@tilua/compiler 1.0.0

package/dist/chunk-S5C4VH6A.js

@@ -0,0 +1,2310 @@
+// src/config.ts
+import { resolve } from "path";
+import { findConfig, loadConfig, nodeHost } from "@tilua/parser";
+function resolveConfig(input, entry, cwd = process.cwd()) {
+  if (input === void 0) return findConfig(entry);
+  if (typeof input === "string") return loadConfig(resolve(cwd, input));
+  const path = resolve(cwd, "tilua.config.json");
+  const text = JSON.stringify(input, null, 2);
+  return loadConfig(path, { readFile: (file) => file === path ? text : nodeHost.readFile(file) });
+}
+
+// src/lower.ts
+import { formatType } from "@tilua/parser";
+import { parse as parseLuau } from "luau-parser";
+
+// src/luau.ts
+var NO_SPAN = { line: { start: 0, end: 0 }, column: { start: 0, end: 0 } };
+var span = () => ({ line: { ...NO_SPAN.line }, column: { ...NO_SPAN.column } });
+var identifier = (name) => ({ type: "Identifier", name, ...span() });
+var nil = () => ({ type: "NilLiteral", ...span() });
+var boolean = (value) => ({ type: "BooleanLiteral", value, ...span() });
+var number = (value, raw = String(value)) => ({ type: "NumberLiteral", value, raw, ...span() });
+var string = (value) => ({ type: "StringLiteral", value, raw: "", ...span() });
+var member = (object, property) => isLuauName(property) ? { type: "MemberExpression", object, property: identifier(property), ...span() } : index(object, string(property));
+var index = (object, key) => ({ type: "IndexExpression", object, index: key, ...span() });
+var call = (callee, args) => ({ type: "CallExpression", callee, arguments: args, ...span() });
+var methodCall = (object, method, args) => ({ type: "MethodCallExpression", object, method: identifier(method), arguments: args, ...span() });
+var functionExpression = (func) => ({ type: "FunctionExpression", func, ...span() });
+var binary = (operator, left, right) => ({ type: "BinaryExpression", operator, 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() });
+var field = (key, value) => isLuauName(key) ? { type: "TableFieldNamed", name: identifier(key), value } : { type: "TableFieldComputed", key: string(key), value };
+var block = (statements) => ({ type: "Block", statements, ...span() });
+var local = (names, init) => ({
+  type: "LocalStatement",
+  names: names.map((name) => ({ type: "TypedIdentifier", name, ...span() })),
+  init,
+  ...span()
+});
+var assign = (targets, values) => ({ type: "AssignmentStatement", targets, values, ...span() });
+var callStatement = (expression) => ({ type: "CallStatement", expression, ...span() });
+var ifThen = (condition, body) => ({
+  type: "IfStatement",
+  clauses: [{ type: "IfClause", condition, body: block(body), ...span() }],
+  ...span()
+});
+var doBlock = (body) => ({ type: "DoStatement", body: block(body), ...span() });
+var breakStatement = () => ({ type: "BreakStatement", ...span() });
+var repeatUntil = (body, condition) => ({ type: "RepeatStatement", body: block(body), condition, ...span() });
+var genericFor = (variables, iterators, body) => ({
+  type: "GenericForStatement",
+  variables: variables.map((name) => ({ type: "TypedIdentifier", name, ...span() })),
+  iterators,
+  body: block(body),
+  ...span()
+});
+var numericFor = (variable, start, end, body) => ({
+  type: "NumericForStatement",
+  variable: { type: "TypedIdentifier", name: variable, ...span() },
+  start,
+  end,
+  body: block(body),
+  ...span()
+});
+var returns = (args) => ({ type: "ReturnStatement", arguments: args, ...span() });
+var functionBody = (params, statements, hasVarargs = false) => ({
+  type: "FunctionBody",
+  generics: [],
+  params: params.map((name) => ({ type: "FunctionParameter", name, ...span() })),
+  hasVarargs,
+  body: block(statements),
+  ...span()
+});
+var localFunction = (name, func) => ({ type: "LocalFunctionStatement", name: identifier(name), func, ...span() });
+var program = (statements) => ({ type: "Program", body: block(statements), ...span() });
+var LUAU_KEYWORDS = /* @__PURE__ */ new Set([
+  "and",
+  "break",
+  "do",
+  "else",
+  "elseif",
+  "end",
+  "false",
+  "for",
+  "function",
+  "if",
+  "in",
+  "local",
+  "nil",
+  "not",
+  "or",
+  "repeat",
+  "return",
+  "then",
+  "true",
+  "until",
+  "while"
+]);
+function isLuauName(name) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) && !LUAU_KEYWORDS.has(name);
+}
+
+// src/console.ts
+var CONSOLE_RUNTIME = `
+local __NAME__ = (function()
+    local console = {}
+    local MAX_DEPTH = 4
+    local ESCAPES = { ["\\n"] = "\\\\n", ["\\r"] = "\\\\r", ["\\t"] = "\\\\t", ["\\""] = "\\\\\\"", ["\\\\"] = "\\\\\\\\" }
+
+    local function quote(text)
+        return '"' .. text:gsub('[%c"\\\\]', function(c) return ESCAPES[c] or ("\\\\%d"):format(c:byte()) end) .. '"'
+    end
+
+    -- A table with 1..n and nothing else prints as a list, as it was written.
+    local function isArray(value)
+        local count = 0
+        for key in pairs(value) do
+            if type(key) ~= "number" then return false end
+            count = count + 1
+        end
+        return count == #value
+    end
+
+    local function isIdentifier(key)
+        return type(key) == "string" and key:match("^[A-Za-z_][A-Za-z0-9_]*$") ~= nil
+    end
+
+    local render
+
+    local function renderTable(value, meta, seen, depth, indent)
+        if seen[value] then return "<cycle>" end
+        if depth > MAX_DEPTH then return "..." end
+        seen[value] = true
+        local inner = indent .. "  "
+        local parts = {}
+        if isArray(value) then
+            for i = 1, #value do
+                parts[#parts + 1] = inner .. render(value[i], nil, seen, depth + 1, inner)
+            end
+        else
+            local keys = {}
+            for key in pairs(value) do keys[#keys + 1] = key end
+            table.sort(keys, function(a, b) return tostring(a) < tostring(b) end)
+            for _, key in ipairs(keys) do
+                local name = isIdentifier(key) and key or ("[" .. render(key, nil, seen, depth + 1, inner) .. "]")
+                parts[#parts + 1] = inner .. name .. " = " .. render(value[key], nil, seen, depth + 1, inner)
+            end
+        end
+        seen[value] = nil
+        if #parts == 0 then return "{}" end
+        local open = isArray(value) and "[" or "{"
+        local close = isArray(value) and "]" or "}"
+        return open .. "\\n" .. table.concat(parts, ",\\n") .. "\\n" .. indent .. close
+    end
+
+    -- \`meta\` is what the compiler knew about this value and the runtime cannot:
+    -- a function's type, and the code it was written as.
+    render = function(value, meta, seen, depth, indent)
+        local kind = type(value)
+        if kind == "string" then return quote(value) end
+        if kind == "number" or kind == "boolean" or kind == "nil" then return tostring(value) end
+        if kind == "function" then
+            if meta == nil then return "function" end
+            if meta[2] == nil or meta[2] == "" then return meta[1] end
+            return meta[1] .. "  " .. meta[2]
+        end
+        if kind == "table" then
+            local shown = rawget(value, "__tostring") == nil and getmetatable(value)
+            -- A value with its own \`__tostring\` (a Roblox Vector3, a class
+            -- instance that says how it reads) is trusted to describe itself.
+            if shown ~= nil and rawget(shown, "__tostring") ~= nil then return tostring(value) end
+            return renderTable(value, meta, seen, depth, indent)
+        end
+        return tostring(value)
+    end
+
+    local function describe(meta, index, value)
+        return render(value, meta ~= nil and meta[index] or nil, {}, 1, "")
+    end
+
+    local function join(meta, count, ...)
+        local parts = {}
+        for i = 1, count do
+            parts[#parts + 1] = describe(meta, i, (select(i, ...)))
+        end
+        return table.concat(parts, " ")
+    end
+
+    -- A line of the bundle, as the place in the project that wrote it.
+    local lines = __LINES__
+    local function place(line)
+        local origin = lines ~= nil and lines[tonumber(line)]
+        if origin == nil then return nil end
+        return origin[1] .. ":" .. tostring(origin[2])
+    end
+
+    -- Luau names the bundle in every frame; the project's files are what the
+    -- reader knows. Frames the map has nothing for are dropped: they are this
+    -- runtime's own, and the bundle's.
+    local function trace(level)
+        local raw = debug.traceback(nil, level)
+        local out = {}
+        for frame in raw:gmatch("[^\\n]+") do
+            local line = frame:match(":(%d+)")
+            local at = line ~= nil and place(line) or nil
+            if at ~= nil then
+                local name = frame:match("function ([%w_.:]+)")
+                out[#out + 1] = "    at " .. at .. (name ~= nil and (" (" .. name .. ")") or "")
+            end
+        end
+        return table.concat(out, "\\n")
+    end
+
+    -- Never on the caller's thread: reporting a problem must not become one.
+    local detach = (task ~= nil and task.spawn) or function(f) return f() end
+
+    local function raise(prefix, meta, count, ...)
+        local message = prefix .. join(meta, count, ...)
+        local where = trace(3)
+        detach(function()
+            error(where ~= "" and (message .. "\\n" .. where) or message, 0)
+        end)
+    end
+
+    function console.log(meta, ...)
+        print(join(meta, select("#", ...), ...))
+    end
+
+    function console.warn(meta, ...)
+        raise("[warn] ", meta, select("#", ...), ...)
+    end
+
+    function console.error(meta, ...)
+        raise("", meta, select("#", ...), ...)
+    end
+
+    return console
+end)()
+`;
+
+// src/names.ts
+var Names = class _Names {
+  constructor(taken) {
+    this.taken = taken;
+  }
+  taken;
+  /** The names `programs` mention — a bundle takes every module's, so that
+   *  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) => {
+      if (!value || typeof value !== "object") return;
+      if (Array.isArray(value)) {
+        for (const item of value) walk(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);
+      }
+    };
+    for (const program2 of programs) walk(program2);
+    return new _Names(taken);
+  }
+  /** A copy that goes on to take names independently — one per module, each
+   *  starting from what the whole bundle already takes. */
+  fork() {
+    return new _Names(new Set(this.taken));
+  }
+  /** `base`, or `base2`, `base3`, ... — whichever is free first. */
+  fresh(base) {
+    let name = base;
+    for (let n = 2; this.taken.has(name); n++) name = `${base}${n}`;
+    this.taken.add(name);
+    return name;
+  }
+};
+
+// src/lower.ts
+function lower(program2, scopes, options = {}) {
+  return new Lowerer(program2, scopes, options).run();
+}
+var Lowerer = class {
+  constructor(source, scopes, options) {
+    this.source = source;
+    this.scopes = scopes;
+    this.options = options;
+    this.lua51 = options.target === "lua51";
+    this.names = options.names ? options.names.fork() : Names.from(source);
+    this.exportsName = this.names.fresh("exports");
+    for (const binding of scopes.bindings.values()) {
+      if (binding.declarationNode) this.bindingByDeclaration.set(binding.declarationNode, binding);
+    }
+  }
+  source;
+  scopes;
+  options;
+  names;
+  diagnostics = [];
+  helpers = /* @__PURE__ */ new Map();
+  /** The binding each declaration node creates. */
+  bindingByDeclaration = /* @__PURE__ */ new Map();
+  /** tilua names that are Luau keywords, and what they are called instead. */
+  renamed = /* @__PURE__ */ new Map();
+  /** Bindings read through something else: an export through `exports.x`,
+   *  an import through its module's table. */
+  rewrites = /* @__PURE__ */ new Map();
+  exportsName;
+  /** Globals generated code calls, renamed where the source shadows them. */
+  builtins = /* @__PURE__ */ new Map();
+  /** Whether the output has to be plain Lua 5.1 rather than Luau. */
+  lua51;
+  /** The source line each emitted statement came from. */
+  origins = /* @__PURE__ */ new WeakMap();
+  run() {
+    const body = this.options.module ? this.module(this.options.module) : this.topLevel(this.source.body.statements);
+    const helpers = this.helperDefinitions();
+    const captured = [...this.builtins].map(([global, local2]) => local([local2], [identifier(global)]));
+    return {
+      statements: [...captured, ...helpers, ...this.classRuntimeStatements(), ...body],
+      exportsName: this.exportsName,
+      module: this.info,
+      diagnostics: this.diagnostics,
+      origins: this.origins
+    };
+  }
+  report(node, message) {
+    this.diagnostics.push({ message, line: node.line.start, column: node.column.start });
+  }
+  // --------------------------------------------------------
+  // Names
+  // --------------------------------------------------------
+  /** A tilua name as Luau can write it: `local` is a keyword there. */
+  name(name) {
+    if (!LUAU_KEYWORDS.has(name)) return name;
+    let renamed = this.renamed.get(name);
+    if (!renamed) {
+      renamed = this.names.fresh(`${name}_`);
+      this.renamed.set(name, renamed);
+    }
+    return renamed;
+  }
+  bindingIdOf(node) {
+    return this.scopes.bindingOf.get(node) ?? this.bindingByDeclaration.get(node)?.id;
+  }
+  /** How Luau refers to a name: its own local, or what it was rewritten to. */
+  reference(node) {
+    const id = this.bindingIdOf(node);
+    const rewrite = id === void 0 ? void 0 : this.rewrites.get(id);
+    return rewrite ? rewrite() : identifier(this.name(node.name));
+  }
+  /** A global the generated code calls — `pairs`, `table`, ... — under a name
+   *  the source cannot have shadowed. */
+  builtin(global) {
+    let local2 = this.builtins.get(global);
+    if (!local2) {
+      const shadowed = [...this.scopes.bindings.values()].some((b) => b.name === global && b.kind !== "global");
+      if (!shadowed) return identifier(global);
+      local2 = this.names.fresh(`tilua_${global}`);
+      this.builtins.set(global, local2);
+    }
+    return identifier(local2);
+  }
+  helper(kind) {
+    let name = this.helpers.get(kind);
+    if (!name) {
+      name = this.names.fresh(`tilua_${kind}`);
+      this.helpers.set(kind, name);
+    }
+    return identifier(name);
+  }
+  /** The local a library's runtime table gets in this file, emitting it the
+   *  first time something asks. Keyed by library and by the key the library
+   *  itself chose, so two libraries' tables never collide. */
+  loweringRuntime(index2, runtime2) {
+    const key = `${index2}:${runtime2}`;
+    let name = this.loweringNames.get(key);
+    if (!name) {
+      name = this.names.fresh(`tilua_${runtime2.replace(/[^A-Za-z0-9_]/g, "_")}`);
+      this.loweringNames.set(key, name);
+      this.loweringUsed.push({ index: index2, runtime: runtime2, name });
+    }
+    return name;
+  }
+  loweringNames = /* @__PURE__ */ new Map();
+  loweringUsed = [];
+  /** What a library says `receiver:method(...)` is. The last library
+   *  loaded is asked first, so a project's own library can answer for a
+   *  method an earlier one also claims; no answer leaves an ordinary Luau
+   *  method call, which is what a value that answers to the method itself
+   *  wants (`text:upper()`). */
+  /** `console:log(a, f)` and its two siblings.
+   *
+   *  Handled here rather than through a library's lowering because what they
+   *  need is not a different callee but *more than was written*: a function
+   *  prints as its type and its code, and neither survives to runtime. The
+   *  compiler is the only thing that has both, so it passes them along:
+   *
+   *      console:log(a, double)
+   *      -- becomes
+   *      tilua_console.log({ [2] = { "(x: number) => number", "(x: number) => x * 2" } }, a, double)
+   *
+   *  The meta table is `nil` when nothing was worth saying, which is most
+   *  calls. `console` itself is never passed: it holds nothing. */
+  consoleCall(node) {
+    if (node.object.type !== "Identifier" || node.object.name !== "console") return void 0;
+    const method = node.method.name;
+    if (method !== "log" && method !== "warn" && method !== "error") return void 0;
+    const binding = this.scopes.bindingOf.get(node.object);
+    if (binding !== void 0 && this.scopes.bindings.get(binding)?.kind !== "global") return void 0;
+    const meta = this.consoleMeta(node.arguments);
+    return call(
+      member(this.helper("console"), method),
+      [meta ?? nil(), ...this.values(node.arguments)]
+    );
+  }
+  /** What the compiler knows about the arguments and the runtime cannot:
+   *  for each function argument, the type it was inferred as and the code it
+   *  was written as. Keyed by position, so an argument that needs nothing
+   *  costs nothing. */
+  consoleMeta(args) {
+    const fields = [];
+    args.forEach((argument, index2) => {
+      const type = this.options.types?.typeOf.get(argument);
+      if (!type || !isFunctionType(type)) return;
+      const written = this.writtenSource(this.declarationOf(argument) ?? argument);
+      fields.push({
+        type: "TableFieldComputed",
+        key: number(index2 + 1),
+        value: table([
+          { type: "TableFieldPositional", value: string(formatType(type)) },
+          { type: "TableFieldPositional", value: string(written) }
+        ])
+      });
+    });
+    return fields.length ? table(fields) : void 0;
+  }
+  /** What a name was declared as: the value of `const f = ...`, or the whole
+   *  `function f() { ... }`. Built once, on the first `console` call that
+   *  needs it — most files have none. */
+  declarationOf(argument) {
+    if (argument.type !== "Identifier") return void 0;
+    if (!this.declarations) {
+      this.declarations = /* @__PURE__ */ new Map();
+      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);
+          });
+        } else if (statement.type === "FunctionDeclaration") {
+          const binding = this.bindingByDeclaration.get(statement.name);
+          if (binding) this.declarations.set(binding.id, statement);
+        }
+      }
+    }
+    const id = this.scopes.bindingOf.get(argument);
+    return id === void 0 ? void 0 : this.declarations.get(id);
+  }
+  declarations;
+  /** The source `node` was written as, read straight out of the file. */
+  writtenSource(node) {
+    const source = this.options.source;
+    if (source === void 0) return "";
+    const lines = source.split(/\r?\n/);
+    if (node.line.start === node.line.end) {
+      return (lines[node.line.start - 1] ?? "").slice(node.column.start - 1, node.column.end - 1);
+    }
+    const first = (lines[node.line.start - 1] ?? "").slice(node.column.start - 1);
+    const middle = lines.slice(node.line.start, node.line.end - 1);
+    const last = (lines[node.line.end - 1] ?? "").slice(0, node.column.end - 1);
+    const indent = /^\s*/.exec(lines[node.line.start - 1] ?? "")[0];
+    const trim = (line) => line.startsWith(indent) ? line.slice(indent.length) : line;
+    return [first, ...middle.map(trim), trim(last)].join("\n");
+  }
+  loweredMethodCall(node) {
+    const lowerings = this.options.lowerings;
+    if (!lowerings?.length) return void 0;
+    const receiver = this.options.types?.typeOf.get(node.object);
+    for (let i = lowerings.length - 1; i >= 0; i--) {
+      const answer = lowerings[i].plugin.methodCall?.({
+        method: node.method.name,
+        receiver,
+        argumentCount: node.arguments.length,
+        use: (runtime2) => this.loweringRuntime(i, runtime2)
+      });
+      if (answer) return { callee: answer.callee, passReceiver: answer.passReceiver !== false };
+    }
+    return void 0;
+  }
+  helperDefinitions() {
+    const out = [];
+    const assign2 = this.helpers.get("assign");
+    if (assign2) {
+      out.push(localFunction(assign2, functionBody(["target"], [
+        numericFor("i", number(1), selectCount(this.builtin("select")), [
+          local(["source"], [call(this.builtin("select"), [identifier("i"), vararg()])]),
+          ifThen(binary("~=", identifier("source"), nil()), [
+            genericFor(["key", "value"], [call(this.builtin("pairs"), [identifier("source")])], [
+              assign([index(identifier("target"), identifier("key"))], [identifier("value")])
+            ])
+          ])
+        ]),
+        returns([identifier("target")])
+      ], true)));
+    }
+    for (const { index: index2, runtime: runtime2, name } of this.loweringUsed) {
+      const { plugin, from } = this.options.lowerings[index2];
+      const source = plugin.runtime?.[runtime2];
+      if (source === void 0) {
+        this.diagnostics.push({
+          message: `'${from}' asked for a runtime it does not have: '${runtime2}'`,
+          line: 1,
+          column: 1
+        });
+        continue;
+      }
+      out.push(...parseLuau(source.replace(/__NAME__/g, name)).body.statements);
+    }
+    const console = this.helpers.get("console");
+    if (console) {
+      const lines = this.options.module?.lines ?? "nil";
+      out.push(...parseLuau(CONSOLE_RUNTIME.replace(/__NAME__/g, console).replace(/__LINES__/g, lines)).body.statements);
+    }
+    const concat = this.helpers.get("concat");
+    if (concat) {
+      out.push(localFunction(concat, functionBody([], [
+        local(["result"], [table([])]),
+        numericFor("i", number(1), selectCount(this.builtin("select")), [
+          local(["part"], [call(this.builtin("select"), [identifier("i"), vararg()])]),
+          callStatement(call(member(this.builtin("table"), "move"), [
+            identifier("part"),
+            number(1),
+            unary("#", identifier("part")),
+            binary("+", unary("#", identifier("result")), number(1)),
+            identifier("result")
+          ]))
+        ]),
+        returns([identifier("result")])
+      ], true)));
+    }
+    return out;
+  }
+  // --------------------------------------------------------
+  // Modules
+  // --------------------------------------------------------
+  info = { names: [], links: [], stars: [], exports: false };
+  /** The module body, in the order an ES module runs:
+   *
+   *    local a, b, util          -- every top-level name, declared first
+   *    function exports.f() ...  -- every top-level function, hoisted
+   *    util = require("util")    -- the imports
+   *    ...                       -- the rest, in source order */
+  module(context) {
+    const statements = this.source.body.statements;
+    const exportsTable = () => identifier(this.exportsName);
+    const { names, links, stars } = this.info;
+    const locals = [];
+    const requires = [];
+    const moduleLocals = /* @__PURE__ */ new Map();
+    const importedFrom = /* @__PURE__ */ new Map();
+    const resolve3 = (source) => {
+      const key = context.resolve(source.value);
+      if (key === void 0) this.report(source, `Cannot find module '${source.value}'`);
+      return key;
+    };
+    const moduleLocal = (key) => {
+      let local2 = moduleLocals.get(key);
+      if (!local2) {
+        local2 = this.names.fresh(moduleName(key));
+        moduleLocals.set(key, local2);
+        locals.push(local2);
+        requires.push(assign([identifier(local2)], [call(context.require, [string(key)])]));
+      }
+      return local2;
+    };
+    const load = (key) => {
+      if (!moduleLocals.has(key)) requires.push(callStatement(call(context.require, [string(key)])));
+    };
+    const exportBinding = (node, exported) => {
+      const binding = node && this.bindingByDeclaration.get(node);
+      if (!binding) return;
+      const existing = this.rewrites.get(binding.id);
+      if (existing) {
+        const first = memberChain(existing());
+        links.push({ name: exported, module: context.name, imported: first?.[first.length - 1] });
+        return;
+      }
+      names.push(exported);
+      this.rewrites.set(binding.id, () => member(exportsTable(), exported));
+    };
+    for (const statement of statements) {
+      if (statement.type !== "ImportStatement" || statement.isTypeOnly) 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 key = resolve3(statement.source);
+      if (key === void 0) continue;
+      const local2 = moduleLocal(key);
+      for (const s of used) {
+        const binding = this.bindingByDeclaration.get(s.local);
+        importedFrom.set(binding.id, { module: key, imported: s.imported });
+        const imported = s.imported;
+        this.rewrites.set(binding.id, imported === void 0 ? () => identifier(local2) : () => member(identifier(local2), imported));
+      }
+    }
+    for (const statement of statements) {
+      switch (statement.type) {
+        case "ExportStatement": {
+          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);
+          break;
+        }
+        case "ExportDefaultStatement":
+          names.push("default");
+          break;
+        case "ExportNamedStatement": {
+          if (statement.source) {
+            const key = resolve3(statement.source);
+            if (key === void 0) break;
+            load(key);
+            for (const s of statement.specifiers) links.push({ name: s.exported.name, module: key, imported: s.local.name });
+            break;
+          }
+          for (const s of statement.specifiers) {
+            const declaration = topLevelDeclaration(statements, s.local.name);
+            const binding = declaration && this.bindingByDeclaration.get(declaration.node);
+            const from = binding && importedFrom.get(binding.id);
+            if (from) links.push({ name: s.exported.name, ...from });
+            else if (declaration?.type === "Declaration") exportBinding(declaration.node, s.exported.name);
+          }
+          break;
+        }
+        case "ExportAllStatement": {
+          const key = resolve3(statement.source);
+          if (key === void 0) break;
+          load(key);
+          stars.push(key);
+          break;
+        }
+      }
+    }
+    this.info.exports = names.length > 0 || links.length > 0 || stars.length > 0;
+    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)) {
+          if (!this.isRewritten(pattern)) locals.push(this.name(pattern.name));
+        }
+      } else if ((declaration.type === "FunctionDeclaration" || declaration.type === "ClassDeclaration") && !this.isRewritten(declaration.name)) {
+        locals.push(this.name(declaration.name.name));
+      }
+    }
+    const hoisted = [];
+    const body = [];
+    for (const statement of statements) {
+      const declaration = statement.type === "ExportStatement" ? statement.declaration : statement;
+      if (declaration.type === "FunctionDeclaration") {
+        hoisted.push(this.from(this.functionStatement(
+          this.reference(declaration.name),
+          declaration,
+          this.functionBody(declaration.func),
+          false
+        ), declaration));
+        continue;
+      }
+      if (declaration.type === "ClassDeclaration") {
+        body.push(...this.classDeclaration(declaration, "assign"));
+        continue;
+      }
+      switch (declaration.type) {
+        case "VariableDeclaration":
+          body.push(...this.variableDeclaration(declaration, "assign"));
+          break;
+        case "ExportDefaultStatement": {
+          const exported = declaration.declaration;
+          if (exported.type === "ClassDeclaration") {
+            body.push(...this.classDeclaration(exported, "assign"));
+            body.push(assign([member(exportsTable(), "default")], [this.reference(exported.name)]));
+          } else {
+            body.push(assign([member(exportsTable(), "default")], [this.expression(exported)]));
+          }
+          break;
+        }
+        case "ReturnStatement":
+          if (declaration.arguments.length) this.report(declaration, "A module cannot return a value; export it instead");
+          body.push(returns([]));
+          break;
+        case "ImportStatement":
+        case "ExportNamedStatement":
+        case "ExportAllStatement":
+          break;
+        default:
+          body.push(...this.statement(declaration));
+      }
+    }
+    const declarations = [];
+    for (let i = 0; i < locals.length; i += 100) declarations.push(local(locals.slice(i, i + 100), []));
+    return [...declarations, ...hoisted, ...requires, ...body];
+  }
+  /** Is `expression` a table iterated directly — not an iterator function
+   *  such as `pairs(t)` or `string.gmatch(s, p)`? Known from its type. */
+  iteratesTable(expression) {
+    const types = this.options.types;
+    const type = types?.typeOf.get(expression);
+    if (!types || !type) return false;
+    const seen = /* @__PURE__ */ new Set();
+    const table2 = (t) => {
+      if (seen.has(t)) return false;
+      seen.add(t);
+      switch (t.kind) {
+        case "array":
+        case "tuple":
+          return true;
+        case "object":
+          return !t.class;
+        case "union":
+          return t.types.every((m) => m.kind === "primitive" && m.name === "nil" || table2(m));
+        case "intersection":
+          return t.types.some(table2);
+        case "genericRef": {
+          const alias = types.aliases.get(t.name);
+          return alias !== void 0 && table2(alias);
+        }
+        default:
+          return false;
+      }
+    };
+    return table2(type);
+  }
+  isRewritten(node) {
+    const binding = this.bindingByDeclaration.get(node);
+    return binding !== void 0 && this.rewrites.has(binding.id);
+  }
+  // --------------------------------------------------------
+  // Statements
+  // --------------------------------------------------------
+  block(block2, prelude = []) {
+    return block([...prelude, ...this.blockStatements(block2.statements)]);
+  }
+  // --------------------------------------------------------
+  // Hoisting
+  // --------------------------------------------------------
+  //
+  // A function declaration is visible to its whole block. Luau's
+  // `local function f` is not, so a function something above it refers to is
+  // declared as a local at the top of the block and assigned where it is
+  // written: another function's body can call it once the block has run
+  // that far. (Calling it straight away, above its declaration, is an error
+  // scope analysis reports.) A bundle's module and a file's top level hoist
+  // the whole function instead.
+  /** Declarations in `statements` that something before them reads: a
+   *  function called above it, or a value a closure in its own initializer
+   *  reads (`local t = { f = function() return t end }`). Lua's `local`
+   *  starts after its statement, so those names are declared at the top of
+   *  the block and assigned where they are written. */
+  referencedAhead(statements) {
+    const functions = /* @__PURE__ */ new Set();
+    const classes = /* @__PURE__ */ new Set();
+    const variables = /* @__PURE__ */ new Set();
+    const names = [];
+    const before = (node, line, column) => line < node.line.start || line === node.line.start && column < node.column.start;
+    for (const statement of statements) {
+      if (statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration") {
+        const binding = this.bindingByDeclaration.get(statement.name);
+        if (binding?.references.some((r) => before(statement.name, r.line.start, r.column.start))) {
+          if (statement.type === "ClassDeclaration") classes.add(statement);
+          else functions.add(statement);
+          names.push(this.name(statement.name.name));
+        }
+        continue;
+      }
+      if (statement.type !== "VariableDeclaration") continue;
+      const patterns = statement.names.flatMap(identifierPatterns);
+      const end = { line: { start: statement.line.end }, column: { start: statement.column.end } };
+      const needed = patterns.some((pattern) => {
+        const binding = this.bindingByDeclaration.get(pattern);
+        return binding?.references.some((r) => before(end, r.line.start, r.column.start));
+      });
+      if (!needed) continue;
+      variables.add(statement);
+      for (const pattern of patterns) names.push(this.name(pattern.name));
+    }
+    return { functions, classes, variables, names };
+  }
+  blockStatements(statements) {
+    const ahead = this.referencedAhead(statements);
+    if (!ahead.names.length) return statements.flatMap((s) => this.statement(s));
+    return [
+      local(ahead.names, []),
+      ...statements.flatMap((s) => {
+        if (s.type === "FunctionDeclaration" && ahead.functions.has(s)) {
+          return [this.functionStatement(this.reference(s.name), s, this.functionBody(s.func), false)];
+        }
+        if (s.type === "VariableDeclaration" && ahead.variables.has(s)) {
+          return this.variableDeclaration(s, "assign");
+        }
+        if (s.type === "ClassDeclaration" && ahead.classes.has(s)) {
+          return this.classDeclaration(s, "assign");
+        }
+        return this.statement(s);
+      })
+    ];
+  }
+  /** A file's statements outside a bundle. A function used above its
+   *  declaration is hoisted whole, as in a module: every top-level name is
+   *  declared first, then the functions are defined, then the rest runs. */
+  topLevel(statements) {
+    if (!this.referencedAhead(statements).names.length) return statements.flatMap((s) => this.statement(s));
+    const locals = [];
+    const hoisted = [];
+    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));
+        body.push(...this.variableDeclaration(statement, "assign"));
+      } else if (statement.type === "FunctionDeclaration") {
+        locals.push(this.name(statement.name.name));
+        hoisted.push(this.from(this.functionStatement(
+          this.reference(statement.name),
+          statement,
+          this.functionBody(statement.func),
+          false
+        ), statement));
+      } else if (statement.type === "ClassDeclaration") {
+        locals.push(this.name(statement.name.name));
+        body.push(...this.classDeclaration(statement, "assign"));
+      } else {
+        body.push(...this.statement(statement));
+      }
+    }
+    const declarations = [];
+    for (let i = 0; i < locals.length; i += 100) declarations.push(local(locals.slice(i, i + 100), []));
+    return [...declarations, ...hoisted, ...body];
+  }
+  /** Where each emitted statement came from. A bundle is one Luau file, so
+   *  a line in it says nothing about which of the project's files wrote it;
+   *  this is what lets a traceback be read back into the source. Statements
+   *  are the unit because lines are: an expression shares its statement's.
+   *
+   *  Only statements built without a span of their own are stamped — the few
+   *  that carry one already kept a more exact position. */
+  statement(node) {
+    const emitted = this.statementOf(node);
+    for (const s of emitted) {
+      if (!s.line.start) {
+        s.line = { ...node.line };
+        s.column = { ...node.column };
+      }
+      if (!this.origins.has(s)) this.origins.set(s, node.line.start);
+    }
+    return emitted;
+  }
+  /** Stamps a statement built outside `statement` — a hoisted function, an
+   *  assignment the module wrapper makes — with where it was written. */
+  from(statement, node) {
+    if (!statement.line.start) {
+      statement.line = { ...node.line };
+      statement.column = { ...node.column };
+    }
+    if (!this.origins.has(statement)) this.origins.set(statement, node.line.start);
+    return statement;
+  }
+  statementOf(node) {
+    switch (node.type) {
+      // Types, and what exists only for them.
+      case "TypeAliasStatement":
+      case "ExportTypeAliasStatement":
+      case "DeclareStatement":
+      case "DeclareClassStatement":
+      case "ErrorStatement":
+        return [];
+      case "VariableDeclaration":
+        return this.variableDeclaration(node, "declare");
+      case "FunctionDeclaration":
+        return [{ ...localFunction(this.name(node.name.name), this.functionBody(node.func)), attributes: node.attributes }];
+      case "FunctionDeclarationStatement":
+        return [this.functionDeclarationStatement(node)];
+      case "ClassDeclaration":
+        return this.classDeclaration(node, "declare");
+      case "AssignmentStatement":
+        return this.assignment(node);
+      case "CompoundAssignmentStatement":
+        if (this.lua51) return this.compoundAssignment51(node);
+        return [{
+          type: "CompoundAssignmentStatement",
+          operator: node.operator,
+          target: this.expression(node.target),
+          value: this.expression(node.value),
+          ...spanOf(node)
+        }];
+      case "CallStatement": {
+        const chain = optionalChain(node.expression);
+        if (chain) return [this.optionalCallStatement(chain)];
+        const expression = this.expression(node.expression);
+        if (expression.type !== "CallExpression" && expression.type !== "MethodCallExpression") {
+          this.report(node, "A statement must be a call");
+          return [];
+        }
+        return [callStatement(expression)];
+      }
+      // `value` on a line of its own: written to ask the editor about a
+      // name, and worth nothing once the file is compiled. It cannot be
+      // kept — Lua has no expression statement — and it cannot run
+      // anything, since a call is a `CallStatement` instead, so dropping
+      // it changes nothing but the noise.
+      case "ExpressionStatement":
+        return [];
+      case "DoStatement":
+        return [{ type: "DoStatement", body: this.block(node.body), ...spanOf(node) }];
+      case "WhileStatement":
+        return [{ type: "WhileStatement", condition: this.expression(node.condition), body: this.loopBody51(this.block(node.body)), ...spanOf(node) }];
+      case "RepeatStatement": {
+        const body = this.block(node.body);
+        const condition = this.expression(node.condition);
+        if (this.lua51 && 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.`);
+          }
+        }
+        return [{ type: "RepeatStatement", body: this.loopBody51(body), condition, ...spanOf(node) }];
+      }
+      case "IfStatement":
+        return [{
+          type: "IfStatement",
+          clauses: node.clauses.map((c) => ({
+            type: "IfClause",
+            condition: this.expression(c.condition),
+            body: this.block(c.body),
+            ...spanOf(c)
+          })),
+          alternate: node.alternate && this.block(node.alternate),
+          ...spanOf(node)
+        }];
+      case "NumericForStatement":
+        return [{
+          type: "NumericForStatement",
+          variable: { type: "TypedIdentifier", name: this.name(node.variable.name), ...spanOf(node.variable) },
+          start: this.expression(node.start),
+          end: this.expression(node.end),
+          step: node.step && this.expression(node.step),
+          body: this.loopBody51(this.block(node.body)),
+          ...spanOf(node)
+        }];
+      case "GenericForStatement": {
+        const prelude = [];
+        const variables = node.variables.map((target) => {
+          if (target.type === "IdentifierPattern") return this.name(target.name);
+          const temp = this.names.fresh("item");
+          prelude.push(...this.destructure(target, identifier(temp), "declare"));
+          return temp;
+        });
+        if (variables.length === 1 && node.iterators.length === 1 && this.iteratesTable(node.iterators[0])) {
+          variables.unshift(this.names.fresh("_"));
+        }
+        return [genericFor(
+          variables,
+          node.iterators.map((e) => this.expression(e)),
+          this.loopBody51(this.block(node.body, prelude)).statements
+        )];
+      }
+      case "ReturnStatement":
+        return [returns(this.values(node.arguments))];
+      case "BreakStatement":
+        return [{ type: "BreakStatement", ...spanOf(node) }];
+      case "ContinueStatement":
+        return [{ type: "ContinueStatement", ...spanOf(node) }];
+      case "ImportStatement":
+        if (node.isTypeOnly) return [];
+        this.report(node, this.options.module ? "Imports and exports belong at the top level of a module" : "Imports and exports need a bundle: build the project with @tilua/compiler");
+        return [];
+      case "ExportStatement":
+      case "ExportDefaultStatement":
+      case "ExportNamedStatement":
+      case "ExportAllStatement":
+        this.report(node, this.options.module ? "Imports and exports belong at the top level of a module" : "Imports and exports need a bundle: build the project with @tilua/compiler");
+        return [];
+    }
+  }
+  functionDeclarationStatement(node) {
+    const statement = this.functionStatement(this.reference(node.target.base), node, this.functionBody(node.func), node.isMethod, node.target.path.map((p) => p.name));
+    if (!node.target.method) return statement;
+    return { ...statement, target: { ...statement.target, method: identifier(node.target.method.name) } };
+  }
+  /** `function a.b.c()`, for a target written as an expression. */
+  // ============================================================
+  // `class ... end`
+  // ------------------------------------------------------------
+  // The shape is Lua's own, and the memory model the language
+  // promises: one table per class holding its methods and its
+  // statics, and one table per instance whose metatable points at
+  // it. An instance reaches its class directly — nothing is copied
+  // per instance, and there is no prototype chain of its own.
+  //
+  //     local Dog = __class(Animal)
+  //     function Dog.__init(this, name)
+  //         Animal.__init(this, name)      -- super(name)
+  //         this.breed = "corgi"           -- a field initializer
+  //     end
+  //     function Dog.new(...)
+  //         local this = setmetatable({}, Dog)
+  //         Dog.__init(this, ...)
+  //         return this
+  //     end
+  //     function Dog.speak(this) ... end
+  //
+  // `new Dog(x)` is `Dog.new(x)`, `dog:speak()` passes the instance
+  // as `this`, and `super.speak()` is `Animal.speak(this)` — the
+  // base's own function, run on this instance.
+  // ============================================================
+  /** The locals the file's classes are built with, named once. */
+  classHelpers;
+  classRuntime() {
+    return this.classHelpers ??= {
+      build: this.names.fresh("tilua_class"),
+      accessors: this.names.fresh("tilua_accessors")
+    };
+  }
+  /** The helpers, as Luau — emitted only in a file that declares a class.
+   *  `__getters`/`__setters` chain to the base's, so a derived class sees
+   *  the accessors it inherits; `__index` only becomes a function for a
+   *  class that has some, which leaves every other class on the plain
+   *  `__index = class` fast path.
+   *
+   *  `ClassObject` and `ParentClass` are the links the memory model
+   *  promises: an instance reads `ClassObject` through its metatable and
+   *  lands on its own class, and a class reads `ParentClass` and lands on
+   *  the one it extends. Both live on the class table, so an instance
+   *  carries neither. */
+  classRuntimeStatements() {
+    if (!this.classHelpers) return [];
+    const { build, accessors } = this.classHelpers;
+    return parseLuau(`
+local function ${build}(base)
+    local class = { __getters = {}, __setters = {} }
+    class.__index = class
+    class.ClassObject = class
+    class.ParentClass = base
+    if base ~= nil then
+        setmetatable(class, { __index = base })
+        setmetatable(class.__getters, { __index = base.__getters })
+        setmetatable(class.__setters, { __index = base.__setters })
+    end
+    return class
+end
+local function ${accessors}(class)
+    if not class.__dynamic and next(class.__getters) == nil and next(class.__setters) == nil then
+        return
+    end
+    class.__dynamic = true
+    class.__index = function(this, key)
+        local getter = class.__getters[key]
+        if getter ~= nil then
+            return getter(this)
+        end
+        return class[key]
+    end
+    class.__newindex = function(this, key, value)
+        local setter = class.__setters[key]
+        if setter ~= nil then
+            setter(this, value)
+            return
+        end
+        rawset(this, key, value)
+    end
+end
+`).body.statements;
+  }
+  /** The class being lowered, so `super` knows what to name. */
+  classContext;
+  /** A class written where a value goes. Building it takes statements, and
+   *  an expression has no room for them, so they go in a function that runs
+   *  where the class is written and hands the class table back. */
+  classExpression(node) {
+    const local2 = this.names.fresh(node.name ? this.name(node.name.name) : "class");
+    const statements = this.classStatements(node, identifier(local2), local2);
+    return call(parenthesized(functionExpression(
+      functionBody([], [...statements, returns([identifier(local2)])])
+    )), []);
+  }
+  classDeclaration(node, mode) {
+    const name = this.name(node.name.name);
+    return mode === "declare" ? this.classStatements(node, identifier(name), name) : this.classStatements(node, this.reference(node.name));
+  }
+  /** `declare` names the local the class table goes in; without it the
+   *  table is assigned to `self`, which a module has already declared. */
+  classStatements(node, self, declare) {
+    const { build, accessors } = this.classRuntime();
+    const create = call(identifier(build), [node.superclass ? this.reference(node.superclass) : nil()]);
+    const out = [declare !== void 0 ? local([declare], [create]) : assign([self], [create])];
+    const previous = this.classContext;
+    this.classContext = node;
+    try {
+      for (const member2 of node.members) {
+        switch (member2.type) {
+          case "ClassField":
+            if (member2.isStatic) {
+              out.push(assign(
+                [member(self, member2.name.name)],
+                [member2.init ? this.expression(member2.init) : nil()]
+              ));
+            }
+            break;
+          case "ClassMethod":
+            out.push(this.functionStatement(
+              member(self, member2.name.name),
+              member2,
+              this.classFunctionBody(member2.func),
+              false
+            ));
+            break;
+          case "ClassAccessor":
+            out.push(assign(
+              [index(
+                member(self, member2.kind === "get" ? "__getters" : "__setters"),
+                string(member2.name.name)
+              )],
+              [functionExpression(this.classFunctionBody(member2.func))]
+            ));
+            break;
+          case "ClassConstructor":
+            break;
+        }
+      }
+      out.push(this.classInit(node, self));
+      out.push(this.classNew(node, self));
+      out.push(callStatement(call(identifier(accessors), [self])));
+    } finally {
+      this.classContext = previous;
+    }
+    return out;
+  }
+  /** `Class.__init(this, ...)` — what every instance of the class runs.
+   *  Kept apart from `new` so `super(...)` can run the base's on the
+   *  instance already being built rather than making a second one. */
+  classInit(node, self) {
+    const instance = this.thisName();
+    const initializers = node.members.filter((m) => m.type === "ClassField" && !m.isStatic && m.init !== void 0).map((field2) => assign(
+      [member(identifier(instance), field2.name.name)],
+      [this.expression(field2.init)]
+    ));
+    const constructor = node.members.find((m) => m.type === "ClassConstructor");
+    if (!constructor) {
+      const body2 = functionBody([instance], [
+        ...node.superclass ? [callStatement(call(
+          member(this.reference(node.superclass), "__init"),
+          [identifier(instance), vararg()]
+        ))] : [],
+        ...initializers
+      ], true);
+      return this.functionStatement(member(self, "__init"), node, body2, false);
+    }
+    const body = this.classFunctionBody(constructor.func);
+    const statements = body.body.statements;
+    const afterSuper = node.superclass ? statements.findIndex(isSuperInit) + 1 : 0;
+    statements.splice(Math.max(afterSuper, 0), 0, ...initializers);
+    return this.functionStatement(member(self, "__init"), constructor, body, false);
+  }
+  /** `Class.new(...)`: the instance, its metatable, its constructor. */
+  classNew(node, self) {
+    const instance = this.thisName();
+    const body = functionBody([], [
+      local([instance], [call(this.builtin("setmetatable"), [table([]), self])]),
+      callStatement(call(member(self, "__init"), [identifier(instance), vararg()])),
+      returns([identifier(instance)])
+    ], true);
+    return this.functionStatement(member(self, "new"), node, body, false);
+  }
+  /** What `this` is called in emitted code. */
+  thisName() {
+    return this.name("this");
+  }
+  /** A class method keeps its receiver as a written parameter: `:` supplies
+   *  it at the call site, but the declaration spells it out so `super` and
+   *  `new` can pass it by hand. */
+  classFunctionBody(func) {
+    return this.functionBody(func.isMethod ? { ...func, isMethod: false } : func);
+  }
+  /** `super(...)` / `super.m(...)` — the base class, by the name this file
+   *  knows it under. */
+  superClassReference(node) {
+    const superclass = this.classContext?.superclass;
+    if (!superclass) {
+      this.report(node, "'super' is only available inside a class that extends another");
+      return nil();
+    }
+    return this.reference(superclass);
+  }
+  functionStatement(target, node, func, isMethod, path = []) {
+    const chain = memberChain(target);
+    if (!chain) this.report(node, "This function name cannot be written in Luau");
+    const [root, ...prefix] = chain ?? ["_"];
+    return {
+      type: "FunctionDeclarationStatement",
+      target: {
+        type: "FunctionName",
+        base: identifier(root),
+        path: [...prefix, ...path].map(identifier),
+        ...spanOf(node)
+      },
+      isMethod,
+      func,
+      attributes: node.attributes,
+      ...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. */
+  variableDeclaration(node, mode) {
+    if (mode === "assign" && !node.init.length) {
+      const exported = node.names.flatMap(identifierPatterns).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));
+    }
+    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];
+  }
+  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 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");
+      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)];
+  }
+  // --------------------------------------------------------
+  // Destructuring
+  // --------------------------------------------------------
+  /** Bind (or assign) every name in `pattern` from `source`, which must be a
+   *  plain name so that reading it repeatedly has no side effects.
+   *
+   *  The reads share one statement, in the pattern's order —
+   *  `local a, b = source.a, source.b` — with a temporary standing in for a
+   *  nested pattern. Defaults, nested patterns and rest follow it. */
+  destructure(pattern, source, mode) {
+    const keys = [];
+    const reads = [];
+    const after = [];
+    const bind = (target, value, fallback) => {
+      if (target.type === "IdentifierPattern") {
+        const name2 = this.name(target.name);
+        const reference = mode === "declare" ? identifier(name2) : this.reference(target);
+        reads.push({ name: name2, target: reference, value, temp: false });
+        if (fallback) after.push(this.defaultValue(reference, fallback));
+        return;
+      }
+      const name = this.names.fresh("ref");
+      reads.push({ name, target: identifier(name), value, temp: true });
+      if (fallback) after.push(this.defaultValue(identifier(name), fallback));
+      after.push(...this.destructure(target, identifier(name), mode));
+    };
+    if (pattern.type === "ObjectPattern") {
+      const taken = [];
+      for (const property of pattern.properties) {
+        let key;
+        if (!property.computed && (property.key.type === "Identifier" || property.key.type === "StringLiteral")) {
+          const name = property.key.type === "Identifier" ? property.key.name : property.key.value;
+          key = string(name);
+          bind(property.value, member(source, name), property.default);
+        } else {
+          const name = this.names.fresh("key");
+          keys.push({ name, value: this.expression(property.key) });
+          key = identifier(name);
+          bind(property.value, index(source, key), property.default);
+        }
+        taken.push(key);
+      }
+      if (pattern.rest) {
+        const rest = this.restTarget(pattern.rest, table([]), mode, after);
+        const key = this.names.fresh("key");
+        const value = this.names.fresh("value");
+        const kept = taken.reduce((condition, k) => {
+          const differs = binary("~=", identifier(key), k);
+          return condition ? binary("and", condition, differs) : differs;
+        }, void 0);
+        const copy = assign([index(rest.target, identifier(key))], [identifier(value)]);
+        after.push(genericFor([key, value], [call(this.builtin("pairs"), [source])], kept ? [ifThen(kept, [copy])] : [copy]));
+        after.push(...rest.then);
+      }
+    } else {
+      pattern.elements.forEach((element, i) => {
+        if (element) bind(element.value, index(source, number(i + 1)), element.default);
+      });
+      if (pattern.rest) {
+        const elements = call(member(this.builtin("table"), "move"), [
+          source,
+          number(pattern.elements.length + 1),
+          unary("#", source),
+          number(1),
+          table([])
+        ]);
+        const rest = this.restTarget(pattern.rest, elements, mode, after);
+        after.push(...rest.then);
+      }
+    }
+    const out = [];
+    if (keys.length) out.push(local(keys.map((k) => k.name), keys.map((k) => k.value)));
+    if (mode === "declare") {
+      if (reads.length) out.push(local(reads.map((r) => r.name), reads.map((r) => r.value)));
+    } else {
+      const temps = reads.filter((r) => r.temp);
+      const targets = reads.filter((r) => !r.temp);
+      if (temps.length) out.push(local(temps.map((r) => r.name), temps.map((r) => r.value)));
+      if (targets.length) out.push(assign(targets.map((r) => r.target), targets.map((r) => r.value)));
+    }
+    return [...out, ...after];
+  }
+  /** Where a rest element's new table goes: straight into its name, or into
+   *  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 === "IdentifierPattern") {
+      if (mode === "declare") {
+        const name2 = this.name(target.name);
+        after.push(local([name2], [initial]));
+        return { target: identifier(name2), then: [] };
+      }
+      const reference = this.reference(target);
+      after.push(assign([reference], [initial]));
+      return { target: reference, then: [] };
+    }
+    const name = this.names.fresh("rest");
+    after.push(local([name], [initial]));
+    return { target: identifier(name), then: this.destructure(target, identifier(name), mode) };
+  }
+  /** `if target == nil then target = fallback end` */
+  defaultValue(target, fallback) {
+    return ifThen(binary("==", target, nil()), [assign([target], [this.expression(fallback)])]);
+  }
+  // --------------------------------------------------------
+  // Functions
+  // --------------------------------------------------------
+  functionBody(func) {
+    const params = func.isMethod ? func.params.slice(1) : func.params;
+    const prelude = [];
+    const names = [];
+    for (const p of params) {
+      if (p.rest) {
+        prelude.push(local([this.name(p.name)], [table([{ type: "TableFieldPositional", value: vararg() }])]));
+        continue;
+      }
+      const name = p.pattern ? this.names.fresh("arg") : this.name(p.name);
+      if (p.default) prelude.push(this.defaultValue(identifier(name), p.default));
+      if (p.pattern) prelude.push(...this.destructure(p.pattern, identifier(name), "declare"));
+      names.push(name);
+    }
+    return { ...functionBody(names, [], func.hasVarargs), body: this.block(func.body, prelude) };
+  }
+  // --------------------------------------------------------
+  // Expressions
+  // --------------------------------------------------------
+  expression(node) {
+    if (node.type === "CallExpression") {
+      const callee = node.callee;
+      const through = callee.type === "SuperExpression" ? "__init" : callee.type === "MemberExpression" && callee.object.type === "SuperExpression" ? callee.property.name : void 0;
+      if (through !== void 0) {
+        return call(member(this.superClassReference(node), through), [
+          identifier(this.thisName()),
+          ...this.values(node.arguments)
+        ]);
+      }
+    }
+    switch (node.type) {
+      case "Identifier":
+        return this.reference(node);
+      case "NilLiteral":
+        return nil();
+      case "BooleanLiteral":
+        return boolean(node.value);
+      case "NumberLiteral":
+        return number(node.value, this.numberRaw(node));
+      case "StringLiteral":
+        return string(node.value);
+      case "VarargExpression":
+        return vararg();
+      // Only a recovering parse makes one, and a syntax error stops the build.
+      case "ErrorExpression":
+        this.report(node, "Syntax error");
+        return nil();
+      case "InterpolatedStringExpression":
+        return this.interpolatedString(node);
+      case "FunctionExpression":
+        return functionExpression(this.functionBody(node.func));
+      case "TableExpression":
+        return this.tableExpression(node);
+      case "ArrayExpression":
+        return this.arrayExpression(node);
+      case "BinaryExpression": {
+        const left = this.expression(node.left);
+        const right = this.expression(node.right);
+        if (this.lua51 && node.operator === "//") return this.floorDivide(left, right);
+        return binary(node.operator, left, right);
+      }
+      case "UnaryExpression":
+        return unary(node.operator, this.expression(node.argument));
+      case "NewExpression":
+        return call(
+          member(this.expression(node.callee), "new"),
+          this.values(node.arguments)
+        );
+      case "SuperExpression":
+        return this.superClassReference(node);
+      case "SpreadElement":
+        this.report(node, "'...' can only spread into a call's arguments or an array");
+        return nil();
+      case "ClassExpression":
+        return this.classExpression(node);
+      case "MemberExpression":
+      case "IndexExpression":
+      case "CallExpression":
+      case "MethodCallExpression": {
+        const chain = optionalChain(node);
+        if (chain) return this.optionalChainExpression(chain);
+        return this.link(node, this.expression(linkObject(node)));
+      }
+      case "ParenthesizedExpression":
+        return parenthesized(this.expression(node.expression));
+      // Types only: the value is the expression itself.
+      case "TypeAssertionExpression":
+      case "SatisfiesExpression":
+      case "AsConstExpression":
+        return this.expression(node.expression);
+      case "IfElseExpression":
+        if (this.lua51) return this.ifElse51(node);
+        return {
+          type: "IfElseExpression",
+          clauses: node.clauses.map((c) => ({ condition: this.expression(c.condition), body: this.expression(c.body) })),
+          alternate: this.expression(node.alternate),
+          ...spanOf(node)
+        };
+    }
+  }
+  /** 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,
+   *  `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. */
+  values(list) {
+    const spreads = list.filter((a) => a.type === "SpreadElement");
+    if (!spreads.length) return list.map((a) => this.expression(a));
+    const unpack = (value) => call(member(this.builtin("table"), "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))];
+    }
+    return [unpack(this.arrayExpression({
+      type: "ArrayExpression",
+      elements: [...list],
+      ...spanOf(list[0])
+    }))];
+  }
+  /** One link of an access chain, read from `object`. */
+  link(node, object) {
+    switch (node.type) {
+      case "MemberExpression":
+        return member(object, node.property.name);
+      case "IndexExpression":
+        return index(object, this.expression(node.index));
+      case "CallExpression":
+        return call(object, this.values(node.arguments));
+      case "MethodCallExpression": {
+        const consoleCall = this.consoleCall(node);
+        if (consoleCall) return consoleCall;
+        const args = this.values(node.arguments);
+        const lowered = this.loweredMethodCall(node);
+        if (lowered) {
+          return call(calleePath(lowered.callee), lowered.passReceiver ? [object, ...args] : args);
+        }
+        if (!isLuauName(node.method.name)) {
+          this.report(node.method, `'${node.method.name}' is a Luau keyword and cannot be called with ':'`);
+        }
+        return methodCall(object, node.method.name, args);
+      }
+    }
+  }
+  // --------------------------------------------------------
+  // Optional chains
+  // --------------------------------------------------------
+  //
+  // `a?.b.c` is nil when `a` is, and then neither `.b` nor `.c` runs. Each
+  // `?.` tests what the chain holds so far, once: the value is kept in a
+  // local rather than read again.
+  /** The links of a chain from `?.` onwards, split into segments that each
+   *  start at a `?.` / `?:`. */
+  segments(chain) {
+    const out = [];
+    for (const link of chain.links) {
+      if (link.optional || !out.length) out.push([link]);
+      else out[out.length - 1].push(link);
+    }
+    return out;
+  }
+  applySegment(segment, object) {
+    return segment.reduce((value, link) => this.link(link, value), object);
+  }
+  /** `a?.b:m()` as a statement:
+   *  `do local ref = a if ref ~= nil then ref.b:m() end end` */
+  optionalCallStatement(chain) {
+    const segments = this.segments(chain);
+    const base = this.expression(chain.base);
+    const ref = base.type === "Identifier" && segments.length === 1 ? base.name : this.names.fresh("ref");
+    const at = identifier(ref);
+    const nest = (i) => {
+      const value = this.applySegment(segments[i], at);
+      if (i === segments.length - 1) {
+        return [callStatement(value)];
+      }
+      return [assign([at], [value]), ifThen(binary("~=", at, nil()), nest(i + 1))];
+    };
+    const test = ifThen(binary("~=", at, nil()), nest(0));
+    if (base.type === "Identifier" && base.name === ref) return test;
+    return doBlock([local([ref], [base]), test]);
+  }
+  /** `a?.b` as a value. The one-test form on a name is an `if` expression;
+   *  anything else runs in a function, so every link is evaluated at most
+   *  once and in order. */
+  optionalChainExpression(chain) {
+    const segments = this.segments(chain);
+    const base = this.expression(chain.base);
+    const last = chain.links[chain.links.length - 1];
+    if (base.type === "Identifier" && segments.length === 1 && last.type !== "CallExpression" && last.type !== "MethodCallExpression") {
+      return {
+        type: "IfElseExpression",
+        clauses: [{ condition: binary("==", base, nil()), body: nil() }],
+        alternate: this.applySegment(segments[0], base),
+        line: base.line,
+        column: base.column
+      };
+    }
+    const ref = this.names.fresh("ref");
+    const at = identifier(ref);
+    const statements = [local([ref], [base])];
+    segments.forEach((segment, i) => {
+      statements.push(ifThen(binary("==", at, nil()), [returns([nil()])]));
+      const value = this.applySegment(segment, at);
+      statements.push(i === segments.length - 1 ? returns([value]) : assign([at], [value]));
+    });
+    const passesVarargs = statements.some(usesVararg);
+    const func = functionExpression(functionBody([], statements, passesVarargs));
+    return call(parenthesized(func), passesVarargs ? [vararg()] : []);
+  }
+  /** `` `${a} any` `` -> `("%s any"):format(tostring(a))` */
+  interpolatedString(node) {
+    let format = "";
+    let text = "";
+    const args = [];
+    for (const part of node.parts) {
+      if (part.kind === "string") {
+        format += part.value.replace(/%/g, "%%");
+        text += part.value;
+      } else {
+        format += "%s";
+        args.push(call(this.builtin("tostring"), [this.expression(part.expression)]));
+      }
+    }
+    if (!args.length) return string(text);
+    return methodCall(parenthesized(string(format)), "format", args);
+  }
+  /** `a += b` for Lua 5.1, which has no compound assignment: `a = a + b`.
+   *
+   *  The target has to be read and written, and writing it out twice would
+   *  evaluate whatever addresses it twice — `t[next()] += 1` would advance
+   *  twice and add to the wrong slot. So anything but a plain name has its
+   *  object and key taken into locals first, and both halves use those. */
+  compoundAssignment51(node) {
+    const operator = node.operator.slice(0, -1);
+    const before = [];
+    let target;
+    if (node.target.type === "MemberExpression" || node.target.type === "IndexExpression") {
+      const object = this.expression(node.target.object);
+      const objectName = this.names.fresh("target");
+      before.push(local([objectName], [object]));
+      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);
+    }
+    const value = this.expression(node.value);
+    const combined = operator === "//" ? this.floorDivide(target, value) : binary(operator, target, parenthesized(value));
+    const statement = assign([target], [combined]);
+    return before.length ? [doBlock([...before, statement])] : [statement];
+  }
+  /** A loop body for Lua 5.1, which has neither `continue` nor the `goto`
+   *  every other Lua lowers it to.
+   *
+   *  `repeat ... until true` runs its body exactly once, so a `break` inside
+   *  it abandons the rest of the body and lands back in the enclosing loop —
+   *  which is what `continue` means. The catch is that a *real* `break` in
+   *  the same body would now leave only that inner `repeat`, so when the
+   *  body has one it sets a flag that the loop checks once the `repeat` is
+   *  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;
+    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]);
+    return block([
+      local([flag], [boolean(false)]),
+      once,
+      ifThen(identifier(flag), [breakStatement()])
+    ]);
+  }
+  /** `if c then a else b` as an expression, for Lua 5.1, which has none.
+   *
+   *  `c and a or b` is the usual stand-in, but it is wrong whenever `a` can
+   *  be `false` or `nil`: it then yields `b` even though `c` held. So it is
+   *  only used where every branch is written as a value that can be neither,
+   *  and anything else becomes a call — one closure, but always the branch
+   *  that was written. */
+  ifElse51(node) {
+    const clauses = node.clauses.map((c) => ({
+      condition: this.expression(c.condition),
+      body: this.expression(c.body)
+    }));
+    const alternate = this.expression(node.alternate);
+    if (clauses.every((c) => alwaysTruthy(c.body))) {
+      let result = alternate;
+      for (let i = clauses.length - 1; i >= 0; i--) {
+        const { condition, body } = clauses[i];
+        result = binary("or", binary("and", condition, body), result);
+      }
+      return parenthesized(result);
+    }
+    const statement = {
+      type: "IfStatement",
+      clauses: clauses.map((c) => ({
+        type: "IfClause",
+        condition: c.condition,
+        body: block([returns([c.body])]),
+        ...spanOf(node)
+      })),
+      alternate: block([returns([alternate])]),
+      ...spanOf(node)
+    };
+    return call(
+      parenthesized(functionExpression(functionBody([], [statement]))),
+      []
+    );
+  }
+  /** How a number is written out. Luau takes what was written; Lua 5.1 has
+   *  neither digit separators nor binary literals, so `1_000_000` loses its
+   *  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 (/^0[bB]/.test(node.raw)) return String(node.value);
+    return node.raw.replace(/_/g, "");
+  }
+  /** `a // b` for Lua 5.1, which has no floor-division operator. */
+  floorDivide(left, right) {
+    return call(
+      member(this.builtin("math"), "floor"),
+      [binary("/", left, parenthesized(right))]
+    );
+  }
+  /** `{ a: 1, b, [k]: v }`. A spread splits the literal into parts that
+   *  `assign` copies into one table in order, so a later key still wins. */
+  tableExpression(node) {
+    const parts = [];
+    let current = [];
+    for (const f of node.fields) {
+      switch (f.type) {
+        case "TableFieldNamed": {
+          const key = f.key.type === "Identifier" ? f.key.name : f.key.value;
+          current.push(field(key, this.expression(f.value)));
+          break;
+        }
+        case "TableFieldShorthand":
+          current.push(field(f.name.name, this.reference(f.name)));
+          break;
+        case "TableFieldComputed":
+          current.push({ type: "TableFieldComputed", key: this.expression(f.key), value: this.expression(f.value) });
+          break;
+        case "TableFieldSpread":
+          if (current.length) parts.push(table(current));
+          current = [];
+          parts.push(this.expression(f.argument));
+          break;
+      }
+    }
+    if (parts.length === 0) return table(current);
+    if (current.length) parts.push(table(current));
+    return call(this.helper("assign"), [table([]), ...parts]);
+  }
+  /** `[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")) {
+      return table(node.elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
+    }
+    const parts = [];
+    let current = [];
+    const flush = () => {
+      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 };
+      })));
+      current = [];
+    };
+    for (const element of node.elements) {
+      if (element.type === "SpreadElement") {
+        flush();
+        parts.push(this.expression(element.argument));
+      } else {
+        current.push(element);
+      }
+    }
+    flush();
+    return call(this.helper("concat"), parts);
+  }
+};
+function isLink(node) {
+  return node.type === "MemberExpression" || node.type === "IndexExpression" || node.type === "CallExpression" || node.type === "MethodCallExpression";
+}
+function linkObject(node) {
+  return node.type === "CallExpression" ? node.callee : node.object;
+}
+function optionalChain(node) {
+  const spine = [];
+  for (let e = node; isLink(e); e = linkObject(e)) spine.unshift(e);
+  const first = spine.findIndex((link) => link.optional);
+  if (first < 0) return void 0;
+  return { base: linkObject(spine[first]), links: spine.slice(first) };
+}
+function usesVararg(node) {
+  if (Array.isArray(node)) return node.some(usesVararg);
+  if (!node || typeof node !== "object") return false;
+  const record = node;
+  if (record.type === "VarargExpression") return true;
+  if (record.type === "FunctionExpression" || record.type === "LocalFunctionStatement" || record.type === "FunctionStatement") return false;
+  return Object.values(record).some(usesVararg);
+}
+function calleePath(path) {
+  const [head, ...rest] = path.split(".");
+  return rest.reduce((value, name) => member(value, name), identifier(head));
+}
+function spanOf(node) {
+  return { line: node.line, column: node.column };
+}
+function vararg() {
+  return { type: "VarargExpression", line: { start: 0, end: 0 }, column: { start: 0, end: 0 } };
+}
+function selectCount(select) {
+  return call(select, [string("#"), vararg()]);
+}
+function expandsToMany(e) {
+  return e.type === "CallExpression" || e.type === "MethodCallExpression" || e.type === "VarargExpression";
+}
+function isSuperInit(statement) {
+  return statement.type === "CallStatement" && statement.expression.type === "CallExpression" && statement.expression.callee.type === "MemberExpression" && statement.expression.callee.property.name === "__init";
+}
+function memberChain(e) {
+  if (e.type === "Identifier") return [e.name];
+  if (e.type === "MemberExpression") {
+    const base = memberChain(e.object);
+    return base && [...base, e.property.name];
+  }
+  return void 0;
+}
+function identifierPatterns(target) {
+  switch (target.type) {
+    case "IdentifierPattern":
+      return [target];
+    case "ObjectPattern":
+      return [...target.properties.flatMap((p) => identifierPatterns(p.value)), ...target.rest ? identifierPatterns(target.rest) : []];
+    case "ArrayPattern":
+      return [
+        ...target.elements.flatMap((e) => e ? identifierPatterns(e.value) : []),
+        ...target.rest ? identifierPatterns(target.rest) : []
+      ];
+  }
+}
+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);
+      if (pattern) return { type: "Declaration", node: pattern };
+    } else if (declaration.type === "FunctionDeclaration" && declaration.name.name === name) {
+      return { type: "Declaration", node: declaration.name };
+    } else if (declaration.type === "ImportStatement") {
+      const local2 = declaration.defaultImport?.name === name ? declaration.defaultImport : declaration.specifiers.find((s) => s.local.name === name)?.local;
+      if (local2) return { type: "ImportStatement", node: local2 };
+    }
+  }
+  return void 0;
+}
+function moduleName(key) {
+  const last = key.split("/").filter(Boolean).pop() ?? "module";
+  const cleaned = last.replace(/[^A-Za-z0-9_]/g, "_");
+  return /^[A-Za-z_]/.test(cleaned) && !LUAU_KEYWORDS.has(cleaned) ? cleaned : `module_${cleaned}`;
+}
+function alwaysTruthy(value) {
+  switch (value.type) {
+    case "NumberLiteral":
+    case "StringLiteral":
+    case "InterpolatedStringExpression":
+    case "TableExpression":
+    case "FunctionExpression":
+      return true;
+    case "BooleanLiteral":
+      return value.value;
+    case "ParenthesizedExpression":
+      return alwaysTruthy(value.expression);
+    default:
+      return false;
+  }
+}
+function ownBlocks(statement) {
+  switch (statement.type) {
+    case "DoStatement":
+      return [statement.body];
+    case "IfStatement":
+      return [...statement.clauses.map((c) => c.body), ...statement.alternate ? [statement.alternate] : []];
+    default:
+      return [];
+  }
+}
+function hasOwnJump(statements, type) {
+  return statements.some((statement) => statement.type === type || ownBlocks(statement).some((b) => hasOwnJump(b.statements, type)));
+}
+function rewriteOwnJumps(statements, flag) {
+  return statements.flatMap((statement) => {
+    if (statement.type === "ContinueStatement") return [breakStatement()];
+    if (statement.type === "BreakStatement") {
+      return flag ? [assign([identifier(flag)], [boolean(true)]), breakStatement()] : [statement];
+    }
+    if (statement.type === "DoStatement") {
+      return [doBlock(rewriteOwnJumps(statement.body.statements, flag))];
+    }
+    if (statement.type === "IfStatement") {
+      return [{
+        ...statement,
+        clauses: statement.clauses.map((c) => ({
+          ...c,
+          body: block(rewriteOwnJumps(c.body.statements, flag))
+        })),
+        alternate: statement.alternate && block(rewriteOwnJumps(statement.alternate.statements, flag))
+      }];
+    }
+    return [statement];
+  });
+}
+function declaredNames(statements) {
+  const names = [];
+  for (const statement of statements) {
+    if (statement.type === "LocalStatement") names.push(...statement.names.map((n) => n.name));
+    else if (statement.type === "LocalFunctionStatement") names.push(statement.name.name);
+  }
+  return names;
+}
+function mentions(expression, name) {
+  let found = false;
+  const walk = (value) => {
+    if (found || !value || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const item of value) walk(item);
+      return;
+    }
+    const node = value;
+    if (node.type === "Identifier" && node.name === name) {
+      found = true;
+      return;
+    }
+    for (const [key, child] of Object.entries(value)) {
+      if (key !== "line" && key !== "column") walk(child);
+    }
+  };
+  walk(expression);
+  return found;
+}
+function isFunctionType(type) {
+  if (type.kind === "function") return true;
+  return type.kind === "intersection" && type.types.some((t) => t.kind === "function");
+}
+function allNodes(root) {
+  const out = [];
+  const visit = (value) => {
+    if (!value || typeof value !== "object") return;
+    if (Array.isArray(value)) return void value.forEach(visit);
+    const record = value;
+    if (typeof record.type === "string") out.push(value);
+    for (const [key, child] of Object.entries(record)) {
+      if (key !== "line" && key !== "column") visit(child);
+    }
+  };
+  visit(root);
+  return out;
+}
+
+// src/lowering.ts
+import { pathToFileURL } from "url";
+async function loadLowerings(modules) {
+  const lowerings = [];
+  const problems = [];
+  for (const module of modules) {
+    try {
+      const loaded = await import(pathToFileURL(module.file).href);
+      const plugin = loaded.default;
+      if (!plugin || typeof plugin !== "object") {
+        problems.push({
+          file: module.file,
+          message: `'${module.from}' lowering module has no default export`
+        });
+        continue;
+      }
+      lowerings.push({ plugin, from: module.from });
+    } catch (error) {
+      problems.push({
+        file: module.file,
+        message: `'${module.from}' lowering module failed to load: ${error.message}`
+      });
+    }
+  }
+  return { lowerings, problems };
+}
+
+// src/bundle.ts
+import { readFileSync } from "fs";
+import { dirname, relative, resolve as resolve2 } from "path";
+import {
+  parse,
+  analyzeScopes,
+  analyzeTypes,
+  moduleExports,
+  resolveModulePath,
+  resolveTypeLibraries,
+  directivesOf,
+  applyDirectives,
+  UNUSED_EXPECT_ERROR,
+  ParseError,
+  LexError
+} from "@tilua/parser";
+import { parse as parseLuau2, parseExpressionFromSource, print } from "luau-parser";
+
+// src/linemap.ts
+function statementsOf(node) {
+  const out = [];
+  const visit = (value) => {
+    if (!value || typeof value !== "object") return;
+    if (Array.isArray(value)) return void value.forEach(visit);
+    const record = value;
+    if (typeof record.type === "string" && record.type.endsWith("Statement")) {
+      out.push(value);
+    }
+    for (const [key, child] of Object.entries(record)) {
+      if (key !== "line" && key !== "column") visit(child);
+    }
+  };
+  visit(node);
+  return out;
+}
+function buildLineMap(emitted, printed, origins) {
+  const before = statementsOf(emitted);
+  const after = statementsOf(printed);
+  if (before.length !== after.length) return /* @__PURE__ */ new Map();
+  const map = /* @__PURE__ */ new Map();
+  for (let i = 0; i < before.length; i++) {
+    if (before[i].type !== after[i].type) return /* @__PURE__ */ new Map();
+    const origin = origins.get(before[i]);
+    if (!origin) continue;
+    const line = after[i].line.start;
+    if (!map.has(line)) map.set(line, origin);
+  }
+  return map;
+}
+function lineMapSource(map) {
+  const entries = [...map.entries()].sort((a, b) => a[0] - b[0]);
+  const quoted = (s) => JSON.stringify(s.replace(/\\/g, "/"));
+  return `{${entries.map(([line, o]) => `[${line}]={${quoted(o.file)},${o.line}}`).join(",")}}`;
+}
+
+// src/bundle.ts
+async function bundle(options) {
+  const entry = resolve2(options.entry);
+  const diagnostics = [];
+  const inline = options.config !== void 0 && typeof options.config !== "string";
+  const { config, problems } = resolveConfig(options.config, entry, options.root ?? (inline ? dirname(entry) : process.cwd()));
+  for (const p of problems) diagnostics.push({ file: p.file, message: p.message, line: p.line ?? 1, column: p.column ?? 1, category: "config" });
+  const root = resolve2(options.root ?? config?.directory ?? dirname(entry));
+  const nameOf = (file) => relative(root, file).replace(/\\/g, "/").replace(/\.tilua$/, "");
+  const sources = /* @__PURE__ */ new Map();
+  const directives = /* @__PURE__ */ new Map();
+  const queue = [entry];
+  while (queue.length) {
+    const file = queue.shift();
+    if (sources.has(file)) continue;
+    const parsed = parseFile(file, diagnostics, directives);
+    if (!parsed) return { modules: [], diagnostics };
+    const { program: program3, text } = parsed;
+    const scopes = analyzeScopes(program3);
+    for (const d of scopes.diagnostics) {
+      diagnostics.push({ file, message: d.message, line: d.node.line.start, column: d.node.column.start, category: "scope" });
+    }
+    sources.set(file, { file, name: nameOf(file), text, program: program3, scopes });
+    for (const specifier of importedSpecifiers(program3)) {
+      const target = resolveModulePath(file, specifier, config);
+      if (target && !target.endsWith(".d.tilua")) queue.push(target);
+    }
+  }
+  const analysis = analyzeModules([...sources.values()], config);
+  const { lowerings, problems: loweringProblems } = await loadLowerings(analysis.lowerings);
+  for (const p of loweringProblems) {
+    diagnostics.push({ file: p.file, message: p.message, line: 1, column: 1, category: "config" });
+  }
+  if (options.typeCheck !== false) diagnostics.push(...analysis.diagnostics);
+  const names = Names.from(...[...sources.values()].map((s) => s.program));
+  const G = names.fresh("G");
+  const requireExpression = member(identifier(G), "require");
+  const modules = /* @__PURE__ */ new Map();
+  const origins = /* @__PURE__ */ new WeakMap();
+  const pending = [entry];
+  while (pending.length) {
+    const file = pending.shift();
+    if (modules.has(file)) continue;
+    const source = sources.get(file);
+    const lowered = lower(source.program, source.scopes, {
+      names,
+      types: analysis.types.get(file),
+      lowerings,
+      target: options.target ?? config?.target,
+      source: source.text,
+      module: {
+        name: source.name,
+        require: requireExpression,
+        lines: `${G}.lines`,
+        resolve: (specifier) => {
+          const target = resolveModulePath(file, specifier, config);
+          if (!target || target.endsWith(".d.tilua") || !sources.has(target)) return void 0;
+          pending.push(target);
+          return sources.get(target).name;
+        }
+      }
+    });
+    for (const d of lowered.diagnostics) diagnostics.push({ file, ...d, category: "module" });
+    const shown = relative(root, file).replace(/\\/g, "/");
+    for (const statement of allStatements(lowered.statements)) {
+      const line = lowered.origins.get(statement);
+      if (line !== void 0) origins.set(statement, { file: shown, line });
+    }
+    modules.set(file, {
+      name: source.name,
+      statements: lowered.statements,
+      exportsName: lowered.exportsName,
+      info: lowered.module
+    });
+  }
+  for (const [file, fileDirectives] of directives) {
+    const semantic = diagnostics.filter((d) => d.file === file && (d.category === "scope" || d.category === "type"));
+    const { kept, unusedExpectErrors } = applyDirectives(fileDirectives, semantic, (d) => d.line);
+    const suppressed = new Set(semantic.filter((d) => !kept.includes(d)));
+    const remaining = diagnostics.filter((d) => !suppressed.has(d));
+    diagnostics.length = 0;
+    diagnostics.push(...remaining);
+    if (options.typeCheck === false) continue;
+    for (const d of unusedExpectErrors) {
+      diagnostics.push({ file, message: UNUSED_EXPECT_ERROR, line: d.line, column: d.column, category: "type" });
+    }
+  }
+  const moduleProblems = new Set(diagnostics.filter((d) => d.category === "module").map((d) => `${d.file}:${d.line}:${d.column}:${d.message}`));
+  const reported = diagnostics.filter((d) => d.category !== "type" || !moduleProblems.has(`${d.file}:${d.line}:${d.column}:${d.message}`));
+  diagnostics.length = 0;
+  diagnostics.push(...reported);
+  const moduleNames = [...modules.values()].map((m) => m.name);
+  if (diagnostics.some((d) => d.category === "syntax" || d.category === "scope" || d.category === "module")) {
+    return { modules: moduleNames, diagnostics };
+  }
+  const program2 = parseLuau2(runtime(G));
+  const assignment = program2.body.statements[1];
+  const modulesTable = assignment.type === "AssignmentStatement" && assignment.values[0].type === "TableExpression" ? assignment.values[0].fields.find((f) => f.type === "TableFieldNamed" && f.name.name === "modules")?.value : void 0;
+  if (!modulesTable) throw new Error("@tilua/compiler: the bundle runtime has no modules table");
+  for (const module of modules.values()) {
+    const { names: exported, links, stars } = module.info;
+    const fields = [];
+    if (exported.length) fields.push(field("names", table(exported.map((n) => field(n, boolean(true))))));
+    if (links.length) {
+      fields.push(field("links", table(links.map((link) => field(link.name, table([
+        { type: "TableFieldPositional", value: string(link.module) },
+        ...link.imported === void 0 ? [] : [{ type: "TableFieldPositional", value: string(link.imported) }]
+      ]))))));
+    }
+    if (stars.length) fields.push(field("stars", table(stars.map((star) => ({ type: "TableFieldPositional", value: string(star) })))));
+    fields.push(field("load", functionExpression(functionBody([module.exportsName], module.statements, true))));
+    modulesTable.fields.push({ type: "TableFieldComputed", key: string(module.name), value: table(fields) });
+  }
+  const start = call(requireExpression, [string(sources.get(entry).name)]);
+  program2.body.statements.push(modules.get(entry).info.exports ? returns([start]) : callStatement(start));
+  const map = buildLineMap(program2, parseLuau2(print(program2)), origins);
+  if (map.size) {
+    program2.body.statements.splice(program2.body.statements.length - 1, 0, assign(
+      [member(identifier(G), "lines")],
+      [parseExpressionFromSource(lineMapSource(map))]
+    ));
+  }
+  return { code: print(program2) + "\n", modules: moduleNames, diagnostics };
+}
+function runtime(G) {
+  return `
+local ${G}
+${G} = {
+    modules = {},
+    records = {},
+    require = function(name)
+        local record = ${G}.records[name]
+        if record ~= nil then
+            return record.exports
+        end
+        local module = ${G}.modules[name]
+        local initialized = {}
+        local exports = setmetatable({}, {
+            __index = function(_, key)
+                if initialized[key] then
+                    return nil
+                end
+                if module.names ~= nil and module.names[key] then
+                    error(("Cannot access '%s' before initialization: '%s' has not reached it yet"):format(tostring(key), name), 2)
+                end
+                local link = module.links ~= nil and module.links[key]
+                if link then
+                    local source = ${G}.require(link[1])
+                    if link[2] == nil then
+                        return source
+                    end
+                    return source[link[2]]
+                end
+                if module.stars ~= nil and key ~= "default" then
+                    for _, star in module.stars do
+                        local value = ${G}.require(star)[key]
+                        if value ~= nil then
+                            return value
+                        end
+                    end
+                end
+                return nil
+            end,
+            __newindex = function(target, key, value)
+                initialized[key] = true
+                rawset(target, key, value)
+            end,
+        })
+        record = { loading = true, exports = exports }
+        ${G}.records[name] = record
+        module.load(exports)
+        record.loading = false
+        return exports
+    end,
+}
+`;
+}
+function parseFile(file, diagnostics, directives) {
+  let text;
+  try {
+    text = readFileSync(file, "utf8");
+  } catch {
+    diagnostics.push({ file, message: "Cannot read file", line: 1, column: 1, category: "module" });
+    return void 0;
+  }
+  try {
+    const program2 = parse(text);
+    directives.set(file, directivesOf(text));
+    return { program: program2, text };
+  } catch (error) {
+    if (error instanceof ParseError || error instanceof LexError) {
+      const { line, column } = error;
+      diagnostics.push({ file, message: error.message, line, column, category: "syntax" });
+      return void 0;
+    }
+    throw error;
+  }
+}
+function importedSpecifiers(program2) {
+  return program2.body.statements.flatMap((s) => s.type === "ImportStatement" || s.type === "ExportAllStatement" || s.type === "ExportNamedStatement" && s.source ? [s.source.value] : []);
+}
+function analyzeModules(modules, config) {
+  const out = [];
+  const analyses = /* @__PURE__ */ new Map();
+  const libraries = config ? resolveTypeLibraries(config) : { files: [], lowerings: [], problems: [] };
+  for (const p of libraries.problems) out.push({ file: p.file, message: p.message, line: p.line ?? 1, column: p.column ?? 1, category: "config" });
+  const libs = libraries.files.map((file) => parse(readFileSync(file, "utf8")));
+  const globals = libs.flatMap((lib) => lib.body.statements.flatMap((s) => s.type === "DeclareStatement" ? [s.name] : []));
+  const byFile = new Map(modules.map((m) => [m.file, m]));
+  const exportsCache = /* @__PURE__ */ new Map();
+  const inProgress = /* @__PURE__ */ new Set();
+  const resolverFor = (file) => (specifier) => {
+    const target = resolveModulePath(file, specifier, config);
+    if (!target) return void 0;
+    if (inProgress.has(target)) return { values: /* @__PURE__ */ new Map(), types: /* @__PURE__ */ new Map(), partial: true };
+    const cached = exportsCache.get(target);
+    if (cached) return cached;
+    let program2 = byFile.get(target)?.program;
+    if (!program2) {
+      try {
+        program2 = parse(readFileSync(target, "utf8"));
+      } catch {
+        return void 0;
+      }
+    }
+    inProgress.add(target);
+    try {
+      const scopes = analyzeScopes(program2, { builtinGlobals: globals });
+      const types = analyzeTypes(program2, scopes, { libs, resolveModule: resolverFor(target), diagnostics: false });
+      const exports = moduleExports(program2, scopes, types, resolverFor(target));
+      exportsCache.set(target, exports);
+      return exports;
+    } finally {
+      inProgress.delete(target);
+    }
+  };
+  for (const module of modules) {
+    const scopes = analyzeScopes(module.program, { builtinGlobals: globals, reportUndeclared: libs.length > 0 });
+    for (const d of scopes.diagnostics) {
+      if (d.kind !== "undeclared") continue;
+      out.push({ file: module.file, message: d.message, line: d.node.line.start, column: d.node.column.start, category: "type" });
+    }
+    const types = analyzeTypes(module.program, scopes, {
+      libs,
+      resolveModule: resolverFor(module.file),
+      reportUnknownTypes: libs.length > 0
+    });
+    analyses.set(module.file, types);
+    for (const d of types.diagnostics) {
+      const at = d.node;
+      out.push({ file: module.file, message: d.message, line: at.line.start, column: at.column.start, category: "type" });
+    }
+  }
+  return { types: analyses, diagnostics: out, lowerings: [...libraries.lowerings] };
+}
+function allStatements(statements) {
+  const out = [];
+  const visit = (value) => {
+    if (!value || typeof value !== "object") return;
+    if (Array.isArray(value)) return void value.forEach(visit);
+    const record = value;
+    if (typeof record.type === "string" && record.type.endsWith("Statement")) {
+      out.push(value);
+    }
+    for (const [key, child] of Object.entries(record)) {
+      if (key !== "line" && key !== "column") visit(child);
+    }
+  };
+  visit(statements);
+  return out;
+}
+
+export {
+  resolveConfig,
+  program,
+  lower,
+  loadLowerings,
+  bundle
+};