@tilua/compiler 3.0.1 → 4.0.0

package/dist/index.cjs

@@ -35,7 +35,7 @@ var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
 // src/bundle.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
-var import_parser3 = require("@tilua/parser");
+var import_parser6 = require("@tilua/parser");
 var import_luau_parser2 = require("luau-parser");
 
 // src/config.ts
@@ -50,10 +50,11 @@ function resolveConfig(input, entry, cwd = process.cwd()) {
 }
 
 // src/lower.ts
-var import_parser2 = require("@tilua/parser");
+var import_parser4 = require("@tilua/parser");
 var import_luau_parser = require("luau-parser");
 
 // src/luau.ts
+var import_parser2 = require("@tilua/parser");
 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() });
@@ -61,7 +62,7 @@ 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 = (object2, property) => isLuauName(property) ? { type: "MemberExpression", object: object2, property: identifier(property), ...span() } : index(object2, string(property));
+var member = (object2, property) => (0, import_parser2.isLuauName)(property) ? { type: "MemberExpression", object: object2, property: identifier(property), ...span() } : index(object2, string(property));
 var index = (object2, key) => ({ type: "IndexExpression", object: object2, index: key, ...span() });
 var call = (callee, args) => ({ type: "CallExpression", callee, arguments: args, ...span() });
 var methodCall = (object2, method, args) => ({ type: "MethodCallExpression", object: object2, method: identifier(method), arguments: args, ...span() });
@@ -70,7 +71,7 @@ var binary = (operator, left, right) => ({ type: "BinaryExpression", operator, l
 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 field = (key, value) => (0, import_parser2.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",
@@ -114,32 +115,6 @@ var functionBody = (params, statements, hasVarargs = false) => ({
 });
 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/names.ts
 var Names = class _Names {
@@ -182,6 +157,7 @@ var Names = class _Names {
 
 // src/language.ts
 var import_node_fs = require("fs");
+var import_parser3 = require("@tilua/parser");
 var read = (name) => (0, import_node_fs.readFileSync)(new URL(`../runtime/${name}`, importMetaUrl), "utf8");
 var implemented = (source) => new Set([...source.matchAll(/function __NAME__\.(\w+)/g)].map((m) => m[1]));
 var array = read("array.luau");
@@ -215,7 +191,7 @@ function objectKeys(type) {
     orders.push(keys);
   }
   const order = JSON.stringify(orders[0] ?? []);
-  const known = orders.length && orders.every((keys) => JSON.stringify(keys) === order) ? `{ ${orders[0].map((key) => JSON.stringify(key)).join(", ")} }` : "nil";
+  const known = orders.length && orders.every((keys) => JSON.stringify(keys) === order) ? `{ ${orders[0].map((key) => (0, import_parser3.luauString)(key)).join(", ")} }` : "nil";
   return { known, open: String(open) };
 }
 var plugin = {
@@ -274,11 +250,11 @@ var Lowerer = class {
   origins = /* @__PURE__ */ new WeakMap();
   run() {
     const body = this.options.module ? this.module(this.options.module) : this.topLevel(this.source.body.statements);
+    const scriptArgs = this.usesScriptArgs && !this.options.module ? [local(["scriptArgs"], [this.array(table([{ type: "TableFieldPositional", value: vararg() }]))])] : [];
     const helpers = this.helperDefinitions();
     const captured = [...this.builtins].map(([global, local2]) => local([local2], [identifier(global)]));
-    const scriptArgs = this.usesScriptArgs && !this.options.module ? [local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: vararg() }])])] : [];
     return {
-      statements: [...scriptArgs, ...captured, ...helpers, ...this.classRuntimeStatements(), ...body],
+      statements: [...captured, ...helpers, ...scriptArgs, ...this.classRuntimeStatements(), ...body],
       exportsName: this.exportsName,
       module: this.info,
       diagnostics: this.diagnostics,
@@ -296,7 +272,7 @@ var Lowerer = class {
   // --------------------------------------------------------
   /** A tilua name as Luau can write it: `local` is a keyword there. */
   name(name) {
-    if (!LUAU_KEYWORDS.has(name)) return name;
+    if (!import_parser2.LUAU_KEYWORDS.has(name)) return name;
     let renamed = this.renamed.get(name);
     if (!renamed) {
       renamed = this.names.fresh(`${name}_`);
@@ -328,11 +304,36 @@ var Lowerer = class {
   helper(kind) {
     let name = this.helpers.get(kind);
     if (!name) {
-      name = this.names.fresh(`tilua_${kind}`);
+      name = this.names.fresh(`tilua_${kind === "array" ? "asArray" : kind}`);
       this.helpers.set(kind, name);
     }
     return identifier(name);
   }
+  // `typeof v` tells an array from an object, which Luau cannot: both are
+  // tables. So every array the program makes — `[a, b]`, a rest parameter,
+  // what `:map` answers — is written down as one, in a table that holds its
+  // keys weakly, and `typeof` looks there. A table nothing wrote down (one a
+  // Lua library made) is told by its type where that says, and by its shape
+  // where it does not.
+  /** `value`, a new array, written down as one. */
+  array(value) {
+    const marked = call(this.helper("array"), [value]);
+    this.marked.add(marked);
+    return marked;
+  }
+  /** The calls `array` made: each answers the one table it was given. */
+  marked = /* @__PURE__ */ new WeakSet();
+  /** Luau reaching the record of arrays: the bundle's, or this file's own. */
+  arrays() {
+    return this.options.module?.arrays ?? this.helper("arrays").name;
+  }
+  typeofExpression(node) {
+    const known = this.options.types?.typeofTables.get(node);
+    let argument = node.argument;
+    while (argument.type === "ParenthesizedExpression") argument = argument.expression;
+    const value = this.expression(argument);
+    return call(this.helper("typeof"), known ? [value, string(known)] : [this.keptToOne(value)]);
+  }
   /** 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. */
@@ -400,7 +401,7 @@ var Lowerer = class {
       const type = this.options.types?.typeOf.get(argument);
       return {
         type,
-        typeText: type ? (0, import_parser2.formatType)(type) : void 0,
+        typeText: type ? (0, import_parser4.formatType)(type) : void 0,
         source: this.writtenSource(argument),
         declaration: declaration ? this.writtenSource(declaration) : void 0,
         spread: argument.type === "SpreadElement"
@@ -527,6 +528,46 @@ var Lowerer = class {
   }
   helperDefinitions() {
     const out = [];
+    const runtimes = this.runtimeDefinitions();
+    if (this.helpers.has("concat")) this.helper("array");
+    const marker = this.helpers.get("array");
+    const typeOf = this.helpers.get("typeof");
+    if (marker || typeOf) {
+      const arrays = this.arrays();
+      const own = this.helpers.get("arrays");
+      if (own) {
+        out.push(...(0, import_luau_parser.parse)(`local ${own} = ${this.builtin("setmetatable").name}({}, { __mode = "k" })`).body.statements);
+      }
+      if (marker) {
+        out.push(...(0, import_luau_parser.parse)(`
+local function ${marker}(t)
+	${arrays}[t] = true
+	return t
+end`).body.statements);
+      }
+      if (typeOf) {
+        out.push(...(0, import_luau_parser.parse)(`
+local function ${typeOf}(value, known)
+	local name = ${this.builtin(this.lua51 ? "type" : "typeof").name}(value)
+	if name ~= "table" then
+		return name
+	end
+	if known ~= nil then
+		return known
+	end
+	if ${arrays}[value] then
+		return "array"
+	end
+	if ${this.builtin("getmetatable").name}(value) ~= nil then
+		return "object"
+	end
+	if #value > 0 then
+		return "array"
+	end
+	return "object"
+end`).body.statements);
+      }
+    }
     const assign2 = this.helpers.get("assign");
     if (assign2) {
       out.push(localFunction(assign2, functionBody(["target"], [
@@ -541,25 +582,11 @@ var Lowerer = class {
         returns([identifier("target")])
       ], true)));
     }
-    for (const { index: index2, runtime: runtime2, name } of this.loweringUsed) {
-      const { plugin: plugin2, from } = this.lowerings[index2];
-      const source = plugin2.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;
-      }
-      const lines = this.options.module?.lines ?? "nil";
-      const fail = this.options.module?.fail ?? "nil";
-      out.push(...(0, import_luau_parser.parse)(source.replace(/__NAME__/g, name).replace(/__LINES__/g, lines).replace(/__FAIL__/g, fail)).body.statements);
-    }
+    out.push(...runtimes);
     const concat = this.helpers.get("concat");
     if (concat) {
       out.push(localFunction(concat, functionBody([], [
-        local(["result"], [table([])]),
+        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"), [
@@ -575,6 +602,26 @@ var Lowerer = class {
     }
     return out;
   }
+  /** The runtime tables the file's libraries were asked for. */
+  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];
+      if (source === void 0) {
+        this.diagnostics.push({
+          message: `'${from}' asked for a runtime it does not have: '${runtime2}'`,
+          line: 1,
+          column: 1
+        });
+        continue;
+      }
+      const lines = this.options.module?.lines ?? "nil";
+      const fail = this.options.module?.fail ?? "nil";
+      out.push(...(0, import_luau_parser.parse)(source.replace(/__NAME__/g, name).replace(/__LINES__/g, lines).replace(/__FAIL__/g, fail).replace(/__ARRAY__/g, () => this.helper("array").name)).body.statements);
+    }
+    return out;
+  }
   // --------------------------------------------------------
   // Modules
   // --------------------------------------------------------
@@ -1327,7 +1374,7 @@ end
           number(pattern.elements.length + 1),
           unary("#", source),
           number(1),
-          table([])
+          this.array(table([]))
         ]);
         const rest = this.restTarget(pattern.rest, elements, mode, after);
         after.push(...rest.then);
@@ -1381,7 +1428,7 @@ end
     const names = [];
     for (const p of params) {
       if (p.rest) {
-        prelude.push(local([this.name(p.name)], [table([{ type: "TableFieldPositional", value: vararg() }])]));
+        prelude.push(local([this.name(p.name)], [this.array(table([{ type: "TableFieldPositional", value: vararg() }]))]));
         continue;
       }
       const name = p.pattern ? this.names.fresh("arg") : this.name(p.name);
@@ -1439,6 +1486,7 @@ end
         return binary(node.operator, left, right);
       }
       case "UnaryExpression":
+        if (node.operator === "typeof") return this.typeofExpression(node);
         return unary(node.operator, this.expression(node.argument));
       case "SuperExpression":
         return this.superClassReference(node);
@@ -1479,6 +1527,9 @@ end
   callValues(node) {
     const chain = optionalChain(node);
     if (chain) return this.optionalChainExpression(chain);
+    if (node.type === "CallExpression" && (node.callee.type === "SuperExpression" || node.callee.type === "MemberExpression" && node.callee.object.type === "SuperExpression")) {
+      return this.expression(node);
+    }
     const object2 = linkObject(node);
     if (node.type === "CallExpression" && object2.type === "Identifier") {
       return this.link(node, this.reference(object2));
@@ -1490,7 +1541,7 @@ end
    *  kept to one there, `f((g()))`. Every value is taken only where the
    *  program asks for them, as an array's last element: `[g()]`. */
   keptToOne(value) {
-    return expandsToMany(value) ? parenthesized(value) : value;
+    return expandsToMany(value) && !this.marked.has(value) ? parenthesized(value) : value;
   }
   /** Is this `scriptArgs` the language's own, not a name the file declared? */
   isLanguageGlobal(node) {
@@ -1544,7 +1595,7 @@ end
             ...args
           ]);
         }
-        if (!isLuauName(node.method.name)) {
+        if (!import_parser2.isLuauName(node.method.name)) {
           this.report(node.method, `'${node.method.name}' is a Luau keyword and cannot be called with ':'`);
         }
         return methodCall(object2, node.method.name, args);
@@ -1771,7 +1822,7 @@ end
   arrayExpression(node) {
     const elements = packs(node.elements).items;
     if (!elements.some((e) => e.type === "SpreadElement")) {
-      return table(elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) })));
+      return this.array(table(elements.map((e) => ({ type: "TableFieldPositional", value: this.expression(e) }))));
     }
     const parts = [];
     let current = [];
@@ -1906,7 +1957,7 @@ function topLevelDeclaration(statements, name) {
 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}`;
+  return /^[A-Za-z_]/.test(cleaned) && !import_parser2.LUAU_KEYWORDS.has(cleaned) ? cleaned : `module_${cleaned}`;
 }
 function alwaysTruthy(value) {
   switch (value.type) {
@@ -2021,6 +2072,7 @@ var CLASS_METAMETHODS = [
 ];
 
 // src/linemap.ts
+var import_parser5 = require("@tilua/parser");
 function statementsOf(node) {
   const out = [];
   const visit = (value) => {
@@ -2053,7 +2105,7 @@ function buildLineMap(emitted, printed, origins) {
 }
 function lineMapSource(map) {
   const entries = [...map.entries()].sort((a, b) => a[0] - b[0]);
-  const quoted = (s) => JSON.stringify(s.replace(/\\/g, "/"));
+  const quoted = (s) => (0, import_parser5.luauString)(s.replace(/\\/g, "/"));
   return `{${entries.map(([line, o]) => `[${line}]={${quoted(o.file)},${o.line}}`).join(",")}}`;
 }
 
@@ -2102,13 +2154,13 @@ async function bundle(options) {
     const parsed = parseFile(file, diagnostics, directives);
     if (!parsed) return { modules: [], diagnostics };
     const { program: program3, text } = parsed;
-    const scopes = (0, import_parser3.analyzeScopes)(program3);
+    const scopes = (0, import_parser6.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 = (0, import_parser3.resolveModulePath)(file, specifier, config);
+      const target = (0, import_parser6.resolveModulePath)(file, specifier, config);
       if (target && !target.endsWith(".d.tilua")) queue.push(target);
     }
   }
@@ -2141,8 +2193,9 @@ async function bundle(options) {
         require: requireExpression,
         lines: `${G}.lines`,
         fail: `${G}.fail`,
+        arrays: `${G}.arrays`,
         resolve: (specifier) => {
-          const target = (0, import_parser3.resolveModulePath)(file, specifier, config);
+          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;
@@ -2164,14 +2217,14 @@ async function bundle(options) {
   }
   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_parser3.applyDirectives)(fileDirectives, semantic, (d) => d.line);
+    const { kept, unusedExpectErrors } = (0, import_parser6.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_parser3.UNUSED_EXPECT_ERROR, line: d.line, column: d.column, category: "type" });
+      diagnostics.push({ file, message: import_parser6.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}`));
@@ -2186,6 +2239,7 @@ async function bundle(options) {
   const assignment = program2.body.statements[1];
   if ([...modules.values()].some((m) => m.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);
   }
   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");
@@ -2207,7 +2261,7 @@ async function bundle(options) {
   const result = names.fresh("result");
   const entryStatements = (0, import_luau_parser2.parse)(`
 local ${ok}, ${result} = xpcall(function()
-    return ${G}.require(${JSON.stringify(sources.get(entry).name)})
+    return ${G}.require(${(0, import_parser6.luauString)(sources.get(entry).name)})
 end, ${G}.fail)
 if not ${ok} then
     error(${result}, 0)
@@ -2229,6 +2283,9 @@ function runtime(G) {
 local ${G}
 ${G} = {
     modules = {},
+    -- Every array the program made, so \`typeof\` can tell one from an object.
+    -- The keys are held weakly: being written down keeps no array alive.
+    arrays = setmetatable({}, { __mode = "k" }),
     -- Filled in just before the entry runs: bundle line -> { file, line }.
     lines = nil,
     -- What an error nothing caught says, in the project's files: the bundle's
@@ -2236,19 +2293,64 @@ ${G} = {
     -- and a traceback of those places follows. A message that is not a string
     -- is left as it is, and a position that is not this bundle's (a library
     -- that raised its error with one already mapped) is left alone.
+    --
+    -- It is an \`xpcall\` handler, and a handler that fails loses the error
+    -- altogether: Luau reports only "error in error handling". So the work is
+    -- done under \`pcall\`, leaning on nothing it has not checked is there (an
+    -- executor may lack \`debug.info\`, or refuse it), and an error it cannot
+    -- map is still answered as Luau raised it, with why.
     fail = function(message)
+        -- Taken first, before anything that can fail. Level 3 is the frame
+        -- that raised: past \`pcall\` and this handler.
+        local trace
+        if debug ~= nil and debug.traceback ~= nil then
+            local ok, text = pcall(debug.traceback, "", 3)
+            if ok and type(text) == "string" then
+                trace = text
+            end
+        end
+        local ok, described = pcall(${G}.describe, message, trace)
+        if ok then
+            return described
+        end
+        if type(message) ~= "string" then
+            return message
+        end
+        local why = type(described) == "string" and described or "unknown"
+        return message .. "\\n(tilua could not map this error to the project's files: " .. why .. ")" .. (trace or "")
+    end,
+    -- \`fail\`'s work. \`trace\` is a traceback from where the error was
+    -- raised, or nil when none could be taken.
+    describe = function(message, trace)
         if type(message) ~= "string" then
             return message
         end
         local lines = ${G}.lines
         if lines == nil then
-            return debug.traceback(message, 2)
+            return message .. (trace or "")
         end
+        -- The bundle's name, as a position in a message spells it: where this
+        -- function is, asked of the debug library by the function rather
+        -- than by a level, which \`pcall\` would shift. Failing that, a message
+        -- starts with the position it was raised at.
         local chunk
-        if debug.info ~= nil then
-            chunk = debug.info(1, "s")
-        else
-            chunk = debug.getinfo(1, "S").short_src
+        if debug ~= nil and debug.info ~= nil then
+            local found, source = pcall(debug.info, ${G}.describe, "s")
+            if found and type(source) == "string" then
+                chunk = source
+            end
+        end
+        if chunk == nil and debug ~= nil and debug.getinfo ~= nil then
+            local found, info = pcall(debug.getinfo, ${G}.describe, "S")
+            if found and type(info) == "table" and type(info.short_src) == "string" then
+                chunk = info.short_src
+            end
+        end
+        if chunk == nil then
+            chunk = message:match("^(.-):%d+:")
+        end
+        if chunk == nil then
+            return message .. (trace or "")
         end
         local prefix = chunk:gsub("%p", "%%%0")
         local function place(line)
@@ -2262,7 +2364,7 @@ ${G} = {
             return place(line)
         end)
         local frames = {}
-        for frame in debug.traceback("", 2):gmatch("[^\\n]+") do
+        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
@@ -2347,13 +2449,13 @@ function parseFile(file, diagnostics, directives) {
     return void 0;
   }
   try {
-    const program2 = (0, import_parser3.parse)(text);
-    const found = (0, import_parser3.directivesOf)(text);
+    const program2 = (0, import_parser6.parse)(text);
+    const found = (0, import_parser6.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_parser3.ParseError || error instanceof import_parser3.LexError) {
+    if (error instanceof import_parser6.ParseError || error instanceof import_parser6.LexError) {
       const { line, column } = error;
       diagnostics.push({ file, message: error.message, line, column, category: "syntax" });
       return void 0;
@@ -2375,7 +2477,7 @@ function parsedLibrary(file) {
   }
   const cached = libraryCache.get(file);
   if (cached && cached.stamp === stamp) return cached.program;
-  const program2 = (0, import_parser3.parse)((0, import_node_fs2.readFileSync)(file, "utf8"));
+  const program2 = (0, import_parser6.parse)((0, import_node_fs2.readFileSync)(file, "utf8"));
   libraryCache.set(file, { stamp, program: program2 });
   return program2;
 }
@@ -2383,7 +2485,7 @@ var moduleAnalyses = /* @__PURE__ */ new Map();
 function analyzeModules(modules, config) {
   const out = [];
   const analyses = /* @__PURE__ */ new Map();
-  const libraries = config ? (0, import_parser3.resolveTypeLibraries)(config) : { files: [], lowerings: [], problems: [] };
+  const libraries = config ? (0, import_parser6.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 globals = libs.flatMap((lib) => lib.body.statements.flatMap((s) => s.type === "DeclareStatement" ? [s.name] : []));
@@ -2403,14 +2505,14 @@ function analyzeModules(modules, config) {
       readWhile.set(file, remembered.read);
       return remembered.result;
     }
-    const scopes = (0, import_parser3.analyzeScopes)(program2, { builtinGlobals: globals, reportUndeclared: libs.length > 0 });
+    const scopes = (0, import_parser6.analyzeScopes)(program2, { builtinGlobals: globals, reportUndeclared: libs.length > 0 });
     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_parser3.analyzeTypes)(program2, scopes, {
+    const types = (0, import_parser6.analyzeTypes)(program2, scopes, {
       libs,
       resolveModule: resolverFor(file),
       reportUnknownTypes: libs.length > 0
@@ -2433,7 +2535,7 @@ function analyzeModules(modules, config) {
     return result;
   };
   const resolverFor = (file) => (specifier) => {
-    const target = (0, import_parser3.resolveModulePath)(file, specifier, config);
+    const target = (0, import_parser6.resolveModulePath)(file, specifier, config);
     if (!target) return void 0;
     const noteRead = () => {
       const read2 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
@@ -2454,16 +2556,16 @@ function analyzeModules(modules, config) {
     let program2 = byFile.get(target)?.program;
     if (!program2) {
       try {
-        program2 = (0, import_parser3.parse)((0, import_node_fs2.readFileSync)(target, "utf8"));
+        program2 = (0, import_parser6.parse)((0, import_node_fs2.readFileSync)(target, "utf8"));
       } catch {
         return void 0;
       }
     }
     inProgress.add(target);
     try {
-      const scopes = (0, import_parser3.analyzeScopes)(program2, { builtinGlobals: globals });
-      const types = byFile.has(target) ? analyzeModule(target, program2).types : (0, import_parser3.analyzeTypes)(program2, scopes, { libs, resolveModule: resolverFor(target), diagnostics: false });
-      const exports2 = (0, import_parser3.moduleExports)(program2, scopes, types, resolverFor(target));
+      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));
       exportsCache.set(target, exports2);
       noteRead();
       return exports2;
@@ -2498,35 +2600,35 @@ function allStatements(statements) {
 // src/compile.ts
 var import_node_fs3 = require("fs");
 var import_node_path3 = require("path");
-var import_parser4 = require("@tilua/parser");
+var import_parser7 = require("@tilua/parser");
 var import_luau_parser3 = require("luau-parser");
 async function compile(source, config) {
   let program2;
   try {
-    program2 = (0, import_parser4.parse)(source);
+    program2 = (0, import_parser7.parse)(source);
   } catch (error) {
-    if (error instanceof import_parser4.ParseError || error instanceof import_parser4.LexError) {
+    if (error instanceof import_parser7.ParseError || error instanceof import_parser7.LexError) {
       const { line, column } = error;
       return { diagnostics: [{ message: error.message, line, column }] };
     }
     throw error;
   }
-  const scopes = (0, import_parser4.analyzeScopes)(program2);
+  const scopes = (0, import_parser7.analyzeScopes)(program2);
   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_parser4.resolveTypeLibraries)(resolved) : { files: [], lowerings: [], problems: [] };
+  const libraries = resolved ? (0, import_parser7.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_parser4.parse)((0, import_node_fs3.readFileSync)(file, "utf8")));
+  const libs = libraries.files.map((file) => (0, import_parser7.parse)((0, import_node_fs3.readFileSync)(file, "utf8")));
   const lowered = lower(program2, scopes, {
-    types: (0, import_parser4.analyzeTypes)(program2, scopes, { libs, diagnostics: false }),
+    types: (0, import_parser7.analyzeTypes)(program2, scopes, { libs, diagnostics: false }),
     lowerings,
     target: resolved?.target,
     source

package/dist/index.d.cts

@@ -100,6 +100,9 @@ interface ModuleContext {
      *  reads, as `__FAIL__`, to report an error from a callback the way an
      *  error that reached the entry is reported. */
     readonly fail?: string;
+    /** Luau reaching the bundle's record of which tables are arrays, so that
+     *  every module marks and reads the same one (`typeof`). */
+    readonly arrays?: string;
 }
 interface LowerOptions {
     /** Lower the file as a module of a bundle. Without it, `import` and

package/dist/index.d.ts

@@ -100,6 +100,9 @@ interface ModuleContext {
      *  reads, as `__FAIL__`, to report an error from a callback the way an
      *  error that reached the entry is reported. */
     readonly fail?: string;
+    /** Luau reaching the bundle's record of which tables are arrays, so that
+     *  every module marks and reads the same one (`typeof`). */
+    readonly arrays?: string;
 }
 interface LowerOptions {
     /** Lower the file as a module of a bundle. Without it, `import` and

package/dist/index.js

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

package/package.json

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