@tilua/compiler 6.1.0 → 7.0.1

package/dist/index.d.cts

@@ -1,8 +1,111 @@
 import * as T from '@tilua/parser';
-import { LoweringPlugin, BuildTarget, TypeAnalysis, ScopeAnalysis, OutputMode, TiluaConfig, ConfigProblem } from '@tilua/parser';
-export { LoweringPlugin, MethodCall, MethodLowering } from '@tilua/parser';
+import { OutputMode, TiluaConfig, ConfigProblem, LoweringPlugin, TypeAnalysis, ScopeAnalysis } from '@tilua/parser';
+export { LoweringPlugin, LuaSyntax, MethodCall, MethodLowering } from '@tilua/parser';
 import * as L from 'luau-parser';
 
+/** What `tilua.config.json` holds. */
+interface TiluaConfigJson {
+    /** Type libraries to check against: `["roblox"]` loads `@tilua-types/roblox`. */
+    types?: string[];
+    /** Import path aliases, as in tsconfig: `{ "@shared/*": ["src/shared/*"] }`. */
+    paths?: Record<string, string[]>;
+    /** Where `paths` targets resolve from. Default: the config's folder. */
+    baseUrl?: string;
+    /** A Rojo sourcemap, or `null`. */
+    sourceMap?: string | null;
+    /** How many files the output is. `"single"` (the default) is one file;
+     *  `"chunks"` also writes a file for what only an `import()` reaches,
+     *  loaded when it is first asked for; `"modules"` writes one per module. */
+    output?: OutputMode;
+    /** Leave out Lua's standard library — `print`, `string`, `pcall` — which
+     *  is otherwise there for every file, as JavaScript's is in TypeScript. */
+    noLib?: boolean;
+    /** Leave out of the bundle what the entry never reaches (`treeShake`). */
+    treeShaking?: boolean;
+}
+/** A config file's path, or the config itself. Relative paths — to a config
+ *  file, and inside an inline config — resolve from `cwd`. */
+type ConfigInput = string | TiluaConfigJson;
+interface ResolvedConfig {
+    readonly config?: TiluaConfig;
+    readonly problems: readonly ConfigProblem[];
+}
+/** The config for a build of `entry`: the one given, or else the nearest
+ *  `tilua.config.json` above the entry. */
+declare function resolveConfig(input: ConfigInput | undefined, entry: string, cwd?: string): ResolvedConfig;
+
+interface BundleOptions {
+    /** The file the bundle runs. */
+    readonly entry: string;
+    /** A `tilua.config.json` path or contents. Default: the nearest config above the entry. */
+    readonly config?: ConfigInput;
+    /** The project folder. Modules are named by their path from it, and an
+     *  inline config's relative paths resolve from it. Default: the config
+     *  file's folder, or else the entry's. */
+    readonly root?: string;
+    /** Check types against the config's `types` too. Default: true. */
+    readonly typeCheck?: boolean;
+    /** How many files to make. Overrides the config's `output`; `"single"`
+     *  without either. */
+    readonly output?: OutputMode;
+    /** Leave out what the entry never reaches. Overrides the config's
+     *  `treeShaking`; off without either. */
+    readonly treeShaking?: boolean;
+    /** What the entry's file is called: `main.luau`. The other files of
+     *  `"chunks"` are named after it (`main_shop.luau`), and every file takes
+     *  its extension. Default: the entry's own name, with `.luau`. */
+    readonly outFile?: string;
+}
+/** One file of the output. */
+interface BundleFile {
+    /** Where it goes, from the folder the output is written to: `main.luau`,
+     *  `src/shop/buy.luau`. Files find each other by these, so they have to be
+     *  written as they are named. */
+    readonly path: string;
+    readonly code: string;
+    /** The modules in it, by name. */
+    readonly modules: string[];
+}
+interface BundleDiagnostic {
+    /** Absolute path of the file it is about. */
+    readonly file: string;
+    readonly message: string;
+    readonly line: number;
+    readonly column: number;
+    /** `type` and `config` problems are reported without stopping the build;
+     *  `syntax`, `scope` (such as assigning to an import) and `module`
+     *  problems leave no bundle. */
+    readonly category: "syntax" | "scope" | "module" | "type" | "config";
+    /** A test that always comes out the same, and the like: said, and no
+     *  reason for the build to fail. */
+    readonly severity?: "warning";
+}
+interface BundleResult {
+    /** The bundle — the entry's file, when there are several — or `undefined`
+     *  when a module could not be compiled. Type errors are reported but do
+     *  not stop it. */
+    readonly code?: string;
+    /** Every file of the output, the entry's first. Empty when there is no
+     *  bundle. */
+    readonly files: BundleFile[];
+    /** The bundled modules' names, entry first. */
+    readonly modules: string[];
+    readonly diagnostics: BundleDiagnostic[];
+}
+declare function bundle(options: BundleOptions): Promise<BundleResult>;
+
+interface Diagnostic {
+    readonly message: string;
+    readonly line: number;
+    readonly column: number;
+}
+interface CompileResult {
+    /** The Luau source, or `undefined` when the file has errors. */
+    readonly code?: string;
+    readonly diagnostics: Diagnostic[];
+}
+declare function compile(source: string, config?: ConfigInput): Promise<CompileResult>;
+
 /**
  * Fresh local names for what lowering introduces — a destructuring temporary,
  * a required module, a helper function.
@@ -21,6 +124,8 @@ declare class Names {
     /** A copy that goes on to take names independently — one per module, each
      *  starting from what the whole bundle already takes. */
     fork(): Names;
+    /** `name`, chosen elsewhere, is not to be chosen again here. */
+    take(name: string): void;
     /** `base`, or `base2`, `base3`, ... — whichever is free first. */
     fresh(base: string): string;
 }
@@ -129,18 +234,24 @@ interface LowerOptions {
     /** The file as a library's runtime names it — `src/shop/buy.tilua` —
      *  in the call sites it is handed. */
     readonly file?: string;
-    /** Which Lua the output has to run on. Default `"luau"`. `"lua51"` also
-     *  lowers what Luau adds to Lua and 5.1 has no syntax for — `a += b`,
-     *  `continue`, `if c then a else b` as an expression, `//`. */
-    readonly target?: Target;
     /** The project leaves Lua's standard library out (`"noLib": true`), so
      *  nothing of it is lowered either. */
     readonly noLib?: boolean;
+    /** A bundle's helpers, shared by its modules: each module names the ones
+     *  it uses, and the bundle defines each once. Without it a file defines
+     *  its own. */
+    readonly shared?: SharedRuntime;
+    /** Tree shaking (`treeShake`): what of the module is left out, and which
+     *  of the modules it imports do something as they run. */
+    readonly shaken?: {
+        readonly removed: ReadonlySet<object>;
+        readonly dead: ReadonlySet<object>;
+        /** Does the module `specifier` names run anything as it loads? */
+        runs(specifier: string): boolean;
+        /** Is the module `specifier` names needed at all? */
+        needed(specifier: string): boolean;
+    };
 }
-/** `"luau"` is Roblox's Lua. `"lua51"` is stock Lua 5.1, which has none of
- *  Luau's additions — and no `goto` either, so `continue` has to be built out
- *  of the loops 5.1 does have. */
-type Target = BuildTarget;
 interface LowerDiagnostic {
     readonly message: string;
     readonly line: number;
@@ -160,6 +271,50 @@ interface LowerResult {
     /** The file reads `scriptArgs`: whatever runs it has to set it up, from
      *  the chunk's own `...` — this file, compiled alone, does it itself. */
     readonly usesScriptArgs: boolean;
+    /** With `shared`: the shared helpers the statements name. */
+    readonly shared: readonly string[];
+}
+/**
+ * The helpers of a bundle — `tilua_asArray`, the array methods, a library's
+ * runtime — defined once for every module rather than once in each. A
+ * project of forty files that all map over a list would otherwise carry the
+ * array runtime forty times.
+ *
+ * A helper is shared by what it is: the same kind, or a runtime whose Luau
+ * reads the same, gets the same name in every module. One whose Luau differs
+ * from module to module — a runtime reading its own module's line map — is a
+ * helper of its own in each.
+ */
+declare class SharedRuntime {
+    private readonly names;
+    private readonly byKey;
+    /** Each group of names and the statements that declare them as locals,
+     *  in the order they were first defined: each after what it uses. */
+    private readonly definitions;
+    private readonly defined;
+    constructor(names: Names);
+    /** The name the helper `key` goes by, in every module. */
+    name(key: string, base: string): string;
+    /** `statements` declare `names`. Only the first module to say so is heard:
+     *  the others' are the same. */
+    define(names: string[], statements: L.Statement[]): void;
+    /** Tree shaking: leave out of each runtime table the members nothing
+     *  reads. `code` is everything else the output holds — the modules —
+     *  and a member is read when it, or a member read already, names it:
+     *  `tilua_array.filter(xs, f)` keeps `filter`, and whatever `filter`
+     *  itself calls. A table used as anything but `table.member` — handed
+     *  on, walked, indexed by what only the running program knows — keeps
+     *  every member. */
+    shake(code: readonly L.Statement[]): void;
+    /** Luau setting up the helpers `used` for a chunk whose code names them:
+     *  `declare` goes before that code, which reads each as an upvalue, and
+     *  `define` after it — before any of it runs, and after what a helper
+     *  reads as it is set up (the line map). Each definition runs in a
+     *  function of its own, so what it keeps to itself stays there. */
+    chunk(used: ReadonlySet<string>): {
+        declare: L.Statement[];
+        define: L.Statement[];
+    };
 }
 /** How a module's exports behave at runtime, beyond what its code assigns. */
 interface ModuleInfo {
@@ -181,109 +336,4 @@ interface ModuleInfo {
 }
 declare function lower(program: T.Program, scopes: ScopeAnalysis, options?: LowerOptions): LowerResult;
 
-/** What `tilua.config.json` holds. */
-interface TiluaConfigJson {
-    /** Type libraries to check against: `["roblox"]` loads `@tilua-types/roblox`. */
-    types?: string[];
-    /** Import path aliases, as in tsconfig: `{ "@shared/*": ["src/shared/*"] }`. */
-    paths?: Record<string, string[]>;
-    /** Where `paths` targets resolve from. Default: the config's folder. */
-    baseUrl?: string;
-    /** A Rojo sourcemap, or `null`. */
-    sourceMap?: string | null;
-    /** Which Lua the output must run on. `"luau"` (the default) keeps Luau's
-     *  own syntax; `"lua51"` also lowers what stock Lua 5.1 cannot parse —
-     *  `a += b`, `continue`, `if c then a else b` as an expression, `//`,
-     *  digit separators and binary literals. */
-    target?: Target;
-    /** How many files the output is. `"single"` (the default) is one file;
-     *  `"chunks"` also writes a file for what only an `import()` reaches,
-     *  loaded when it is first asked for; `"modules"` writes one per module. */
-    output?: OutputMode;
-    /** Leave out Lua's standard library — `print`, `string`, `pcall` — which
-     *  is otherwise there for every file, as JavaScript's is in TypeScript. */
-    noLib?: boolean;
-}
-/** A config file's path, or the config itself. Relative paths — to a config
- *  file, and inside an inline config — resolve from `cwd`. */
-type ConfigInput = string | TiluaConfigJson;
-interface ResolvedConfig {
-    readonly config?: TiluaConfig;
-    readonly problems: readonly ConfigProblem[];
-}
-/** The config for a build of `entry`: the one given, or else the nearest
- *  `tilua.config.json` above the entry. */
-declare function resolveConfig(input: ConfigInput | undefined, entry: string, cwd?: string): ResolvedConfig;
-
-interface BundleOptions {
-    /** The file the bundle runs. */
-    readonly entry: string;
-    /** A `tilua.config.json` path or contents. Default: the nearest config above the entry. */
-    readonly config?: ConfigInput;
-    /** The project folder. Modules are named by their path from it, and an
-     *  inline config's relative paths resolve from it. Default: the config
-     *  file's folder, or else the entry's. */
-    readonly root?: string;
-    /** Check types against the config's `types` too. Default: true. */
-    readonly typeCheck?: boolean;
-    /** Which Lua the output must run on. Overrides the config's `target`. */
-    readonly target?: Target;
-    /** How many files to make. Overrides the config's `output`; `"single"`
-     *  without either. */
-    readonly output?: OutputMode;
-    /** What the entry's file is called: `main.luau`. The other files of
-     *  `"chunks"` are named after it (`main_shop.luau`), and every file takes
-     *  its extension. Default: the entry's own name, with `.luau`. */
-    readonly outFile?: string;
-}
-/** One file of the output. */
-interface BundleFile {
-    /** Where it goes, from the folder the output is written to: `main.luau`,
-     *  `src/shop/buy.luau`. Files find each other by these, so they have to be
-     *  written as they are named. */
-    readonly path: string;
-    readonly code: string;
-    /** The modules in it, by name. */
-    readonly modules: string[];
-}
-interface BundleDiagnostic {
-    /** Absolute path of the file it is about. */
-    readonly file: string;
-    readonly message: string;
-    readonly line: number;
-    readonly column: number;
-    /** `type` and `config` problems are reported without stopping the build;
-     *  `syntax`, `scope` (such as assigning to an import) and `module`
-     *  problems leave no bundle. */
-    readonly category: "syntax" | "scope" | "module" | "type" | "config";
-    /** A test that always comes out the same, and the like: said, and no
-     *  reason for the build to fail. */
-    readonly severity?: "warning";
-}
-interface BundleResult {
-    /** The bundle — the entry's file, when there are several — or `undefined`
-     *  when a module could not be compiled. Type errors are reported but do
-     *  not stop it. */
-    readonly code?: string;
-    /** Every file of the output, the entry's first. Empty when there is no
-     *  bundle. */
-    readonly files: BundleFile[];
-    /** The bundled modules' names, entry first. */
-    readonly modules: string[];
-    readonly diagnostics: BundleDiagnostic[];
-}
-declare function bundle(options: BundleOptions): Promise<BundleResult>;
-
-interface Diagnostic {
-    readonly message: string;
-    readonly line: number;
-    readonly column: number;
-}
-interface CompileResult {
-    /** The Luau source, or `undefined` when the file has errors. */
-    readonly code?: string;
-    readonly diagnostics: Diagnostic[];
-}
-declare function compile(source: string, config?: ConfigInput): Promise<CompileResult>;
-
 export { type BundleDiagnostic, type BundleFile, type BundleOptions, type BundleResult, type CompileResult, type ConfigInput, type Diagnostic, type LoadedLowering, type LowerDiagnostic, type LowerOptions, type LowerResult, type LoweringProblem, type ModuleContext, type ResolvedConfig, type TiluaConfigJson, bundle, compile, loadLowerings, lower, resolveConfig };

package/dist/index.d.ts

@@ -1,8 +1,111 @@
 import * as T from '@tilua/parser';
-import { LoweringPlugin, BuildTarget, TypeAnalysis, ScopeAnalysis, OutputMode, TiluaConfig, ConfigProblem } from '@tilua/parser';
-export { LoweringPlugin, MethodCall, MethodLowering } from '@tilua/parser';
+import { OutputMode, TiluaConfig, ConfigProblem, LoweringPlugin, TypeAnalysis, ScopeAnalysis } from '@tilua/parser';
+export { LoweringPlugin, LuaSyntax, MethodCall, MethodLowering } from '@tilua/parser';
 import * as L from 'luau-parser';
 
+/** What `tilua.config.json` holds. */
+interface TiluaConfigJson {
+    /** Type libraries to check against: `["roblox"]` loads `@tilua-types/roblox`. */
+    types?: string[];
+    /** Import path aliases, as in tsconfig: `{ "@shared/*": ["src/shared/*"] }`. */
+    paths?: Record<string, string[]>;
+    /** Where `paths` targets resolve from. Default: the config's folder. */
+    baseUrl?: string;
+    /** A Rojo sourcemap, or `null`. */
+    sourceMap?: string | null;
+    /** How many files the output is. `"single"` (the default) is one file;
+     *  `"chunks"` also writes a file for what only an `import()` reaches,
+     *  loaded when it is first asked for; `"modules"` writes one per module. */
+    output?: OutputMode;
+    /** Leave out Lua's standard library — `print`, `string`, `pcall` — which
+     *  is otherwise there for every file, as JavaScript's is in TypeScript. */
+    noLib?: boolean;
+    /** Leave out of the bundle what the entry never reaches (`treeShake`). */
+    treeShaking?: boolean;
+}
+/** A config file's path, or the config itself. Relative paths — to a config
+ *  file, and inside an inline config — resolve from `cwd`. */
+type ConfigInput = string | TiluaConfigJson;
+interface ResolvedConfig {
+    readonly config?: TiluaConfig;
+    readonly problems: readonly ConfigProblem[];
+}
+/** The config for a build of `entry`: the one given, or else the nearest
+ *  `tilua.config.json` above the entry. */
+declare function resolveConfig(input: ConfigInput | undefined, entry: string, cwd?: string): ResolvedConfig;
+
+interface BundleOptions {
+    /** The file the bundle runs. */
+    readonly entry: string;
+    /** A `tilua.config.json` path or contents. Default: the nearest config above the entry. */
+    readonly config?: ConfigInput;
+    /** The project folder. Modules are named by their path from it, and an
+     *  inline config's relative paths resolve from it. Default: the config
+     *  file's folder, or else the entry's. */
+    readonly root?: string;
+    /** Check types against the config's `types` too. Default: true. */
+    readonly typeCheck?: boolean;
+    /** How many files to make. Overrides the config's `output`; `"single"`
+     *  without either. */
+    readonly output?: OutputMode;
+    /** Leave out what the entry never reaches. Overrides the config's
+     *  `treeShaking`; off without either. */
+    readonly treeShaking?: boolean;
+    /** What the entry's file is called: `main.luau`. The other files of
+     *  `"chunks"` are named after it (`main_shop.luau`), and every file takes
+     *  its extension. Default: the entry's own name, with `.luau`. */
+    readonly outFile?: string;
+}
+/** One file of the output. */
+interface BundleFile {
+    /** Where it goes, from the folder the output is written to: `main.luau`,
+     *  `src/shop/buy.luau`. Files find each other by these, so they have to be
+     *  written as they are named. */
+    readonly path: string;
+    readonly code: string;
+    /** The modules in it, by name. */
+    readonly modules: string[];
+}
+interface BundleDiagnostic {
+    /** Absolute path of the file it is about. */
+    readonly file: string;
+    readonly message: string;
+    readonly line: number;
+    readonly column: number;
+    /** `type` and `config` problems are reported without stopping the build;
+     *  `syntax`, `scope` (such as assigning to an import) and `module`
+     *  problems leave no bundle. */
+    readonly category: "syntax" | "scope" | "module" | "type" | "config";
+    /** A test that always comes out the same, and the like: said, and no
+     *  reason for the build to fail. */
+    readonly severity?: "warning";
+}
+interface BundleResult {
+    /** The bundle — the entry's file, when there are several — or `undefined`
+     *  when a module could not be compiled. Type errors are reported but do
+     *  not stop it. */
+    readonly code?: string;
+    /** Every file of the output, the entry's first. Empty when there is no
+     *  bundle. */
+    readonly files: BundleFile[];
+    /** The bundled modules' names, entry first. */
+    readonly modules: string[];
+    readonly diagnostics: BundleDiagnostic[];
+}
+declare function bundle(options: BundleOptions): Promise<BundleResult>;
+
+interface Diagnostic {
+    readonly message: string;
+    readonly line: number;
+    readonly column: number;
+}
+interface CompileResult {
+    /** The Luau source, or `undefined` when the file has errors. */
+    readonly code?: string;
+    readonly diagnostics: Diagnostic[];
+}
+declare function compile(source: string, config?: ConfigInput): Promise<CompileResult>;
+
 /**
  * Fresh local names for what lowering introduces — a destructuring temporary,
  * a required module, a helper function.
@@ -21,6 +124,8 @@ declare class Names {
     /** A copy that goes on to take names independently — one per module, each
      *  starting from what the whole bundle already takes. */
     fork(): Names;
+    /** `name`, chosen elsewhere, is not to be chosen again here. */
+    take(name: string): void;
     /** `base`, or `base2`, `base3`, ... — whichever is free first. */
     fresh(base: string): string;
 }
@@ -129,18 +234,24 @@ interface LowerOptions {
     /** The file as a library's runtime names it — `src/shop/buy.tilua` —
      *  in the call sites it is handed. */
     readonly file?: string;
-    /** Which Lua the output has to run on. Default `"luau"`. `"lua51"` also
-     *  lowers what Luau adds to Lua and 5.1 has no syntax for — `a += b`,
-     *  `continue`, `if c then a else b` as an expression, `//`. */
-    readonly target?: Target;
     /** The project leaves Lua's standard library out (`"noLib": true`), so
      *  nothing of it is lowered either. */
     readonly noLib?: boolean;
+    /** A bundle's helpers, shared by its modules: each module names the ones
+     *  it uses, and the bundle defines each once. Without it a file defines
+     *  its own. */
+    readonly shared?: SharedRuntime;
+    /** Tree shaking (`treeShake`): what of the module is left out, and which
+     *  of the modules it imports do something as they run. */
+    readonly shaken?: {
+        readonly removed: ReadonlySet<object>;
+        readonly dead: ReadonlySet<object>;
+        /** Does the module `specifier` names run anything as it loads? */
+        runs(specifier: string): boolean;
+        /** Is the module `specifier` names needed at all? */
+        needed(specifier: string): boolean;
+    };
 }
-/** `"luau"` is Roblox's Lua. `"lua51"` is stock Lua 5.1, which has none of
- *  Luau's additions — and no `goto` either, so `continue` has to be built out
- *  of the loops 5.1 does have. */
-type Target = BuildTarget;
 interface LowerDiagnostic {
     readonly message: string;
     readonly line: number;
@@ -160,6 +271,50 @@ interface LowerResult {
     /** The file reads `scriptArgs`: whatever runs it has to set it up, from
      *  the chunk's own `...` — this file, compiled alone, does it itself. */
     readonly usesScriptArgs: boolean;
+    /** With `shared`: the shared helpers the statements name. */
+    readonly shared: readonly string[];
+}
+/**
+ * The helpers of a bundle — `tilua_asArray`, the array methods, a library's
+ * runtime — defined once for every module rather than once in each. A
+ * project of forty files that all map over a list would otherwise carry the
+ * array runtime forty times.
+ *
+ * A helper is shared by what it is: the same kind, or a runtime whose Luau
+ * reads the same, gets the same name in every module. One whose Luau differs
+ * from module to module — a runtime reading its own module's line map — is a
+ * helper of its own in each.
+ */
+declare class SharedRuntime {
+    private readonly names;
+    private readonly byKey;
+    /** Each group of names and the statements that declare them as locals,
+     *  in the order they were first defined: each after what it uses. */
+    private readonly definitions;
+    private readonly defined;
+    constructor(names: Names);
+    /** The name the helper `key` goes by, in every module. */
+    name(key: string, base: string): string;
+    /** `statements` declare `names`. Only the first module to say so is heard:
+     *  the others' are the same. */
+    define(names: string[], statements: L.Statement[]): void;
+    /** Tree shaking: leave out of each runtime table the members nothing
+     *  reads. `code` is everything else the output holds — the modules —
+     *  and a member is read when it, or a member read already, names it:
+     *  `tilua_array.filter(xs, f)` keeps `filter`, and whatever `filter`
+     *  itself calls. A table used as anything but `table.member` — handed
+     *  on, walked, indexed by what only the running program knows — keeps
+     *  every member. */
+    shake(code: readonly L.Statement[]): void;
+    /** Luau setting up the helpers `used` for a chunk whose code names them:
+     *  `declare` goes before that code, which reads each as an upvalue, and
+     *  `define` after it — before any of it runs, and after what a helper
+     *  reads as it is set up (the line map). Each definition runs in a
+     *  function of its own, so what it keeps to itself stays there. */
+    chunk(used: ReadonlySet<string>): {
+        declare: L.Statement[];
+        define: L.Statement[];
+    };
 }
 /** How a module's exports behave at runtime, beyond what its code assigns. */
 interface ModuleInfo {
@@ -181,109 +336,4 @@ interface ModuleInfo {
 }
 declare function lower(program: T.Program, scopes: ScopeAnalysis, options?: LowerOptions): LowerResult;
 
-/** What `tilua.config.json` holds. */
-interface TiluaConfigJson {
-    /** Type libraries to check against: `["roblox"]` loads `@tilua-types/roblox`. */
-    types?: string[];
-    /** Import path aliases, as in tsconfig: `{ "@shared/*": ["src/shared/*"] }`. */
-    paths?: Record<string, string[]>;
-    /** Where `paths` targets resolve from. Default: the config's folder. */
-    baseUrl?: string;
-    /** A Rojo sourcemap, or `null`. */
-    sourceMap?: string | null;
-    /** Which Lua the output must run on. `"luau"` (the default) keeps Luau's
-     *  own syntax; `"lua51"` also lowers what stock Lua 5.1 cannot parse —
-     *  `a += b`, `continue`, `if c then a else b` as an expression, `//`,
-     *  digit separators and binary literals. */
-    target?: Target;
-    /** How many files the output is. `"single"` (the default) is one file;
-     *  `"chunks"` also writes a file for what only an `import()` reaches,
-     *  loaded when it is first asked for; `"modules"` writes one per module. */
-    output?: OutputMode;
-    /** Leave out Lua's standard library — `print`, `string`, `pcall` — which
-     *  is otherwise there for every file, as JavaScript's is in TypeScript. */
-    noLib?: boolean;
-}
-/** A config file's path, or the config itself. Relative paths — to a config
- *  file, and inside an inline config — resolve from `cwd`. */
-type ConfigInput = string | TiluaConfigJson;
-interface ResolvedConfig {
-    readonly config?: TiluaConfig;
-    readonly problems: readonly ConfigProblem[];
-}
-/** The config for a build of `entry`: the one given, or else the nearest
- *  `tilua.config.json` above the entry. */
-declare function resolveConfig(input: ConfigInput | undefined, entry: string, cwd?: string): ResolvedConfig;
-
-interface BundleOptions {
-    /** The file the bundle runs. */
-    readonly entry: string;
-    /** A `tilua.config.json` path or contents. Default: the nearest config above the entry. */
-    readonly config?: ConfigInput;
-    /** The project folder. Modules are named by their path from it, and an
-     *  inline config's relative paths resolve from it. Default: the config
-     *  file's folder, or else the entry's. */
-    readonly root?: string;
-    /** Check types against the config's `types` too. Default: true. */
-    readonly typeCheck?: boolean;
-    /** Which Lua the output must run on. Overrides the config's `target`. */
-    readonly target?: Target;
-    /** How many files to make. Overrides the config's `output`; `"single"`
-     *  without either. */
-    readonly output?: OutputMode;
-    /** What the entry's file is called: `main.luau`. The other files of
-     *  `"chunks"` are named after it (`main_shop.luau`), and every file takes
-     *  its extension. Default: the entry's own name, with `.luau`. */
-    readonly outFile?: string;
-}
-/** One file of the output. */
-interface BundleFile {
-    /** Where it goes, from the folder the output is written to: `main.luau`,
-     *  `src/shop/buy.luau`. Files find each other by these, so they have to be
-     *  written as they are named. */
-    readonly path: string;
-    readonly code: string;
-    /** The modules in it, by name. */
-    readonly modules: string[];
-}
-interface BundleDiagnostic {
-    /** Absolute path of the file it is about. */
-    readonly file: string;
-    readonly message: string;
-    readonly line: number;
-    readonly column: number;
-    /** `type` and `config` problems are reported without stopping the build;
-     *  `syntax`, `scope` (such as assigning to an import) and `module`
-     *  problems leave no bundle. */
-    readonly category: "syntax" | "scope" | "module" | "type" | "config";
-    /** A test that always comes out the same, and the like: said, and no
-     *  reason for the build to fail. */
-    readonly severity?: "warning";
-}
-interface BundleResult {
-    /** The bundle — the entry's file, when there are several — or `undefined`
-     *  when a module could not be compiled. Type errors are reported but do
-     *  not stop it. */
-    readonly code?: string;
-    /** Every file of the output, the entry's first. Empty when there is no
-     *  bundle. */
-    readonly files: BundleFile[];
-    /** The bundled modules' names, entry first. */
-    readonly modules: string[];
-    readonly diagnostics: BundleDiagnostic[];
-}
-declare function bundle(options: BundleOptions): Promise<BundleResult>;
-
-interface Diagnostic {
-    readonly message: string;
-    readonly line: number;
-    readonly column: number;
-}
-interface CompileResult {
-    /** The Luau source, or `undefined` when the file has errors. */
-    readonly code?: string;
-    readonly diagnostics: Diagnostic[];
-}
-declare function compile(source: string, config?: ConfigInput): Promise<CompileResult>;
-
 export { type BundleDiagnostic, type BundleFile, type BundleOptions, type BundleResult, type CompileResult, type ConfigInput, type Diagnostic, type LoadedLowering, type LowerDiagnostic, type LowerOptions, type LowerResult, type LoweringProblem, type ModuleContext, type ResolvedConfig, type TiluaConfigJson, bundle, compile, loadLowerings, lower, resolveConfig };

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   lower,
   program,
   resolveConfig
-} from "./chunk-574KDV5W.js";
+} from "./chunk-WGXXYKEU.js";
 
 // src/compile.ts
 import { readFileSync } from "fs";
@@ -41,7 +41,6 @@ async function compile(source, config) {
     types: analyzeTypes(program2, scopes, { libs, noLib, diagnostics: false }),
     noLib,
     lowerings,
-    target: resolved?.target,
     source
   });
   diagnostics.push(...lowered.diagnostics);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua/compiler",
-  "version": "6.1.0",
+  "version": "7.0.1",
   "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": "^6.1.0"
+    "@tilua/parser": "^7.0.0"
   },
   "devDependencies": {
     "@types/node": "^22.20.2",