@tilua/compiler 4.0.0 → 5.0.0

package/dist/index.cjs

@@ -33,9 +33,9 @@ var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${_
 var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 
 // src/bundle.ts
-var import_node_fs2 = require("fs");
+var import_node_fs3 = require("fs");
 var import_node_path2 = require("path");
-var import_parser6 = require("@tilua/parser");
+var import_parser7 = require("@tilua/parser");
 var import_luau_parser2 = require("luau-parser");
 
 // src/config.ts
@@ -50,7 +50,7 @@ function resolveConfig(input, entry, cwd = process.cwd()) {
 }
 
 // src/lower.ts
-var import_parser4 = require("@tilua/parser");
+var import_parser5 = require("@tilua/parser");
 var import_luau_parser = require("luau-parser");
 
 // src/luau.ts
@@ -212,6 +212,77 @@ var plugin = {
 };
 var languageLowering = { plugin, from: "tilua" };
 
+// src/standard.ts
+var import_node_fs2 = require("fs");
+var import_parser4 = require("@tilua/parser");
+var read2 = (name) => (0, import_node_fs2.readFileSync)(new URL(`../runtime/${name}`, importMetaUrl), "utf8");
+var console = read2("console.luau");
+var result = read2("result.luau");
+var place = (at) => (0, import_parser4.luauString)(at.file === void 0 ? `line ${at.line}` : `${at.file}:${at.line}`);
+var tag = (at) => (0, import_parser4.luauString)(`[${at.file === void 0 ? `line ${at.line}` : `${at.file.replace(/\.tilua$/, "")}:${at.line}`}]:`);
+function consoleMeta(args) {
+  const fields = [];
+  args.forEach((argument, index2) => {
+    if (argument.spread || argument.typeText === void 0 || !(0, import_parser4.isFunctionType)(argument.type)) return;
+    const written = argument.declaration ?? argument.source;
+    fields.push(`[${index2 + 1}] = { ${(0, import_parser4.luauString)(argument.typeText)}, ${(0, import_parser4.luauString)(written)} }`);
+  });
+  return fields.length ? `{ ${fields.join(", ")} }` : "nil";
+}
+var CONSOLE_METHODS = /* @__PURE__ */ new Set(["log", "warn", "error"]);
+var REPLACED = /* @__PURE__ */ new Map([
+  ["pcall", "pcall"],
+  ["xpcall", "xpcall"],
+  ["ypcall", "pcall"],
+  ["coroutine.resume", "resume"],
+  ["string.find", "find"],
+  ["string.match", "match"],
+  ["string.gsub", "gsub"],
+  ["string.byte", "byte"],
+  ["math.modf", "modf"],
+  ["math.frexp", "frexp"],
+  ["next", "next"],
+  ["select", "select"],
+  ["unpack", "unpack"],
+  ["table.unpack", "unpack"],
+  ["loadstring", "loadstring"],
+  ["pairs", "pairs"],
+  ["ipairs", "ipairs"],
+  ["string.gmatch", "gmatch"]
+]);
+var plugin2 = {
+  runtime: { console, result },
+  methodCall({ method, receiverGlobal, at, arguments: args, use }) {
+    if (receiverGlobal === "console" && CONSOLE_METHODS.has(method)) {
+      return {
+        callee: `${use("console")}.${method}`,
+        prepend: [tag(at), consoleMeta(args)],
+        passReceiver: false
+      };
+    }
+    return void 0;
+  },
+  // `print(x)` and `warn(x)` are left exactly as written: the place a line
+  // came from is what `console:log` / `console:warn` are for. `error` has to
+  // put the place inside the message it raises, so it goes through the
+  // runtime.
+  globalCall({ name, at, use }) {
+    if (name === "error") return { callee: `${use("console")}.raise`, prepend: [place(at)] };
+    const replaced = REPLACED.get(name);
+    if (replaced) return { callee: `${use("result")}.${replaced}` };
+    return void 0;
+  },
+  // Read as a value there is no call site to write down; the runtime finds
+  // one on the stack.
+  globalValue({ name, use }) {
+    if (name === "error") return `${use("console")}.raiseValue`;
+    const replaced = REPLACED.get(name);
+    if (replaced) return `${use("result")}.${replaced}`;
+    return void 0;
+  }
+};
+var standardLowering = { plugin: plugin2, from: "tilua (standard library)" };
+
 // src/lower.ts
 function lower(program2, scopes, options = {}) {
   return new Lowerer(program2, scopes, options).run();
@@ -301,6 +372,10 @@ var Lowerer = class {
     }
     return identifier(local2);
   }
+  /** `table.move`. Lua 5.1 has none, and gets a function that does the same. */
+  move() {
+    return this.lua51 ? this.helper("move") : member(this.builtin("table"), "move");
+  }
   helper(kind) {
     let name = this.helpers.get(kind);
     if (!name) {
@@ -401,7 +476,7 @@ var Lowerer = class {
       const type = this.options.types?.typeOf.get(argument);
       return {
         type,
-        typeText: type ? (0, import_parser4.formatType)(type) : void 0,
+        typeText: type ? (0, import_parser5.formatType)(type) : void 0,
         source: this.writtenSource(argument),
         declaration: declaration ? this.writtenSource(declaration) : void 0,
         spread: argument.type === "SpreadElement"
@@ -423,7 +498,11 @@ var Lowerer = class {
   /** The language's own lowering, then each library's, in load order. A
    *  runtime is named by its lowering's place here (`loweringRuntime`). */
   get lowerings() {
-    return this.allLowerings ??= [languageLowering, ...this.options.lowerings ?? []];
+    return this.allLowerings ??= [
+      languageLowering,
+      ...this.options.noLib ? [] : [standardLowering],
+      ...this.options.lowerings ?? []
+    ];
   }
   allLowerings;
   /** What `receiver:method(...)` becomes, when Luau alone would not run it.
@@ -437,22 +516,28 @@ var Lowerer = class {
    *  (`console:log`), the last library loaded first. No answer leaves an
    *  ordinary Luau method call: `text:upper()` reaches Lua's own. */
   loweredMethodCall(node) {
+    return this.loweredMethod(node.method.name, this.options.types?.methodSources.get(node), node.object, node.arguments, node.method, node);
+  }
+  /** `loweredMethodCall`, for a method named `method` of what `object`
+   *  holds — called with `:` on it, or read off it with `.` and handed its
+   *  `self` like any other argument. `args` are the arguments after the
+   *  receiver; a read that is not called has none. */
+  loweredMethod(method, source, object2, args, name, node) {
     const lowerings = this.lowerings;
-    const source = this.options.types?.methodSources.get(node);
     const asked = source?.origin === "language" ? [0] : source?.origin === "library" ? lowerings.flatMap((l, i) => l.library === source.library ? [i] : []) : source?.origin === "program" ? [] : lowerings.map((_, i) => i).slice(1).reverse();
     if (!asked.some((i) => lowerings[i].plugin.methodCall)) return void 0;
-    const receiver = this.options.types?.typeOf.get(node.object);
-    const receiverGlobal = this.globalName(node.object);
-    const info = this.lazyArguments(node.arguments);
+    const receiver = this.options.types?.typeOf.get(object2);
+    const receiverGlobal = this.globalName(object2);
+    const info = this.lazyArguments(args);
     for (const i of asked) {
-      const plugin2 = lowerings[i].plugin;
-      if (!plugin2.methodCall) continue;
-      const answer = plugin2.methodCall({
-        method: node.method.name,
+      const plugin3 = lowerings[i].plugin;
+      if (!plugin3.methodCall) continue;
+      const answer = plugin3.methodCall({
+        method,
         receiver,
         receiverGlobal,
-        argumentCount: node.arguments.length,
-        at: this.callSite(node.method),
+        argumentCount: args.length,
+        at: this.callSite(name),
         get arguments() {
           return info();
         },
@@ -476,9 +561,9 @@ var Lowerer = class {
     if (name === void 0) return void 0;
     const info = this.lazyArguments(node.arguments);
     for (let i = lowerings.length - 1; i >= 0; i--) {
-      const plugin2 = lowerings[i].plugin;
-      if (!plugin2.globalCall) continue;
-      const answer = plugin2.globalCall({
+      const plugin3 = lowerings[i].plugin;
+      if (!plugin3.globalCall) continue;
+      const answer = plugin3.globalCall({
         name,
         at: this.callSite(node.callee),
         get arguments() {
@@ -530,6 +615,31 @@ var Lowerer = class {
     const out = [];
     const runtimes = this.runtimeDefinitions();
     if (this.helpers.has("concat")) this.helper("array");
+    if (this.helpers.has("concat")) this.move();
+    const move = this.helpers.get("move");
+    if (move) {
+      out.push(...(0, import_luau_parser.parse)(`
+local function ${move}(from, first, last, at, to)
+	for i = first, last do
+		to[at + i - first] = from[i]
+	end
+	return to
+end`).body.statements);
+    }
+    const each = this.helpers.get("each");
+    if (each) {
+      out.push(...(0, import_luau_parser.parse)(`
+local function ${each}(source, ...)
+	if ${this.builtin("type").name}(source) == "function" then
+		return source, ...
+	end
+	local meta = ${this.builtin("getmetatable").name}(source)
+	if meta ~= nil and meta.__iter ~= nil then
+		return meta.__iter(source)
+	end
+	return ${this.builtin("next").name}, source
+end`).body.statements);
+    }
     const marker = this.helpers.get("array");
     const typeOf = this.helpers.get("typeof");
     if (marker || typeOf) {
@@ -568,6 +678,49 @@ local function ${typeOf}(value, known)
 end`).body.statements);
       }
     }
+    const instanceOf = this.helpers.get("instanceof");
+    if (instanceOf) {
+      out.push(...(0, import_luau_parser.parse)(`
+local function ${instanceOf}(value, class)
+	if ${this.builtin("type").name}(value) ~= "table" then
+		return false
+	end
+	local current = value.ClassObject
+	while current ~= nil do
+		if current == class then
+			return true
+		end
+		current = current.ParentClass
+	end
+	return false
+end`).body.statements);
+    }
+    const accessors = this.helpers.get("accessors");
+    if (accessors) {
+      out.push(...(0, import_luau_parser.parse)(`
+local function ${accessors}(target, getters, setters)
+	return ${this.builtin("setmetatable").name}(target, {
+		__index = function(self, key)
+			local get = getters[key]
+			if get ~= nil then
+				return get(self)
+			end
+			return nil
+		end,
+		__newindex = function(self, key, value)
+			local set = setters[key]
+			if set ~= nil then
+				set(self, value)
+				return
+			end
+			if getters[key] ~= nil then
+				${this.builtin("error").name}("Cannot assign to '" .. ${this.builtin("tostring").name}(key) .. "': it has a getter and no setter", 2)
+			end
+			${this.builtin("rawset").name}(self, key, value)
+		end,
+	})
+end`).body.statements);
+    }
     const assign2 = this.helpers.get("assign");
     if (assign2) {
       out.push(localFunction(assign2, functionBody(["target"], [
@@ -589,7 +742,7 @@ end`).body.statements);
         local(["result"], [this.array(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"), [
+          callStatement(call(this.move(), [
             identifier("part"),
             number(1),
             unary("#", identifier("part")),
@@ -606,8 +759,8 @@ end`).body.statements);
   runtimeDefinitions() {
     const out = [];
     for (const { index: index2, runtime: runtime2, name } of this.loweringUsed) {
-      const { plugin: plugin2, from } = this.lowerings[index2];
-      const source = plugin2.runtime?.[runtime2];
+      const { plugin: plugin3, from } = this.lowerings[index2];
+      const source = plugin3.runtime?.[runtime2];
       if (source === void 0) {
         this.diagnostics.push({
           message: `'${from}' asked for a runtime it does not have: '${runtime2}'`,
@@ -702,6 +855,7 @@ end`).body.statements);
           names.push("default");
           break;
         case "ExportNamedStatement": {
+          if (statement.typeOnly) break;
           if (statement.source) {
             const key = resolve4(statement.source);
             if (key === void 0) break;
@@ -785,6 +939,26 @@ end`).body.statements);
     for (let i = 0; i < locals.length; i += 100) declarations.push(local(locals.slice(i, i + 100), []));
     return [...declarations, ...hoisted, ...requires, ...body];
   }
+  /** `import("./x")`: the bundle's `import`, called with the module's name.
+   *  It answers the module's exports table — what `import * as` names. */
+  importExpression(node) {
+    const context = this.options.module;
+    if (!context) {
+      this.report(node, "import() needs a bundle: build the project with @tilua/compiler");
+      return nil();
+    }
+    const source = node.source;
+    if (source.type !== "StringLiteral") {
+      this.report(source, "import() takes a string literal: which module it loads is decided when the project is built");
+      return nil();
+    }
+    const key = context.resolve(source.value, true);
+    if (key === void 0) {
+      this.report(source, `Cannot find module '${source.value}'`);
+      return nil();
+    }
+    return call(context.import ?? context.require, [string(key)]);
+  }
   isRewritten(node) {
     const binding = this.bindingByDeclaration.get(node);
     return binding !== void 0 && this.rewrites.has(binding.id);
@@ -931,7 +1105,7 @@ end`).body.statements);
       case "VariableDeclaration":
         return this.variableDeclaration(node, "declare");
       case "FunctionDeclaration":
-        return [{ ...localFunction(this.name(node.name.name), this.functionBody(node.func)), attributes: node.attributes }];
+        return [{ ...localFunction(this.name(node.name.name), this.functionBody(node.func)), attributes: this.lua51 ? void 0 : node.attributes }];
       case "FunctionDeclarationStatement":
         return [this.functionDeclarationStatement(node)];
       case "ClassDeclaration":
@@ -962,8 +1136,13 @@ end`).body.statements);
       // 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 "ExpressionStatement": {
+        let expression = node.expression;
+        while (expression.type === "ParenthesizedExpression") expression = expression.expression;
+        if (expression.type !== "ImportExpression") return [];
+        const call2 = this.importExpression(expression);
+        return call2.type === "CallExpression" ? [this.from(callStatement(call2), node)] : [];
+      }
       case "DoStatement":
         return [{ type: "DoStatement", body: this.block(node.body), ...spanOf(node) }];
       case "WhileStatement":
@@ -1015,7 +1194,11 @@ end`).body.statements);
         let source = this.expression(node.iterator);
         if (form.viaIter) source = methodCall(source, "__iter", []);
         const variables = form.walks === "values" ? [this.names.fresh("_"), item] : [item];
-        const iterators = form.walks === "iteration" ? [call(this.builtin("unpack"), [source, number(1), number(3)])] : [source];
+        let iterators = form.walks === "iteration" ? [call(this.builtin("unpack"), [source, number(1), number(3)])] : [source];
+        if (this.lua51 && form.walks === "values") {
+          const kind = form.viaIter ? void 0 : this.options.types?.typeOf.get(node.iterator)?.kind;
+          iterators = [call(kind === "array" || kind === "tuple" ? this.builtin("ipairs") : this.helper("each"), [source])];
+        }
         return [genericFor(
           variables,
           iterators,
@@ -1268,7 +1451,8 @@ end
       },
       isMethod,
       func,
-      attributes: node.attributes,
+      // `@native` and the like are Luau's.
+      attributes: this.lua51 ? void 0 : node.attributes,
       ...spanOf(node)
     };
   }
@@ -1369,7 +1553,7 @@ end
         if (element) bind(element.value, index(source, number(i + 1)), element.default);
       });
       if (pattern.rest) {
-        const elements = call(member(this.builtin("table"), "move"), [
+        const elements = call(this.move(), [
           source,
           number(pattern.elements.length + 1),
           unary("#", source),
@@ -1480,8 +1664,15 @@ end
       case "ArrayExpression":
         return this.arrayExpression(node);
       case "BinaryExpression": {
+        if (node.operator === "??") return this.nullish(node);
         const left = this.expression(node.left);
         const right = this.expression(node.right);
+        if (node.operator === "in") {
+          return parenthesized(binary("~=", index(this.keptToOne(right), this.keptToOne(left)), nil()));
+        }
+        if (node.operator === "instanceof") {
+          return call(this.helper("instanceof"), [this.keptToOne(left), this.keptToOne(right)]);
+        }
         if (this.lua51 && node.operator === "//") return this.floorDivide(left, right);
         return binary(node.operator, left, right);
       }
@@ -1508,6 +1699,8 @@ end
       }
       case "ParenthesizedExpression":
         return parenthesized(this.expression(node.expression));
+      case "ImportExpression":
+        return this.importExpression(node);
       // Types only: the value is the expression itself.
       case "TypeAssertionExpression":
       case "SatisfiesExpression":
@@ -1561,7 +1754,7 @@ end
       const last2 = list.length - 1;
       return lowered.length && !many.has(list[last2]) ? [...lowered.slice(0, -1), this.keptToOne(lowered[last2])] : lowered;
     }
-    const unpack = (value) => call(member(this.builtin("table"), "unpack"), [value]);
+    const unpack = (value) => call(this.lua51 ? this.builtin("unpack") : 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))];
@@ -1575,11 +1768,21 @@ end
   /** One link of an access chain, read from `object`. */
   link(node, object2) {
     switch (node.type) {
-      case "MemberExpression":
+      case "MemberExpression": {
+        if (this.options.types?.lengths.has(node)) return unary("#", object2);
+        const source = this.options.types?.methodReads.get(node);
+        const lowered = source && this.loweredMethod(node.property.name, source, node.object, [], node.property, node);
+        if (lowered) {
+          const forwarded = call(calleePath(lowered.callee), [...lowered.prepend, vararg()]);
+          return functionExpression(functionBody(lowered.passReceiver ? [] : ["_"], [returns([forwarded])], true));
+        }
         return member(object2, node.property.name);
+      }
       case "IndexExpression":
         return index(object2, this.expression(node.index));
       case "CallExpression": {
+        const method = this.methodCalled(node);
+        if (method) return method;
         const lowered = this.loweredGlobalCall(node);
         const args = this.arguments(node.arguments);
         if (!lowered) return call(object2, args);
@@ -1602,6 +1805,24 @@ end
       }
     }
   }
+  /** `names.filter(names, f)`: a method of the value's metatable, read with
+   *  `.` and handed its `self` as the first argument. Written as a call of
+   *  the function the method really is — `array.filter(names, f)` — where
+   *  whoever declared the metatable says so; `undefined` leaves an ordinary
+   *  call, which is right for a string's Lua methods (`text.upper(text)`
+   *  reaches Lua's own `string.upper`). */
+  methodCalled(node) {
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression") return void 0;
+    const source = this.options.types?.methodReads.get(callee);
+    if (!source) return void 0;
+    const spreads = node.arguments.map((a, i) => a.type === "SpreadElement" ? i : -1).filter((i) => i >= 0);
+    if (!node.arguments.length || spreads.includes(0) || spreads.some((i) => i !== node.arguments.length - 1)) return void 0;
+    const lowered = this.loweredMethod(callee.property.name, source, callee.object, node.arguments.slice(1), callee.property, node);
+    if (!lowered) return void 0;
+    const [self, ...rest] = this.arguments(node.arguments);
+    return call(calleePath(lowered.callee), [...lowered.prepend, ...lowered.passReceiver ? [self] : [], ...rest]);
+  }
   // --------------------------------------------------------
   // Optional chains
   // --------------------------------------------------------
@@ -1647,7 +1868,7 @@ end
     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") {
+    if (!this.lua51 && base.type === "Identifier" && segments.length === 1 && last.type !== "CallExpression" && last.type !== "MethodCallExpression") {
       return {
         type: "IfElseExpression",
         clauses: [{ condition: binary("==", base, nil()), body: nil() }],
@@ -1668,6 +1889,32 @@ end
     const func = functionExpression(functionBody([], statements, passesVarargs));
     return call(parenthesized(func), passesVarargs ? [vararg()] : []);
   }
+  /** `a ?? b`: `a`, or `b` where `a` is nil — read only then. A `false`
+   *  stays, which is what sets it apart from `a or b`. A name is tested
+   *  in place; anything else is read once, into a local. */
+  nullish(node) {
+    const left = this.keptToOne(this.expression(node.left));
+    const right = this.keptToOne(this.expression(node.right));
+    if (!this.lua51 && left.type === "Identifier") {
+      return {
+        type: "IfElseExpression",
+        clauses: [{ condition: binary("~=", left, nil()), body: left }],
+        alternate: right,
+        line: left.line,
+        column: left.column
+      };
+    }
+    const ref = this.names.fresh("value");
+    const at = identifier(ref);
+    const statements = [
+      local([ref], [left]),
+      ifThen(binary("~=", at, nil()), [returns([at])]),
+      returns([right])
+    ];
+    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 = "";
@@ -1749,12 +1996,12 @@ end
     }));
     const alternate = this.expression(node.alternate);
     if (clauses.every((c) => alwaysTruthy(c.body))) {
-      let result = alternate;
+      let result2 = alternate;
       for (let i = clauses.length - 1; i >= 0; i--) {
         const { condition, body } = clauses[i];
-        result = binary("or", binary("and", condition, body), result);
+        result2 = binary("or", binary("and", condition, body), result2);
       }
-      return parenthesized(result);
+      return parenthesized(result2);
     }
     const statement = {
       type: "IfStatement",
@@ -1811,11 +2058,20 @@ end
           current = [];
           parts.push(this.expression(f.argument));
           break;
+        case "TableFieldAccessor":
+          break;
       }
     }
-    if (parts.length === 0) return table(current);
-    if (current.length) parts.push(table(current));
-    return call(this.helper("assign"), [table([]), ...parts]);
+    let made;
+    if (parts.length === 0) made = table(current);
+    else {
+      if (current.length) parts.push(table(current));
+      made = call(this.helper("assign"), [table([]), ...parts]);
+    }
+    const accessors = node.fields.filter((f) => f.type === "TableFieldAccessor");
+    if (!accessors.length) return made;
+    const table2 = (kind) => table(accessors.filter((f) => f.kind === kind).map((f) => field(f.key.type === "Identifier" ? f.key.name : f.key.value, functionExpression(this.classFunctionBody(f.func)))));
+    return call(this.helper("accessors"), [made, table2("get"), table2("set")]);
   }
   /** `[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`. */
@@ -2072,7 +2328,7 @@ var CLASS_METAMETHODS = [
 ];
 
 // src/linemap.ts
-var import_parser5 = require("@tilua/parser");
+var import_parser6 = require("@tilua/parser");
 function statementsOf(node) {
   const out = [];
   const visit = (value) => {
@@ -2105,7 +2361,7 @@ function buildLineMap(emitted, printed, origins) {
 }
 function lineMapSource(map) {
   const entries = [...map.entries()].sort((a, b) => a[0] - b[0]);
-  const quoted = (s) => (0, import_parser5.luauString)(s.replace(/\\/g, "/"));
+  const quoted = (s) => (0, import_parser6.luauString)(s.replace(/\\/g, "/"));
   return `{${entries.map(([line, o]) => `[${line}]={${quoted(o.file)},${o.line}}`).join(",")}}`;
 }
 
@@ -2117,15 +2373,15 @@ async function loadLowerings(modules) {
   for (const module2 of modules) {
     try {
       const loaded = await import((0, import_node_url.pathToFileURL)(module2.file).href);
-      const plugin2 = loaded.default;
-      if (!plugin2 || typeof plugin2 !== "object") {
+      const plugin3 = loaded.default;
+      if (!plugin3 || typeof plugin3 !== "object") {
         problems.push({
           file: module2.file,
           message: `'${module2.from}' lowering module has no default export`
         });
         continue;
       }
-      lowerings.push({ plugin: plugin2, from: module2.from, library: module2.library });
+      lowerings.push({ plugin: plugin3, from: module2.from, library: module2.library });
     } catch (error) {
       problems.push({
         file: module2.file,
@@ -2152,16 +2408,17 @@ async function bundle(options) {
     const file = queue.shift();
     if (sources.has(file)) continue;
     const parsed = parseFile(file, diagnostics, directives);
-    if (!parsed) return { modules: [], diagnostics };
+    if (!parsed) return { files: [], modules: [], diagnostics };
     const { program: program3, text } = parsed;
-    const scopes = (0, import_parser6.analyzeScopes)(program3);
+    const scopes = (0, import_parser7.analyzeScopes)(program3, { noLib: config?.noLib });
     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 = (0, import_parser6.resolveModulePath)(file, specifier, config);
-      if (target && !target.endsWith(".d.tilua")) queue.push(target);
+    const dynamic = (0, import_parser7.importExpressions)(program3).flatMap((node) => node.source.type === "StringLiteral" ? [node.source.value] : []);
+    for (const specifier of [...importedSpecifiers(program3), ...dynamic]) {
+      const target2 = (0, import_parser7.resolveModulePath)(file, specifier, config);
+      if (target2 && !target2.endsWith(".d.tilua")) queue.push(target2);
     }
   }
   const analysis = analyzeModules([...sources.values()], config);
@@ -2173,6 +2430,9 @@ async function bundle(options) {
   const names = Names.from(...[...sources.values()].map((s) => s.program));
   const G = names.fresh("G");
   const requireExpression = member(identifier(G), "require");
+  const importExpression = member(identifier(G), "import");
+  const mode = options.output ?? config?.output ?? "single";
+  const target = options.target ?? config?.target ?? "luau";
   const modules = /* @__PURE__ */ new Map();
   const origins = /* @__PURE__ */ new WeakMap();
   const pending = [entry];
@@ -2181,104 +2441,228 @@ async function bundle(options) {
     if (modules.has(file)) continue;
     const source = sources.get(file);
     const shown = (0, import_node_path2.relative)(root, file).replace(/\\/g, "/");
-    const lowered = lower(source.program, source.scopes, {
+    const imports = /* @__PURE__ */ new Set();
+    const dynamicImports = /* @__PURE__ */ new Set();
+    const lowered2 = lower(source.program, source.scopes, {
       names,
       types: analysis.types.get(file),
       lowerings,
-      target: options.target ?? config?.target,
+      target,
+      noLib: config?.noLib,
       source: source.text,
       file: shown,
       module: {
         name: source.name,
         require: requireExpression,
-        lines: `${G}.lines`,
+        import: importExpression,
+        // One file has one line map. Several have one each, and a
+        // module reads the one of the file it is in.
+        lines: mode === "single" ? `${G}.lines` : `${G}.maps[${(0, import_parser7.luauString)(source.name)}]`,
         fail: `${G}.fail`,
         arrays: `${G}.arrays`,
-        resolve: (specifier) => {
-          const target = (0, import_parser6.resolveModulePath)(file, specifier, config);
-          if (!target || target.endsWith(".d.tilua") || !sources.has(target)) return void 0;
-          pending.push(target);
-          return sources.get(target).name;
+        resolve: (specifier, dynamic) => {
+          const found = (0, import_parser7.resolveModulePath)(file, specifier, config);
+          if (!found || found.endsWith(".d.tilua") || !sources.has(found)) return void 0;
+          pending.push(found);
+          const name = sources.get(found).name;
+          (dynamic ? dynamicImports : imports).add(name);
+          return name;
         }
       }
     });
-    for (const d of lowered.diagnostics) diagnostics.push({ file, ...d, category: "module" });
-    for (const statement of allStatements(lowered.statements)) {
-      const line = lowered.origins.get(statement);
+    for (const d of lowered2.diagnostics) diagnostics.push({ file, ...d, category: "module" });
+    for (const statement of allStatements(lowered2.statements)) {
+      const line = lowered2.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,
-      usesScriptArgs: lowered.usesScriptArgs
+      statements: lowered2.statements,
+      exportsName: lowered2.exportsName,
+      info: lowered2.module,
+      usesScriptArgs: lowered2.usesScriptArgs,
+      imports,
+      dynamicImports
     });
   }
   for (const [file, fileDirectives] of directives) {
     const semantic = diagnostics.filter((d) => d.file === file && (d.category === "scope" || d.category === "type"));
-    const { kept, unusedExpectErrors } = (0, import_parser6.applyDirectives)(fileDirectives, semantic, (d) => d.line);
+    const { kept, unusedExpectErrors } = (0, import_parser7.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: import_parser6.UNUSED_EXPECT_ERROR, line: d.line, column: d.column, category: "type" });
+      diagnostics.push({ file, message: import_parser7.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);
+  const lowered = [...modules.values()];
+  const moduleNames = lowered.map((m) => m.name);
   if (diagnostics.some((d) => d.category === "syntax" || d.category === "scope" || d.category === "module")) {
-    return { modules: moduleNames, diagnostics };
-  }
-  const program2 = (0, import_luau_parser2.parse)(runtime(G));
+    return { files: [], modules: moduleNames, diagnostics };
+  }
+  const several = mode !== "single";
+  const layout = layoutOf(mode, modules.get(entry), lowered, options.outFile);
+  const usesScriptArgs = lowered.some((m) => m.usesScriptArgs);
+  const elsewhere = /* @__PURE__ */ new Map();
+  for (const file of layout.slice(1)) {
+    for (const module2 of file.modules) elsewhere.set(module2.name, loadPath(layout[0].path, file.path, target));
+  }
+  const program2 = (0, import_luau_parser2.parse)(runtime(G, {
+    several,
+    target,
+    files: elsewhere,
+    imports: lowered.some((m) => m.dynamicImports.size > 0)
+  }));
   const assignment = program2.body.statements[1];
-  if ([...modules.values()].some((m) => m.usesScriptArgs)) {
+  if (usesScriptArgs) {
     program2.body.statements.unshift(local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: { type: "VarargExpression" } }])]));
     program2.body.statements.push(...(0, import_luau_parser2.parse)(`${G}.arrays[scriptArgs] = true`).body.statements);
+    if (several) program2.body.statements.push(...(0, import_luau_parser2.parse)(`${G}.scriptArgs = scriptArgs`).body.statements);
   }
   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 module2 of modules.values()) {
-    const { names: exported, links, stars } = module2.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([module2.exportsName], module2.statements, true))));
-    modulesTable.fields.push({ type: "TableFieldComputed", key: string(module2.name), value: table(fields) });
+  for (const module2 of layout[0].modules) {
+    modulesTable.fields.push({ type: "TableFieldComputed", key: string(module2.name), value: moduleTable(module2) });
   }
   const ok = names.fresh("ok");
-  const result = names.fresh("result");
+  const result2 = names.fresh("result");
   const entryStatements = (0, import_luau_parser2.parse)(`
-local ${ok}, ${result} = xpcall(function()
-    return ${G}.require(${(0, import_parser6.luauString)(sources.get(entry).name)})
+local ${ok}, ${result2} = xpcall(function()
+    return ${G}.require(${(0, import_parser7.luauString)(sources.get(entry).name)})
 end, ${G}.fail)
 if not ${ok} then
-    error(${result}, 0)
+    error(${result2}, 0)
 end
-${modules.get(entry).info.exports ? `return ${result}` : ""}
+${modules.get(entry).info.exports ? `return ${result2}` : ""}
 `).body.statements;
   program2.body.statements.push(...entryStatements);
   const map = buildLineMap(program2, (0, import_luau_parser2.parse)((0, import_luau_parser2.print)(program2)), origins);
-  if (map.size) {
-    program2.body.statements.splice(program2.body.statements.length - entryStatements.length, 0, assign(
+  if (map.size || several) {
+    const mapStatements = [assign(
       [member(identifier(G), "lines")],
       [(0, import_luau_parser2.parseExpressionFromSource)(lineMapSource(map))]
-    ));
+    )];
+    if (several) mapStatements.push(...mapRegistration(G, layout[0], `${G}.lines`));
+    program2.body.statements.splice(program2.body.statements.length - entryStatements.length, 0, ...mapStatements);
+  }
+  const files = [{ path: layout[0].path, code: (0, import_luau_parser2.print)(program2) + "\n", modules: layout[0].modules.map((m) => m.name) }];
+  for (const file of layout.slice(1)) {
+    const body = [];
+    if (file.modules.some((m) => m.usesScriptArgs)) body.push(...(0, import_luau_parser2.parse)(`local scriptArgs = ${G}.scriptArgs`).body.statements);
+    for (const module2 of file.modules) {
+      body.push(assign(
+        [index(member(identifier(G), "modules"), string(module2.name))],
+        [moduleTable(module2)]
+      ));
+    }
+    const chunk = program([returns([functionExpression(functionBody([G], body))])]);
+    const lines = buildLineMap(chunk, (0, import_luau_parser2.parse)((0, import_luau_parser2.print)(chunk)), origins);
+    body.push(...mapRegistration(G, file, lineMapSource(lines)));
+    files.push({ path: file.path, code: (0, import_luau_parser2.print)(chunk) + "\n", modules: file.modules.map((m) => m.name) });
+  }
+  return { code: files[0].code, files, modules: moduleNames, diagnostics };
+}
+function moduleTable(module2) {
+  const { names: exported, links, stars } = module2.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([module2.exportsName], module2.statements, true))));
+  return table(fields);
+}
+function layoutOf(mode, entry, modules, outFile) {
+  const extension = outFile !== void 0 && (0, import_node_path2.extname)(outFile) || ".luau";
+  const entryStem = outFile !== void 0 ? (0, import_node_path2.basename)(outFile, (0, import_node_path2.extname)(outFile)) : import_node_path2.posix.basename(entry.name);
+  const others = modules.filter((m) => m !== entry);
+  if (mode === "single") return [{ path: `${entryStem}${extension}`, modules: [entry, ...others] }];
+  if (mode === "modules") {
+    const pathOf = (m) => `${m.name.split("/").map((part) => part === ".." ? "__" : part).join("/")}${extension}`;
+    return [entry, ...others].map((m) => ({ path: pathOf(m), modules: [m] }));
+  }
+  const byName = new Map(modules.map((m) => [m.name, m]));
+  const reach = (root) => {
+    const seen = /* @__PURE__ */ new Set();
+    const stack = [root];
+    while (stack.length) {
+      const name = stack.pop();
+      if (seen.has(name)) continue;
+      seen.add(name);
+      stack.push(...byName.get(name)?.imports ?? []);
+    }
+    return seen;
+  };
+  const inEntry = reach(entry.name);
+  const roots = [...new Set(modules.flatMap((m) => [...m.dynamicImports]))].filter((root) => !inEntry.has(root));
+  const reached = new Map(roots.map((root) => [root, reach(root)]));
+  const groups = /* @__PURE__ */ new Map();
+  for (const module2 of others) {
+    if (inEntry.has(module2.name)) continue;
+    const by = roots.filter((root) => reached.get(root).has(module2.name));
+    const key = by.join("\n");
+    if (!groups.has(key)) groups.set(key, { roots: by, modules: [] });
+    groups.get(key).modules.push(module2);
+  }
+  const files = [{ path: `${entryStem}${extension}`, modules: modules.filter((m) => inEntry.has(m.name)) }];
+  const taken = /* @__PURE__ */ new Set([entryStem]);
+  for (const group of groups.values()) {
+    const label = group.roots.length === 1 ? group.roots[0].replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "") || "chunk" : "shared";
+    let stem = `${entryStem}_${label}`;
+    for (let n = 2; taken.has(stem); n++) stem = `${entryStem}_${label}_${n}`;
+    taken.add(stem);
+    files.push({ path: `${stem}${extension}`, modules: group.modules });
+  }
+  return files;
+}
+function loadPath(entryPath, file, target) {
+  const path = import_node_path2.posix.relative(import_node_path2.posix.dirname(entryPath), file);
+  if (target === "lua51") return path;
+  const bare = path.slice(0, path.length - import_node_path2.posix.extname(path).length);
+  return bare.startsWith("../") ? bare : `./${bare}`;
+}
+function mapRegistration(G, file, map) {
+  const extension = import_node_path2.posix.extname(file.path);
+  const parts = file.path.slice(0, file.path.length - extension.length).split(/[/.]/).filter((part) => part !== "");
+  const entry = `${G}.sources[#${G}.sources + 1]`;
+  return (0, import_luau_parser2.parse)([
+    `${entry} = { { ${parts.map(import_parser7.luauString).join(", ")} }, ${map}, ${(0, import_parser7.luauString)(extension.slice(1))} }`,
+    ...file.modules.map((module2) => `${G}.maps[${(0, import_parser7.luauString)(module2.name)}] = ${G}.sources[#${G}.sources][2]`)
+  ].join("\n")).body.statements;
+}
+function loader(G, target) {
+  if (target === "lua51") {
+    return `
+        -- From beside this file, wherever that is: its own path says where.
+        local folder = ""
+        if debug ~= nil and debug.getinfo ~= nil then
+            local at = debug.getinfo(${G}.load, "S").source
+            if at:sub(1, 1) == "@" then
+                folder = at:match("^@(.*[/\\\\])") or ""
+            end
+        end
+        local chunk, problem = loadfile(folder .. file)
+        if chunk == nil then
+            error(problem, 0)
+        end
+        chunk()(${G})`;
   }
-  return { code: (0, import_luau_parser2.print)(program2) + "\n", modules: moduleNames, diagnostics };
+  return `
+        require(file)(${G})`;
 }
-function runtime(G) {
+function runtime(G, options) {
+  const { several } = options;
+  const files = [...options.files].map(([name, file]) => `[${(0, import_parser7.luauString)(name)}] = ${(0, import_parser7.luauString)(file)}`).join(", ");
   return `
 local ${G}
 ${G} = {
@@ -2326,7 +2710,7 @@ ${G} = {
             return message
         end
         local lines = ${G}.lines
-        if lines == nil then
+        if lines == nil ${several ? `and #${G}.sources == 0 ` : ""}then
             return message .. (trace or "")
         end
         -- The bundle's name, as a position in a message spells it: where this
@@ -2346,6 +2730,81 @@ ${G} = {
                 chunk = info.short_src
             end
         end
+${several ? `
+        -- A position in this file is read by this file's map. One in another
+        -- of the bundle's files is read by that file's: the one whose name
+        -- the position ends with, by the most folders where several do. A
+        -- message says nothing about which file it starts in, so nothing is
+        -- guessed from it here.
+        local prefix = nil
+        if chunk ~= nil then
+            prefix = chunk:gsub("%p", "%%%0")
+        end
+        local function place(line)
+            local origin = lines ~= nil and lines[tonumber(line)] or nil
+            if origin == nil then
+                return nil
+            end
+            return origin[1] .. ":" .. tostring(origin[2])
+        end
+        local function elsewhere(at, line)
+            -- Already a place in the project.
+            if at:sub(-6) == ".tilua" then
+                return nil
+            end
+            local parts = {}
+            for part in at:gmatch("[^/\\\\%.]+") do
+                parts[#parts + 1] = part
+            end
+            local map, most, tied = nil, 0, false
+            for _, source in ipairs(${G}.sources) do
+                local names = source[1]
+                local last = #parts
+                if parts[last] == source[3] then
+                    last = last - 1
+                end
+                local same = 0
+                while same < #names and same < last and names[#names - same] == parts[last - same] do
+                    same = same + 1
+                end
+                if same > most then
+                    map, most, tied = source[2], same, false
+                elseif same == most then
+                    tied = true
+                end
+            end
+            -- Two files it could as well be: a wrong place is worse than none.
+            local origin = map ~= nil and not tied and map[tonumber(line)] or nil
+            if origin == nil then
+                return nil
+            end
+            return origin[1] .. ":" .. tostring(origin[2])
+        end
+        local mapped = message
+        if prefix ~= nil then
+            mapped = mapped:gsub(prefix .. ":(%d+)", function(line)
+                return place(line)
+            end)
+        end
+        mapped = mapped:gsub("(%S+):(%d+)", elsewhere)
+        local frames = {}
+        for frame in (trace or ""):gmatch("[^\\n]+") do
+            local at = nil
+            if prefix ~= nil then
+                local line = frame:match(prefix .. ":(%d+)")
+                if line ~= nil then
+                    at = place(line)
+                end
+            end
+            if at == nil then
+                for source, line in frame:gmatch("(%S+):(%d+)") do
+                    at = elsewhere(source, line)
+                    if at ~= nil then
+                        break
+                    end
+                end
+            end
+            if at ~= nil then` : `
         if chunk == nil then
             chunk = message:match("^(.-):%d+:")
         end
@@ -2367,8 +2826,9 @@ ${G} = {
         for frame in (trace or ""):gmatch("[^\\n]+") do
             local line = frame:match(prefix .. ":(%d+)")
             local at = line ~= nil and place(line) or nil
-            if at ~= nil then
-                local name = frame:match("function ([%w_.:]+)")
+            if at ~= nil then`}
+                -- Luau writes \`function name\`; Lua 5.1, \`function 'name'\`.
+                local name = frame:match("function ([%w_.:]+)") or frame:match("function '([^']+)'")
                 frames[#frames + 1] = "    at " .. at .. (name ~= nil and (" (" .. name .. ")") or "")
             end
         end
@@ -2377,13 +2837,36 @@ ${G} = {
         end
         return mapped .. "\\n" .. table.concat(frames, "\\n")
     end,
-    records = {},
+    records = {},${several ? `
+    -- The file each module outside this one is in, as \`load\` is handed it.
+    files = { ${files} },
+    loaded = {},
+    -- Every file's line map: by the module, and by the file's name.
+    maps = {},
+    sources = {},
+    -- Another of the bundle's files: a function that adds its modules here.
+    load = function(file)
+        if ${G}.loaded[file] then
+            return
+        end
+        ${G}.loaded[file] = true${loader(G, options.target)}
+    end,` : ""}${options.imports ? `
+    -- \`import("./x")\`: the module's exports, asked for where the code runs
+    -- rather than before its module does. \`require\` does the rest \u2014 and
+    -- loads the file the module is in, if it is not this one.
+    import = function(name)
+        return ${G}.require(name)
+    end,` : ""}
     require = function(name)
         local record = ${G}.records[name]
         if record ~= nil then
             return record.exports
         end
-        local module = ${G}.modules[name]
+        local module = ${G}.modules[name]${several ? `
+        if module == nil then
+            ${G}.load(${G}.files[name])
+            module = ${G}.modules[name]
+        end` : ""}
         local initialized = {}
         local exports = setmetatable({}, {
             __index = function(_, key)
@@ -2402,7 +2885,7 @@ ${G} = {
                     return source[link[2]]
                 end
                 if module.stars ~= nil and key ~= "default" then
-                    for _, star in module.stars do
+                    for _, star in ipairs(module.stars) do
                         local value = ${G}.require(star)[key]
                         if value ~= nil then
                             return value
@@ -2427,7 +2910,7 @@ ${G} = {
 }
 function stampOf(file) {
   try {
-    const at = (0, import_node_fs2.statSync)(file);
+    const at = (0, import_node_fs3.statSync)(file);
     return `${at.size}:${at.mtimeMs}`;
   } catch {
     return void 0;
@@ -2443,19 +2926,19 @@ function parseFile(file, diagnostics, directives) {
   }
   let text;
   try {
-    text = (0, import_node_fs2.readFileSync)(file, "utf8");
+    text = (0, import_node_fs3.readFileSync)(file, "utf8");
   } catch {
     diagnostics.push({ file, message: "Cannot read file", line: 1, column: 1, category: "module" });
     return void 0;
   }
   try {
-    const program2 = (0, import_parser6.parse)(text);
-    const found = (0, import_parser6.directivesOf)(text);
+    const program2 = (0, import_parser7.parse)(text);
+    const found = (0, import_parser7.directivesOf)(text);
     directives.set(file, found);
     if (stamp !== void 0) parsedFiles.set(file, { stamp, program: program2, text, directives: found });
     return { program: program2, text };
   } catch (error) {
-    if (error instanceof import_parser6.ParseError || error instanceof import_parser6.LexError) {
+    if (error instanceof import_parser7.ParseError || error instanceof import_parser7.LexError) {
       const { line, column } = error;
       diagnostics.push({ file, message: error.message, line, column, category: "syntax" });
       return void 0;
@@ -2470,14 +2953,14 @@ var libraryCache = /* @__PURE__ */ new Map();
 function parsedLibrary(file) {
   let stamp;
   try {
-    const at = (0, import_node_fs2.statSync)(file);
+    const at = (0, import_node_fs3.statSync)(file);
     stamp = `${at.size}:${at.mtimeMs}`;
   } catch {
     stamp = "";
   }
   const cached = libraryCache.get(file);
   if (cached && cached.stamp === stamp) return cached.program;
-  const program2 = (0, import_parser6.parse)((0, import_node_fs2.readFileSync)(file, "utf8"));
+  const program2 = (0, import_parser7.parse)((0, import_node_fs3.readFileSync)(file, "utf8"));
   libraryCache.set(file, { stamp, program: program2 });
   return program2;
 }
@@ -2485,9 +2968,11 @@ var moduleAnalyses = /* @__PURE__ */ new Map();
 function analyzeModules(modules, config) {
   const out = [];
   const analyses = /* @__PURE__ */ new Map();
-  const libraries = config ? (0, import_parser6.resolveTypeLibraries)(config) : { files: [], lowerings: [], problems: [] };
+  const libraries = config ? (0, import_parser7.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(parsedLibrary);
+  const noLib = config?.noLib ?? false;
+  const checked = libs.length > 0 || !noLib;
   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();
@@ -2500,49 +2985,50 @@ function analyzeModules(modules, config) {
     const done = analyzed.get(file);
     if (done) return done;
     const remembered = moduleAnalyses.get(file);
-    if (remembered && remembered.setting === settingFor && libs.length === remembered.libs.length && remembered.libs.every((lib, i) => lib === libs[i]) && remembered.program === program2 && [...remembered.read].every(([read2, stamp]) => stampOf(read2) === stamp)) {
+    if (remembered && remembered.setting === settingFor && libs.length === remembered.libs.length && remembered.libs.every((lib, i) => lib === libs[i]) && remembered.program === program2 && [...remembered.read].every(([read3, stamp]) => stampOf(read3) === stamp)) {
       analyzed.set(file, remembered.result);
       readWhile.set(file, remembered.read);
       return remembered.result;
     }
-    const scopes = (0, import_parser6.analyzeScopes)(program2, { builtinGlobals: globals, reportUndeclared: libs.length > 0 });
+    const scopes = (0, import_parser7.analyzeScopes)(program2, { builtinGlobals: globals, reportUndeclared: checked, noLib });
     const said = [];
     for (const d of scopes.diagnostics) {
       if (d.kind !== "undeclared") continue;
       said.push({ file, message: d.message, line: d.node.line.start, column: d.node.column.start, category: "type" });
     }
     const before = partials;
-    const types = (0, import_parser6.analyzeTypes)(program2, scopes, {
+    const types = (0, import_parser7.analyzeTypes)(program2, scopes, {
       libs,
       resolveModule: resolverFor(file),
-      reportUnknownTypes: libs.length > 0
+      noLib,
+      reportUnknownTypes: checked
     });
     for (const d of types.diagnostics) {
       const at = d.node;
       said.push({ file, message: d.message, line: at.line.start, column: at.column.start, category: "type" });
     }
-    const result = { types, diagnostics: said };
+    const result2 = { types, diagnostics: said };
     if (partials === before) {
-      analyzed.set(file, result);
-      const read2 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
+      analyzed.set(file, result2);
+      const read3 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
       const own = stampOf(file);
-      if (own !== void 0) read2.set(file, own);
-      readWhile.set(file, read2);
-      if ([...read2.values()].every((stamp) => stamp !== void 0)) {
-        moduleAnalyses.set(file, { setting: settingFor, libs: [...libs], program: program2, read: read2, result });
+      if (own !== void 0) read3.set(file, own);
+      readWhile.set(file, read3);
+      if ([...read3.values()].every((stamp) => stamp !== void 0)) {
+        moduleAnalyses.set(file, { setting: settingFor, libs: [...libs], program: program2, read: read3, result: result2 });
       }
     }
-    return result;
+    return result2;
   };
   const resolverFor = (file) => (specifier) => {
-    const target = (0, import_parser6.resolveModulePath)(file, specifier, config);
+    const target = (0, import_parser7.resolveModulePath)(file, specifier, config);
     if (!target) return void 0;
     const noteRead = () => {
-      const read2 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
-      readWhile.set(file, read2);
+      const read3 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
+      readWhile.set(file, read3);
       const stamp = stampOf(target);
-      if (stamp !== void 0) read2.set(target, stamp);
-      for (const [below, belowStamp] of readWhile.get(target) ?? []) read2.set(below, belowStamp);
+      if (stamp !== void 0) read3.set(target, stamp);
+      for (const [below, belowStamp] of readWhile.get(target) ?? []) read3.set(below, belowStamp);
     };
     if (inProgress.has(target)) {
       partials++;
@@ -2556,16 +3042,16 @@ function analyzeModules(modules, config) {
     let program2 = byFile.get(target)?.program;
     if (!program2) {
       try {
-        program2 = (0, import_parser6.parse)((0, import_node_fs2.readFileSync)(target, "utf8"));
+        program2 = (0, import_parser7.parse)((0, import_node_fs3.readFileSync)(target, "utf8"));
       } catch {
         return void 0;
       }
     }
     inProgress.add(target);
     try {
-      const scopes = (0, import_parser6.analyzeScopes)(program2, { builtinGlobals: globals });
-      const types = byFile.has(target) ? analyzeModule(target, program2).types : (0, import_parser6.analyzeTypes)(program2, scopes, { libs, resolveModule: resolverFor(target), diagnostics: false });
-      const exports2 = (0, import_parser6.moduleExports)(program2, scopes, types, resolverFor(target));
+      const scopes = (0, import_parser7.analyzeScopes)(program2, { builtinGlobals: globals, noLib });
+      const types = byFile.has(target) ? analyzeModule(target, program2).types : (0, import_parser7.analyzeTypes)(program2, scopes, { libs, noLib, resolveModule: resolverFor(target), diagnostics: false });
+      const exports2 = (0, import_parser7.moduleExports)(program2, scopes, types, resolverFor(target));
       exportsCache.set(target, exports2);
       noteRead();
       return exports2;
@@ -2598,37 +3084,39 @@ function allStatements(statements) {
 }
 
 // src/compile.ts
-var import_node_fs3 = require("fs");
+var import_node_fs4 = require("fs");
 var import_node_path3 = require("path");
-var import_parser7 = require("@tilua/parser");
+var import_parser8 = require("@tilua/parser");
 var import_luau_parser3 = require("luau-parser");
 async function compile(source, config) {
   let program2;
   try {
-    program2 = (0, import_parser7.parse)(source);
+    program2 = (0, import_parser8.parse)(source);
   } catch (error) {
-    if (error instanceof import_parser7.ParseError || error instanceof import_parser7.LexError) {
+    if (error instanceof import_parser8.ParseError || error instanceof import_parser8.LexError) {
       const { line, column } = error;
       return { diagnostics: [{ message: error.message, line, column }] };
     }
     throw error;
   }
-  const scopes = (0, import_parser7.analyzeScopes)(program2);
+  const { config: resolved, problems } = resolveConfig(config, (0, import_node_path3.resolve)("main.tilua"));
+  const noLib = resolved?.noLib ?? false;
+  const scopes = (0, import_parser8.analyzeScopes)(program2, { noLib });
   const diagnostics = scopes.diagnostics.map((d) => ({
     message: d.message,
     line: d.node.line.start,
     column: d.node.column.start
   }));
-  const { config: resolved, problems } = resolveConfig(config, (0, import_node_path3.resolve)("main.tilua"));
-  const libraries = resolved ? (0, import_parser7.resolveTypeLibraries)(resolved) : { files: [], lowerings: [], problems: [] };
+  const libraries = resolved ? (0, import_parser8.resolveTypeLibraries)(resolved) : { files: [], lowerings: [], problems: [] };
   const { lowerings, problems: loweringProblems } = await loadLowerings(libraries.lowerings);
   for (const p of [...problems, ...libraries.problems]) {
     diagnostics.push({ message: p.message, line: p.line ?? 1, column: p.column ?? 1 });
   }
   for (const p of loweringProblems) diagnostics.push({ message: p.message, line: 1, column: 1 });
-  const libs = libraries.files.map((file) => (0, import_parser7.parse)((0, import_node_fs3.readFileSync)(file, "utf8")));
+  const libs = libraries.files.map((file) => (0, import_parser8.parse)((0, import_node_fs4.readFileSync)(file, "utf8")));
   const lowered = lower(program2, scopes, {
-    types: (0, import_parser7.analyzeTypes)(program2, scopes, { libs, diagnostics: false }),
+    types: (0, import_parser8.analyzeTypes)(program2, scopes, { libs, noLib, diagnostics: false }),
+    noLib,
     lowerings,
     target: resolved?.target,
     source