@tilua/compiler 3.0.1 → 4.0.0

package/dist/cli.cjs

@@ -12,7 +12,7 @@ var import_node_path3 = require("path");
 // 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
@@ -27,10 +27,11 @@ function resolveConfig(input, entry2, 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() });
@@ -38,7 +39,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, args2) => ({ type: "CallExpression", callee, arguments: args2, ...span() });
 var methodCall = (object2, method, args2) => ({ type: "MethodCallExpression", object: object2, method: identifier(method), arguments: args2, ...span() });
@@ -47,7 +48,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",
@@ -90,32 +91,6 @@ var functionBody = (params, statements, hasVarargs = false) => ({
   ...span()
 });
 var localFunction = (name, func) => ({ type: "LocalFunctionStatement", name: identifier(name), func, ...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 {
@@ -158,6 +133,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");
@@ -191,7 +167,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 = {
@@ -250,11 +226,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,
@@ -272,7 +248,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}_`);
@@ -304,11 +280,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. */
@@ -376,7 +377,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"
@@ -503,6 +504,46 @@ var Lowerer = class {
   }
   helperDefinitions() {
     const out2 = [];
+    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) {
+        out2.push(...(0, import_luau_parser.parse)(`local ${own} = ${this.builtin("setmetatable").name}({}, { __mode = "k" })`).body.statements);
+      }
+      if (marker) {
+        out2.push(...(0, import_luau_parser.parse)(`
+local function ${marker}(t)
+	${arrays}[t] = true
+	return t
+end`).body.statements);
+      }
+      if (typeOf) {
+        out2.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) {
       out2.push(localFunction(assign2, functionBody(["target"], [
@@ -517,25 +558,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";
-      out2.push(...(0, import_luau_parser.parse)(source.replace(/__NAME__/g, name).replace(/__LINES__/g, lines).replace(/__FAIL__/g, fail)).body.statements);
-    }
+    out2.push(...runtimes);
     const concat = this.helpers.get("concat");
     if (concat) {
       out2.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"), [
@@ -551,6 +578,26 @@ var Lowerer = class {
     }
     return out2;
   }
+  /** The runtime tables the file's libraries were asked for. */
+  runtimeDefinitions() {
+    const out2 = [];
+    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";
+      out2.push(...(0, import_luau_parser.parse)(source.replace(/__NAME__/g, name).replace(/__LINES__/g, lines).replace(/__FAIL__/g, fail).replace(/__ARRAY__/g, () => this.helper("array").name)).body.statements);
+    }
+    return out2;
+  }
   // --------------------------------------------------------
   // Modules
   // --------------------------------------------------------
@@ -1303,7 +1350,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);
@@ -1357,7 +1404,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);
@@ -1415,6 +1462,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);
@@ -1455,6 +1503,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));
@@ -1466,7 +1517,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) {
@@ -1520,7 +1571,7 @@ end
             ...args2
           ]);
         }
-        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, args2);
@@ -1747,7 +1798,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 = [];
@@ -1882,7 +1933,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) {
@@ -1997,6 +2048,7 @@ var CLASS_METAMETHODS = [
 ];
 
 // src/linemap.ts
+var import_parser5 = require("@tilua/parser");
 function statementsOf(node) {
   const out2 = [];
   const visit = (value) => {
@@ -2029,7 +2081,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(",")}}`;
 }
 
@@ -2078,13 +2130,13 @@ async function bundle(options) {
     const parsed = parseFile(file, diagnostics, directives);
     if (!parsed) return { modules: [], diagnostics };
     const { program: program2, text } = parsed;
-    const scopes = (0, import_parser3.analyzeScopes)(program2);
+    const scopes = (0, import_parser6.analyzeScopes)(program2);
     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: program2, scopes });
     for (const specifier of importedSpecifiers(program2)) {
-      const target = (0, import_parser3.resolveModulePath)(file, specifier, config2);
+      const target = (0, import_parser6.resolveModulePath)(file, specifier, config2);
       if (target && !target.endsWith(".d.tilua")) queue.push(target);
     }
   }
@@ -2117,8 +2169,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, config2);
+          const target = (0, import_parser6.resolveModulePath)(file, specifier, config2);
           if (!target || target.endsWith(".d.tilua") || !sources.has(target)) return void 0;
           pending.push(target);
           return sources.get(target).name;
@@ -2140,14 +2193,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}`));
@@ -2162,6 +2215,7 @@ async function bundle(options) {
   const assignment = program.body.statements[1];
   if ([...modules.values()].some((m) => m.usesScriptArgs)) {
     program.body.statements.unshift(local(["scriptArgs"], [table([{ type: "TableFieldPositional", value: { type: "VarargExpression" } }])]));
+    program.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");
@@ -2183,7 +2237,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(entry2).name)})
+    return ${G}.require(${(0, import_parser6.luauString)(sources.get(entry2).name)})
 end, ${G}.fail)
 if not ${ok} then
     error(${result}, 0)
@@ -2205,6 +2259,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
@@ -2212,19 +2269,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)
@@ -2238,7 +2340,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
@@ -2323,13 +2425,13 @@ function parseFile(file, diagnostics, directives) {
     return void 0;
   }
   try {
-    const program = (0, import_parser3.parse)(text);
-    const found = (0, import_parser3.directivesOf)(text);
+    const program = (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, text, directives: found });
     return { program, 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;
@@ -2351,7 +2453,7 @@ function parsedLibrary(file) {
   }
   const cached = libraryCache.get(file);
   if (cached && cached.stamp === stamp) return cached.program;
-  const program = (0, import_parser3.parse)((0, import_node_fs2.readFileSync)(file, "utf8"));
+  const program = (0, import_parser6.parse)((0, import_node_fs2.readFileSync)(file, "utf8"));
   libraryCache.set(file, { stamp, program });
   return program;
 }
@@ -2359,7 +2461,7 @@ var moduleAnalyses = /* @__PURE__ */ new Map();
 function analyzeModules(modules, config2) {
   const out2 = [];
   const analyses = /* @__PURE__ */ new Map();
-  const libraries = config2 ? (0, import_parser3.resolveTypeLibraries)(config2) : { files: [], lowerings: [], problems: [] };
+  const libraries = config2 ? (0, import_parser6.resolveTypeLibraries)(config2) : { files: [], lowerings: [], problems: [] };
   for (const p of libraries.problems) out2.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] : []));
@@ -2379,14 +2481,14 @@ function analyzeModules(modules, config2) {
       readWhile.set(file, remembered.read);
       return remembered.result;
     }
-    const scopes = (0, import_parser3.analyzeScopes)(program, { builtinGlobals: globals, reportUndeclared: libs.length > 0 });
+    const scopes = (0, import_parser6.analyzeScopes)(program, { 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)(program, scopes, {
+    const types = (0, import_parser6.analyzeTypes)(program, scopes, {
       libs,
       resolveModule: resolverFor(file),
       reportUnknownTypes: libs.length > 0
@@ -2409,7 +2511,7 @@ function analyzeModules(modules, config2) {
     return result;
   };
   const resolverFor = (file) => (specifier) => {
-    const target = (0, import_parser3.resolveModulePath)(file, specifier, config2);
+    const target = (0, import_parser6.resolveModulePath)(file, specifier, config2);
     if (!target) return void 0;
     const noteRead = () => {
       const read2 = readWhile.get(file) ?? /* @__PURE__ */ new Map();
@@ -2430,16 +2532,16 @@ function analyzeModules(modules, config2) {
     let program = byFile.get(target)?.program;
     if (!program) {
       try {
-        program = (0, import_parser3.parse)((0, import_node_fs2.readFileSync)(target, "utf8"));
+        program = (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)(program, { builtinGlobals: globals });
-      const types = byFile.has(target) ? analyzeModule(target, program).types : (0, import_parser3.analyzeTypes)(program, scopes, { libs, resolveModule: resolverFor(target), diagnostics: false });
-      const exports2 = (0, import_parser3.moduleExports)(program, scopes, types, resolverFor(target));
+      const scopes = (0, import_parser6.analyzeScopes)(program, { builtinGlobals: globals });
+      const types = byFile.has(target) ? analyzeModule(target, program).types : (0, import_parser6.analyzeTypes)(program, scopes, { libs, resolveModule: resolverFor(target), diagnostics: false });
+      const exports2 = (0, import_parser6.moduleExports)(program, scopes, types, resolverFor(target));
       exportsCache.set(target, exports2);
       noteRead();
       return exports2;

package/dist/cli.js

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