@tilua/parser 5.0.0 → 5.0.1

package/README.md

@@ -353,7 +353,9 @@ than -1 — and `push`, `pop`, `shift`, `unshift`, `sort` and `reverse` change
 the array. Looking for a value is not adding one, so `includes` and `indexOf`
 take any value, not only one the array's type already holds — and `includes`
 is a guard: `if (modes:includes(s))` narrows `s` to a mode. `concat` may join
-arrays of other types (`(T | U)[]`). The ones that only read take a read-only
+arrays of other types (`(T | U)[]`). `keys`, `values` and `entries` answer
+arrays rather than JavaScript's iterators — `for (const [i, v] in
+xs:entries())` — counting from 1. The ones that only read take a read-only
 list too (`readonly T[]`, what `as const` makes), as TypeScript's
 `ReadonlyArray` does; the ones that change it do not. A table's are `keys`, `values` and `entries`, which answer a tuple
 in the order the table's type wrote its members, not `string[]` as
@@ -693,7 +695,11 @@ Dog.ParentClass == Animal       -- a class names the one it extends
 Animal.ParentClass == nil       -- and a root class extends nothing
 ```
 
-Both live on the class table, so an instance carries neither.
+Both live on the class table, so an instance carries neither. So does its
+name, as a JavaScript class's `name`: `Dog.name` is `"Dog"`, and a class
+written as a value takes the name of what holds it (`const Counter = class
+{ ... }` is `"Counter"`). A static, a method or an accessor cannot be called
+`name`; an instance field can, and lives on the instance.
 
 **Generic classes** — `class Box<T> { ... }`. The name is then a generic type,
 and `Box<number>` and `Box<string>` are both `Box` but neither is the other:

package/dist/index.cjs

@@ -226,6 +226,14 @@ function isAlphaNumeric(ch) {
   return isAlpha(ch) || isDigit(ch);
 }
 var KeywordSet = new Set(Keywords);
+var TS_SPELLINGS = [
+  ["!==", "~=", "Operator"],
+  ["===", "==", "Operator"],
+  ["!=", "~=", "Operator"],
+  ["&&", "and", "Keyword"],
+  ["||", "or", "Keyword"],
+  ["!", "not", "Keyword"]
+];
 var OperatorSet = new Set(Operators);
 var SortedSymbols = [...Operators, ...Punctuators].sort((a, b) => b.length - a.length);
 var LexError = class extends Error {
@@ -686,6 +694,15 @@ function tokenize(source, options = {}) {
       tokens.push(readIdentifierOrKeyword());
       continue;
     }
+    const spelled = TS_SPELLINGS.find(([written]) => source.startsWith(written, cursor));
+    if (spelled) {
+      const [written, meant, kind] = spelled;
+      const startLine = line, startColumn = column;
+      fail(`tilua writes '${meant}', not '${written}'`, startLine, startColumn);
+      for (let k = 0; k < written.length; k++) advance();
+      tokens.push(kind === "Keyword" ? { type: "Keyword", value: meant, ...makeBase(startLine, startColumn) } : { type: "Operator", value: meant, ...makeBase(startLine, startColumn) });
+      continue;
+    }
     const symbol = readOperatorOrPunctuator();
     if (symbol) tokens.push(symbol);
   }
@@ -4494,7 +4511,7 @@ declare function xpcall<A extends unknown[], T>(fn: (...args: A) => T, handler:
 declare function select(n: "#", ...args: unknown[]): number
 declare function select<T>(n: number, ...args: T[]): T[]
 -- A copy of the list, or of part of it.
-declare function unpack<V>(list: V[], i?: number, j?: number): V[]
+declare function unpack<V>(list: readonly V[], i?: number, j?: number): V[]
 declare function rawget(t: unknown, key: unknown): unknown
 declare function rawset<T>(t: T, key: unknown, value: unknown): T
 declare function rawequal(a: unknown, b: unknown): boolean
@@ -4513,10 +4530,11 @@ type Iteration<S, T> = [(state: S, previous: T | nil) => T | nil, S, T | nil]
 -- \`for (const [k, v] in pairs(t))\` / \`ipairs(t)\`: each item is one \`[key,
 -- value]\` \u2014 a table, as every array is. The analyzer types it from \`t\` itself
 -- (a record's keys as literals, an array's elements); these declare the
--- names, and their shape for any other use.
-declare function pairs<V>(t: V[]): Iteration<V[], [number, V]>
+-- names, and their shape for any other use. Walking a list only reads it, so
+-- a read-only one (\`as const\`, \`readonly T[]\`) is walked as well.
+declare function pairs<V>(t: readonly V[]): Iteration<readonly V[], [number, V]>
 declare function pairs<K, V>(t: { [K]: V }): Iteration<{ [K]: V }, [K, V]>
-declare function ipairs<V>(t: V[]): Iteration<V[], [number, V]>
+declare function ipairs<V>(t: readonly V[]): Iteration<readonly V[], [number, V]>
 
 declare function collectgarbage(option: "count"): number
 declare function gcinfo(): number
@@ -4590,14 +4608,14 @@ declare table: {
     -- \`insert(t, v)\` appends; \`insert(t, pos, v)\` puts it there.
     insert: (<T>(t: T[], value: T) => nil) & (<T>(t: T[], pos: number, value: T) => nil),
     remove: <T>(t: T[], pos?: number) => T | nil,
-    concat: (t: (string | number)[], sep?: string, i?: number, j?: number) => string,
+    concat: (t: readonly (string | number)[], sep?: string, i?: number, j?: number) => string,
     sort: <T>(t: T[], compare?: (a: T, b: T) => boolean) => nil,
     -- Lua 5.1's originals. Deprecated there and gone from 5.2 on, but Luau
     -- still answers to them, so code being ported still type-checks.
-    getn: <T>(t: T[]) => number,
-    maxn: <T>(t: T[]) => number,
+    getn: <T>(t: readonly T[]) => number,
+    maxn: <T>(t: readonly T[]) => number,
     foreach: <K, V, R>(t: { [K]: V }, f: (key: K, value: V) => R) => R | nil,
-    foreachi: <V, R>(t: V[], f: (index: number, value: V) => R) => R | nil,
+    foreachi: <V, R>(t: readonly V[], f: (index: number, value: V) => R) => R | nil,
 }
 
 declare os: {
@@ -5490,6 +5508,11 @@ declare metatable<T> T[]: {
         concat: <U>(self: readonly T[], ...others: (readonly U[])[]) => (T | U)[],
         slice: (self: readonly T[], start?: number, stop?: number) => T[],
         flat: (self: readonly T[]) => T[],
+        -- JavaScript's, as arrays rather than iterators: \`for (const [i, v] in
+        -- xs:entries())\` walks positions and values, counting from 1.
+        keys: (self: readonly T[]) => number[],
+        values: (self: readonly T[]) => T[],
+        entries: (self: readonly T[]) => [number, T][],
         reverse: (self: T[]) => T[],
         sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],
         push: (self: T[], ...args: T[]) => number,
@@ -7277,7 +7300,7 @@ function keepsLiterals(paramType) {
   const members = paramType.constraint.kind === "union" ? paramType.constraint.types : [paramType.constraint];
   return members.some((m) => m.kind === "literal" || m.kind === "primitive" && (m.name === "string" || m.name === "number"));
 }
-var CLASS_LINKS = /* @__PURE__ */ new Set(["new", "ClassObject", "ParentClass"]);
+var CLASS_LINKS = /* @__PURE__ */ new Set(["new", "ClassObject", "ParentClass", "name"]);
 var CLASS_RESERVED = /* @__PURE__ */ new Set([
   "new",
   "ClassObject",
@@ -8035,6 +8058,7 @@ var TypeAnalyzer = class {
     });
     type.properties.set("new", construct);
     type.properties.set("ParentClass", { type: parent ?? nilType, optional: false, readonly: true });
+    type.properties.set("name", { type: stmt.name ? literal(stmt.name.name) : stringType, optional: false, readonly: true });
     return type;
   }
   /** The value side of the class `superclass` names when it is not
@@ -8294,6 +8318,9 @@ var TypeAnalyzer = class {
       if (CLASS_RESERVED.has(member.name.name)) {
         report(member.name, `'${member.name.name}' is what the compiler calls part of a class; a member cannot be named that`);
       }
+      if (member.name.name === "name" && !(member.type === "ClassField" && !member.isStatic)) {
+        report(member.name, "'name' is the class's own name, `Dog.name`: a static, a method or an accessor cannot be called that \u2014 an instance field can");
+      }
     }
     const seen = /* @__PURE__ */ new Map();
     for (const member of stmt.members) {
@@ -9134,6 +9161,13 @@ var TypeAnalyzer = class {
       case "array":
       case "tuple":
         return union([numberType, literal("length")]);
+      // A string is not indexed by position in Lua (`s[1]` is nil), so
+      // of its keys only `length` is there.
+      case "primitive":
+        return t.name === "string" ? literal("length") : neverType;
+      case "literal":
+      case "templateLiteral":
+        return t.kind === "templateLiteral" || t.base === "string" ? literal("length") : neverType;
       case "union": {
         const sets = t.types.map((m) => {
           const keys = this.keysOf(m);
@@ -9604,7 +9638,7 @@ var TypeAnalyzer = class {
           this.loops.set(stmt, { walks: "iteration", viaIter: false });
         } else {
           const [item, form] = this.iterationOf(stmt.iterator, sourceType);
-          this.bindPattern(stmt.variable, item, bodyEnv, "widen");
+          this.bindPattern(stmt.variable, item, bodyEnv, stmt.kind === "const" ? "keep" : "widen");
           this.loops.set(stmt, form);
         }
         this.visitBlock(stmt.body, bodyEnv);
@@ -11060,7 +11094,8 @@ var TypeAnalyzer = class {
       const name = source.callee.name;
       const src = this.expand(this.typeOf.get(source.arguments[0]) ?? unknownType);
       const iteration = { walks: "iteration", viaIter: false };
-      if (name === "ipairs") return [tuple([numberType, this.elementType(src, 0)]), iteration];
+      const element = src.kind === "array" ? src.element : src.kind === "tuple" ? union(tupleMembers(src).map((m) => m.kind === "spread" ? this.spreadElement(m.type) ?? unknownType : m)) : void 0;
+      if (name === "ipairs") return [tuple([numberType, element ?? this.elementType(src, 0)]), iteration];
       if (name === "pairs") {
         if (src.kind === "object") {
           return [tuple([
@@ -11068,7 +11103,7 @@ var TypeAnalyzer = class {
             src.indexer?.value ?? union([...src.properties.values()].map((p) => p.type))
           ]), iteration];
         }
-        if (src.kind === "array") return [tuple([numberType, src.element]), iteration];
+        if (element) return [tuple([numberType, element]), iteration];
       }
     }
     const handsOut = (t2, viaIter) => {

package/dist/index.d.cts

@@ -1756,7 +1756,7 @@ resolveModule?: (specifier: string) => ModuleExports | undefined): ModuleExports
  * `ObjectValues<T>` and `ObjectEntries<T>`, an object's members as tuples in
  * the order they were written.
  */
-declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = Exclude<T, Falsy>\n\n-- `Exclude<T, U>` is the analyzer's own: what of `T` is not a `U`. Over a\n-- union it drops the members it takes whole; over `unknown`, `any`, a\n-- primitive or an unresolved parameter it is kept \u2014 `Exclude<string, \"a\">` is\n-- a string that is not `\"a\"` \u2014 unlike TypeScript's.\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = Exclude<T, nil>\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\n-- A class table builds with `new`: `InstanceType<typeof Dog>` is a `Dog`.\ntype InstanceType<T> = T extends { new: (...args: any[]) => infer R } ? R : never\ntype ConstructorParameters<T> = T extends { new: (...args: infer P) => any } ? P : never\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n\n-- ============================================================\n-- The metatables of the language's own values\n-- ============================================================\n\n-- A string's methods. The first group is Lua's string library, which a\n-- string really answers to; where Lua answers several values, tilua answers\n-- one, as the global functions do (`find` is an array, `gsub` the new\n-- string). The second group is written the way JavaScript writes it.\n--\n-- Positions are Lua's: `sub` and `slice` count from 1, and `indexOf` is\n-- `nil` when the text is not there.\ndeclare metatable string: {\n    __index: {\n        upper: (self: string) => string,\n        lower: (self: string) => string,\n        len: (self: string) => number,\n        sub: (self: string, i: number, j?: number) => string,\n        rep: (self: string, n: number, separator?: string) => string,\n        reverse: (self: string) => string,\n        format: (self: string, ...args: unknown[]) => string,\n        byte: ((self: string, i?: number) => number) & ((self: string, i: number, j: number) => number[]),\n        find: (self: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n        match: (self: string, pattern: string, init?: number) => [...string[]] | nil,\n        gmatch: (self: string, pattern: string) => () => [string, ...string[]] | nil,\n        gsub: (self: string, pattern: string, replacement: unknown, n?: number) => string,\n\n        trim: (self: string) => string,\n        trimStart: (self: string) => string,\n        trimEnd: (self: string) => string,\n        startsWith: (self: string, text: string) => boolean,\n        endsWith: (self: string, text: string) => boolean,\n        includes: (self: string, text: string) => boolean,\n        indexOf: (self: string, text: string, start?: number) => number | nil,\n        slice: (self: string, start?: number, stop?: number) => string,\n        replace: (self: string, text: string, replacement: string) => string,\n        replaceAll: (self: string, text: string, replacement: string) => string,\n        padStart: (self: string, length: number, padding?: string) => string,\n        padEnd: (self: string, length: number, padding?: string) => string,\n    },\n}\n\n-- An array's methods. Lua gives an array no metatable: the compiler lowers\n-- each call to a plain function, so they work on any array, one a Lua\n-- library made included.\n--\n-- Indices are Lua's: the first element is 1, and `indexOf` / `findIndex`\n-- answer `nil` rather than JavaScript's -1. `sort` takes Lua's comparator\n-- (true when `a` comes first). `push`, `pop`, `shift`, `unshift`,\n-- `sort` and `reverse` change the array; everything else returns a new one.\n-- The ones that only read take a `readonly T[]` too \u2014 `as const` lists, and\n-- what a function promised not to change \u2014 as TypeScript's `ReadonlyArray`.\n-- A `filter` whose test is a guard \u2014 `v is S`, or `v => v ~= nil` \u2014\n-- answers an array of what it let through.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: readonly T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: readonly T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (<S extends T>(self: readonly T[], test: (value: T, index: number) => value is S) => S[])\n            & ((self: readonly T[], test: (value: T, index: number) => boolean) => T[]),\n        map: <U>(self: readonly T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: readonly T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: readonly T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: readonly T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: readonly T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        -- Asking is not adding: any value may be looked for, and finding it\n        -- says it is one of the array's \u2014 `if (names:includes(s))` narrows `s`.\n        includes: (self: readonly T[], value: unknown) => value is T,\n        indexOf: (self: readonly T[], value: unknown, start?: number) => number | nil,\n        join: (self: readonly T[], separator?: string) => string,\n        concat: <U>(self: readonly T[], ...others: (readonly U[])[]) => (T | U)[],\n        slice: (self: readonly T[], start?: number, stop?: number) => T[],\n        flat: (self: readonly T[]) => T[],\n        reverse: (self: T[]) => T[],\n        sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],\n        push: (self: T[], ...args: T[]) => number,\n        pop: (self: T[]) => T | nil,\n        shift: (self: T[]) => T | nil,\n        unshift: (self: T[], ...args: T[]) => number,\n    },\n}\n\n-- A table's methods. Unlike JavaScript's `Object.keys`, they answer a\n-- tuple, in the order the table's type wrote its members:\n--\n--     const point = { x: 1, y: \"up\" }\n--     point:keys()     -- [\"x\", \"y\"]\n--     point:values()   -- [number, string]\n--     point:entries()  -- [[\"x\", number], [\"y\", string]]\n--\n-- A Lua table has no order of its own, so the compiler hands its runtime the\n-- keys as the type lists them. An optional member keeps its place, holding\n-- `nil` when it is missing; an indexer's keys follow the named ones. A\n-- member of the table's own with one of these names is what a call reaches,\n-- and a class instance, which has a metatable of its own, has none of them.\n--\n-- The rest are JavaScript's `Object` functions, written as methods of the\n-- table they take first:\n--\n--     point:hasOwn(\"x\")           -- Object.hasOwn(point, \"x\")\n--     point:assign({ z: 3 })      -- Object.assign(point, { z: 3 })\n--     point:freeze()              -- Object.freeze(point)\n--\n-- `hasOwn` asks the table itself, not what its metatable's `__index`\n-- lends it. `assign` copies each source's members onto the table, later ones\n-- over earlier ones, skipping a `nil` source, and answers the table. `freeze`\n-- is Luau's `table.freeze`; under Lua 5.1, which cannot freeze a table, the\n-- table is answered as it is and `isFrozen` is false.\ndeclare metatable<T extends {}> T: {\n    __index: {\n        keys: (self: T) => ObjectKeys<T>,\n        values: (self: T) => ObjectValues<T>,\n        entries: (self: T) => ObjectEntries<T>,\n\n        hasOwn: (self: T, key: unknown) => boolean,\n        hasOwnProperty: (self: T, key: unknown) => boolean,\n        assign: (<U>(self: T, source: U) => T & U)\n            & (<U, V>(self: T, a: U, b: V) => T & U & V)\n            & (<U, V, W>(self: T, a: U, b: V, c: W) => T & U & V & W)\n            -- Generic like the rest: a plain signature would be tried first.\n            & (<S extends {}>(self: T, ...sources: S[]) => T),\n        freeze: (self: T) => Readonly<T>,\n        isFrozen: (self: T) => boolean,\n    },\n}\n";
+declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = Exclude<T, Falsy>\n\n-- `Exclude<T, U>` is the analyzer's own: what of `T` is not a `U`. Over a\n-- union it drops the members it takes whole; over `unknown`, `any`, a\n-- primitive or an unresolved parameter it is kept \u2014 `Exclude<string, \"a\">` is\n-- a string that is not `\"a\"` \u2014 unlike TypeScript's.\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = Exclude<T, nil>\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\n-- A class table builds with `new`: `InstanceType<typeof Dog>` is a `Dog`.\ntype InstanceType<T> = T extends { new: (...args: any[]) => infer R } ? R : never\ntype ConstructorParameters<T> = T extends { new: (...args: infer P) => any } ? P : never\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n\n-- ============================================================\n-- The metatables of the language's own values\n-- ============================================================\n\n-- A string's methods. The first group is Lua's string library, which a\n-- string really answers to; where Lua answers several values, tilua answers\n-- one, as the global functions do (`find` is an array, `gsub` the new\n-- string). The second group is written the way JavaScript writes it.\n--\n-- Positions are Lua's: `sub` and `slice` count from 1, and `indexOf` is\n-- `nil` when the text is not there.\ndeclare metatable string: {\n    __index: {\n        upper: (self: string) => string,\n        lower: (self: string) => string,\n        len: (self: string) => number,\n        sub: (self: string, i: number, j?: number) => string,\n        rep: (self: string, n: number, separator?: string) => string,\n        reverse: (self: string) => string,\n        format: (self: string, ...args: unknown[]) => string,\n        byte: ((self: string, i?: number) => number) & ((self: string, i: number, j: number) => number[]),\n        find: (self: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n        match: (self: string, pattern: string, init?: number) => [...string[]] | nil,\n        gmatch: (self: string, pattern: string) => () => [string, ...string[]] | nil,\n        gsub: (self: string, pattern: string, replacement: unknown, n?: number) => string,\n\n        trim: (self: string) => string,\n        trimStart: (self: string) => string,\n        trimEnd: (self: string) => string,\n        startsWith: (self: string, text: string) => boolean,\n        endsWith: (self: string, text: string) => boolean,\n        includes: (self: string, text: string) => boolean,\n        indexOf: (self: string, text: string, start?: number) => number | nil,\n        slice: (self: string, start?: number, stop?: number) => string,\n        replace: (self: string, text: string, replacement: string) => string,\n        replaceAll: (self: string, text: string, replacement: string) => string,\n        padStart: (self: string, length: number, padding?: string) => string,\n        padEnd: (self: string, length: number, padding?: string) => string,\n    },\n}\n\n-- An array's methods. Lua gives an array no metatable: the compiler lowers\n-- each call to a plain function, so they work on any array, one a Lua\n-- library made included.\n--\n-- Indices are Lua's: the first element is 1, and `indexOf` / `findIndex`\n-- answer `nil` rather than JavaScript's -1. `sort` takes Lua's comparator\n-- (true when `a` comes first). `push`, `pop`, `shift`, `unshift`,\n-- `sort` and `reverse` change the array; everything else returns a new one.\n-- The ones that only read take a `readonly T[]` too \u2014 `as const` lists, and\n-- what a function promised not to change \u2014 as TypeScript's `ReadonlyArray`.\n-- A `filter` whose test is a guard \u2014 `v is S`, or `v => v ~= nil` \u2014\n-- answers an array of what it let through.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: readonly T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: readonly T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (<S extends T>(self: readonly T[], test: (value: T, index: number) => value is S) => S[])\n            & ((self: readonly T[], test: (value: T, index: number) => boolean) => T[]),\n        map: <U>(self: readonly T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: readonly T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: readonly T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: readonly T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: readonly T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        -- Asking is not adding: any value may be looked for, and finding it\n        -- says it is one of the array's \u2014 `if (names:includes(s))` narrows `s`.\n        includes: (self: readonly T[], value: unknown) => value is T,\n        indexOf: (self: readonly T[], value: unknown, start?: number) => number | nil,\n        join: (self: readonly T[], separator?: string) => string,\n        concat: <U>(self: readonly T[], ...others: (readonly U[])[]) => (T | U)[],\n        slice: (self: readonly T[], start?: number, stop?: number) => T[],\n        flat: (self: readonly T[]) => T[],\n        -- JavaScript's, as arrays rather than iterators: `for (const [i, v] in\n        -- xs:entries())` walks positions and values, counting from 1.\n        keys: (self: readonly T[]) => number[],\n        values: (self: readonly T[]) => T[],\n        entries: (self: readonly T[]) => [number, T][],\n        reverse: (self: T[]) => T[],\n        sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],\n        push: (self: T[], ...args: T[]) => number,\n        pop: (self: T[]) => T | nil,\n        shift: (self: T[]) => T | nil,\n        unshift: (self: T[], ...args: T[]) => number,\n    },\n}\n\n-- A table's methods. Unlike JavaScript's `Object.keys`, they answer a\n-- tuple, in the order the table's type wrote its members:\n--\n--     const point = { x: 1, y: \"up\" }\n--     point:keys()     -- [\"x\", \"y\"]\n--     point:values()   -- [number, string]\n--     point:entries()  -- [[\"x\", number], [\"y\", string]]\n--\n-- A Lua table has no order of its own, so the compiler hands its runtime the\n-- keys as the type lists them. An optional member keeps its place, holding\n-- `nil` when it is missing; an indexer's keys follow the named ones. A\n-- member of the table's own with one of these names is what a call reaches,\n-- and a class instance, which has a metatable of its own, has none of them.\n--\n-- The rest are JavaScript's `Object` functions, written as methods of the\n-- table they take first:\n--\n--     point:hasOwn(\"x\")           -- Object.hasOwn(point, \"x\")\n--     point:assign({ z: 3 })      -- Object.assign(point, { z: 3 })\n--     point:freeze()              -- Object.freeze(point)\n--\n-- `hasOwn` asks the table itself, not what its metatable's `__index`\n-- lends it. `assign` copies each source's members onto the table, later ones\n-- over earlier ones, skipping a `nil` source, and answers the table. `freeze`\n-- is Luau's `table.freeze`; under Lua 5.1, which cannot freeze a table, the\n-- table is answered as it is and `isFrozen` is false.\ndeclare metatable<T extends {}> T: {\n    __index: {\n        keys: (self: T) => ObjectKeys<T>,\n        values: (self: T) => ObjectValues<T>,\n        entries: (self: T) => ObjectEntries<T>,\n\n        hasOwn: (self: T, key: unknown) => boolean,\n        hasOwnProperty: (self: T, key: unknown) => boolean,\n        assign: (<U>(self: T, source: U) => T & U)\n            & (<U, V>(self: T, a: U, b: V) => T & U & V)\n            & (<U, V, W>(self: T, a: U, b: V, c: W) => T & U & V & W)\n            -- Generic like the rest: a plain signature would be tried first.\n            & (<S extends {}>(self: T, ...sources: S[]) => T),\n        freeze: (self: T) => Readonly<T>,\n        isFrozen: (self: T) => boolean,\n    },\n}\n";
 
 /**
  * The Lua 5.1 standard library, always there — as TypeScript always has
@@ -1773,7 +1773,7 @@ declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `
  * `@tilua-types/lua`, where this used to live, is not loaded when a project
  * still names it: it would declare everything twice.
  */
-declare const STANDARD_LIBRARY_SOURCE = "\n-- The Lua 5.1 standard library, written in tilua.\n--\n-- This is the floor every tilua project stands on, the way TypeScript stands\n-- on JavaScript's: the functions and libraries Lua itself defines, there in\n-- every file without being asked for. Nothing here is Luau's or Roblox's \u2014\n-- `buffer`, `table.create` and the rest live one layer up in\n-- `@tilua-types/roblox`, which adds to it.\n--\n-- Lua's `type()` is not here: what a value is, is asked with the language's\n-- own `typeof v`, which also tells an array from an object.\n--\n-- Adding to it is literal: a name declared again in a later file keeps what\n-- earlier files gave it. `declare table: { find: ... }` in `@tilua-types/roblox` does\n-- not replace this `table`, it extends it, and overloads of a function\n-- accumulate the same way. So the layers really are layers.\n\n-- ============================================================\n-- Base library\n-- ============================================================\n\ndeclare _G: { [string]: unknown }\ndeclare _VERSION: string\n\ndeclare function require(module: unknown): unknown\ndeclare function tostring(value: unknown): string\ndeclare function tonumber(value: unknown, base?: number): number | nil\ndeclare function print(...args: unknown[]): nil\n-- `error` never returns, which is what lets\n-- `if v == nil then error(\"...\") end` narrow the rest of the block.\ndeclare function error(message: unknown, level?: number): never\n\n-- `asserts value` \u2014 narrows the *rest of the enclosing block*, the way\n-- TypeScript's assertion signatures do:\n--\n--     const part = workspace:FindFirstChild(\"Part\")  -- Instance | nil\n--     assert(part)\n--     part.Name                                      -- Instance, no `?`\n\ndeclare function assert<T>(value: T, message?: string): asserts value\n\n-- `pcall` and `xpcall` answer the way a JavaScript result object does:\n--\n--     const { success, data, error } = pcall(load, \"config\")\n--     if (success) { use(data) } else { warn(error) }\n--\n-- `data` is what the function returned. These are not Luau's own `pcall`:\n-- where Luau answers several values, tilua has one, and the compiler puts its\n-- own functions in place of those globals (runtime/result.luau) \u2014 for calls,\n-- and for the global read as a value alike. The same goes for `string.find`,\n-- `string.match`, `string.gsub`, `string.byte`, `math.modf`, `math.frexp`,\n-- `next`, `select`, `unpack`, `loadstring`, `pairs`, `ipairs` and\n-- `string.gmatch` below.\ntype PcallResult<T> = { success: true, data: T, error: nil } | { success: false, data: nil, error: unknown }\n\ndeclare function pcall<A extends unknown[], T>(fn: (...args: A) => T, ...args: A): PcallResult<T>\ndeclare function xpcall<A extends unknown[], T>(fn: (...args: A) => T, handler: (err: unknown) => unknown, ...args: A): PcallResult<T>\n-- `select(\"#\", ...args)` counts; `select(n, ...args)` is what follows the\n-- n-th, as an array.\ndeclare function select(n: \"#\", ...args: unknown[]): number\ndeclare function select<T>(n: number, ...args: T[]): T[]\n-- A copy of the list, or of part of it.\ndeclare function unpack<V>(list: V[], i?: number, j?: number): V[]\ndeclare function rawget(t: unknown, key: unknown): unknown\ndeclare function rawset<T>(t: T, key: unknown, value: unknown): T\ndeclare function rawequal(a: unknown, b: unknown): boolean\ndeclare function setmetatable<T>(t: T, mt: unknown): T\ndeclare function getmetatable(t: unknown): unknown\ndeclare function newproxy(addMeta?: boolean): unknown\n-- The entry after `key` \u2014 or nil, past the last one.\ndeclare function next<K, V>(t: { [K]: V }, key?: K): [K, V] | nil\n\n-- What `for (const item in source)` walks: `step` is called with the state\n-- and the item before it \u2014 `first` the first time \u2014 until it answers nil.\n-- An array, a table and an iterator function are walked too, so this is only\n-- what a source such as `pairs(t)` hands over.\ntype Iteration<S, T> = [(state: S, previous: T | nil) => T | nil, S, T | nil]\n\n-- `for (const [k, v] in pairs(t))` / `ipairs(t)`: each item is one `[key,\n-- value]` \u2014 a table, as every array is. The analyzer types it from `t` itself\n-- (a record's keys as literals, an array's elements); these declare the\n-- names, and their shape for any other use.\ndeclare function pairs<V>(t: V[]): Iteration<V[], [number, V]>\ndeclare function pairs<K, V>(t: { [K]: V }): Iteration<{ [K]: V }, [K, V]>\ndeclare function ipairs<V>(t: V[]): Iteration<V[], [number, V]>\n\ndeclare function collectgarbage(option: \"count\"): number\ndeclare function gcinfo(): number\ndeclare function getfenv(target?: unknown): { [string]: unknown }\ndeclare function setfenv<T>(target: T, env: { [string]: unknown }): T\ndeclare function loadstring(source: string, chunkname?: string): [((...args: unknown[]) => unknown) | nil, string | nil]\n\ndeclare debug: {\n    traceback: (message?: string, level?: number) => string,\n}\n\ndeclare string: {\n    format: (fmt: string, ...args: unknown[]) => string,\n    sub: (s: string, i: number, j?: number) => string,\n    len: (s: string) => number,\n    upper: (s: string) => string,\n    lower: (s: string) => string,\n    rep: (s: string, n: number, sep?: string) => string,\n    reverse: (s: string) => string,\n    -- Where the pattern is, then what it captured \u2014 or nil.\n    find: (s: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n    -- What it captured (the whole match when there are no captures), as\n    -- JavaScript's `match` answers \u2014 or nil.\n    match: (s: string, pattern: string, init?: number) => [...string[]] | nil,\n    -- Each match's captures (the whole match when there are none), one\n    -- array at a time: `for (const [word] in s:gmatch(\"%a+\"))`.\n    gmatch: (s: string, pattern: string) => () => [string, ...string[]] | nil,\n    -- The new string, as JavaScript's `replace` answers; Luau's count of\n    -- replacements is left behind.\n    gsub: (s: string, pattern: string, repl: unknown, n?: number) => string,\n    -- One code for one position; an array of them for a range.\n    byte: ((s: string, i?: number) => number) & ((s: string, i: number, j: number) => number[]),\n    char: (...args: number[]) => string,\n}\n\ndeclare math: {\n    abs: (x: number) => number,\n    floor: (x: number) => number,\n    ceil: (x: number) => number,\n    fmod: (x: number, y: number) => number,\n    modf: (x: number) => [number, number],\n    sqrt: (x: number) => number,\n    pow: (x: number, y: number) => number,\n    exp: (x: number) => number,\n    log: (x: number, base?: number) => number,\n    log10: (x: number) => number,\n    frexp: (x: number) => [number, number],\n    ldexp: (m: number, e: number) => number,\n    min: (...args: number[]) => number,\n    max: (...args: number[]) => number, \n    sin: (x: number) => number,\n    cos: (x: number) => number,\n    tan: (x: number) => number,\n    asin: (x: number) => number,\n    acos: (x: number) => number,\n    atan: (x: number) => number,\n    atan2: (y: number, x: number) => number,\n    sinh: (x: number) => number,\n    cosh: (x: number) => number,\n    tanh: (x: number) => number,\n    rad: (deg: number) => number,\n    deg: (rad: number) => number,\n    random: (m?: number, n?: number) => number,\n    randomseed: (x: number) => nil,\n    huge: number,\n    pi: number,\n}\n\n\ndeclare table: {\n    -- `insert(t, v)` appends; `insert(t, pos, v)` puts it there.\n    insert: (<T>(t: T[], value: T) => nil) & (<T>(t: T[], pos: number, value: T) => nil),\n    remove: <T>(t: T[], pos?: number) => T | nil,\n    concat: (t: (string | number)[], sep?: string, i?: number, j?: number) => string,\n    sort: <T>(t: T[], compare?: (a: T, b: T) => boolean) => nil,\n    -- Lua 5.1's originals. Deprecated there and gone from 5.2 on, but Luau\n    -- still answers to them, so code being ported still type-checks.\n    getn: <T>(t: T[]) => number,\n    maxn: <T>(t: T[]) => number,\n    foreach: <K, V, R>(t: { [K]: V }, f: (key: K, value: V) => R) => R | nil,\n    foreachi: <V, R>(t: V[], f: (index: number, value: V) => R) => R | nil,\n}\n\ndeclare os: {\n    time: (t?: unknown) => number,\n    clock: () => number,\n    date: (format?: string, time?: number) => unknown,\n    difftime: (a: number, b: number) => number,\n}\n\ndeclare coroutine: {\n    create: (fn: (...args: unknown[]) => unknown) => thread,\n    -- Answers like `pcall`: `{ success, data, error }`, `data` what the\n    -- coroutine yielded or returned.\n    resume: (co: thread, ...args: unknown[]) => PcallResult<unknown>,\n    yield: (...args: unknown[]) => unknown,\n    wrap: (fn: (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown,\n    status: (co: thread) => string,\n    running: () => thread,\n}\n\n-- A string's, an array's and a table's methods \u2014 `text:trim()`,\n-- `names:filter(f)`, `point:keys()` \u2014 are the language's: their metatables\n-- are declared in @tilua/parser's prelude, and the compiler runs them. A\n-- library adds to one with `declare metatable` of the same target, as\n-- `@tilua-types/roblox` gives a string Luau's `split`.\n\n-- The console. Written with `:` \u2014 `console:log(value)` \u2014 and lowered by the\n-- compiler (standard.ts) into runtime/console.luau, not into `print`.\n--\n-- Every line starts with the place that called it: `[src/main:12]: ...`.\n-- `print` and `warn` are left as written; `error` puts `src/main.tilua:12:` in\n-- its message, as Lua does.\n--\n-- `log` expands what it is given the way a browser console does: a table is\n-- printed as its contents, not as an address. A function prints as the type it\n-- was inferred to have *and* the code it was written as, both of which the\n-- compiler passes along, since neither exists once the code is running.\n--\n-- `error` reports in the project's own files: a bundle is one Luau file, so\n-- Luau's own line numbers name a file nobody wrote. It does not raise on the\n-- calling thread \u2014 the error goes to `task.spawn`, so reporting a problem\n-- never becomes one.\ntype Console = {\n    log: (self: Console, ...args: unknown[]) => nil,\n    warn: (self: Console, ...args: unknown[]) => nil,\n    error: (self: Console, ...args: unknown[]) => nil,\n}\n\ndeclare console: Console\n";
+declare const STANDARD_LIBRARY_SOURCE = "\n-- The Lua 5.1 standard library, written in tilua.\n--\n-- This is the floor every tilua project stands on, the way TypeScript stands\n-- on JavaScript's: the functions and libraries Lua itself defines, there in\n-- every file without being asked for. Nothing here is Luau's or Roblox's \u2014\n-- `buffer`, `table.create` and the rest live one layer up in\n-- `@tilua-types/roblox`, which adds to it.\n--\n-- Lua's `type()` is not here: what a value is, is asked with the language's\n-- own `typeof v`, which also tells an array from an object.\n--\n-- Adding to it is literal: a name declared again in a later file keeps what\n-- earlier files gave it. `declare table: { find: ... }` in `@tilua-types/roblox` does\n-- not replace this `table`, it extends it, and overloads of a function\n-- accumulate the same way. So the layers really are layers.\n\n-- ============================================================\n-- Base library\n-- ============================================================\n\ndeclare _G: { [string]: unknown }\ndeclare _VERSION: string\n\ndeclare function require(module: unknown): unknown\ndeclare function tostring(value: unknown): string\ndeclare function tonumber(value: unknown, base?: number): number | nil\ndeclare function print(...args: unknown[]): nil\n-- `error` never returns, which is what lets\n-- `if v == nil then error(\"...\") end` narrow the rest of the block.\ndeclare function error(message: unknown, level?: number): never\n\n-- `asserts value` \u2014 narrows the *rest of the enclosing block*, the way\n-- TypeScript's assertion signatures do:\n--\n--     const part = workspace:FindFirstChild(\"Part\")  -- Instance | nil\n--     assert(part)\n--     part.Name                                      -- Instance, no `?`\n\ndeclare function assert<T>(value: T, message?: string): asserts value\n\n-- `pcall` and `xpcall` answer the way a JavaScript result object does:\n--\n--     const { success, data, error } = pcall(load, \"config\")\n--     if (success) { use(data) } else { warn(error) }\n--\n-- `data` is what the function returned. These are not Luau's own `pcall`:\n-- where Luau answers several values, tilua has one, and the compiler puts its\n-- own functions in place of those globals (runtime/result.luau) \u2014 for calls,\n-- and for the global read as a value alike. The same goes for `string.find`,\n-- `string.match`, `string.gsub`, `string.byte`, `math.modf`, `math.frexp`,\n-- `next`, `select`, `unpack`, `loadstring`, `pairs`, `ipairs` and\n-- `string.gmatch` below.\ntype PcallResult<T> = { success: true, data: T, error: nil } | { success: false, data: nil, error: unknown }\n\ndeclare function pcall<A extends unknown[], T>(fn: (...args: A) => T, ...args: A): PcallResult<T>\ndeclare function xpcall<A extends unknown[], T>(fn: (...args: A) => T, handler: (err: unknown) => unknown, ...args: A): PcallResult<T>\n-- `select(\"#\", ...args)` counts; `select(n, ...args)` is what follows the\n-- n-th, as an array.\ndeclare function select(n: \"#\", ...args: unknown[]): number\ndeclare function select<T>(n: number, ...args: T[]): T[]\n-- A copy of the list, or of part of it.\ndeclare function unpack<V>(list: readonly V[], i?: number, j?: number): V[]\ndeclare function rawget(t: unknown, key: unknown): unknown\ndeclare function rawset<T>(t: T, key: unknown, value: unknown): T\ndeclare function rawequal(a: unknown, b: unknown): boolean\ndeclare function setmetatable<T>(t: T, mt: unknown): T\ndeclare function getmetatable(t: unknown): unknown\ndeclare function newproxy(addMeta?: boolean): unknown\n-- The entry after `key` \u2014 or nil, past the last one.\ndeclare function next<K, V>(t: { [K]: V }, key?: K): [K, V] | nil\n\n-- What `for (const item in source)` walks: `step` is called with the state\n-- and the item before it \u2014 `first` the first time \u2014 until it answers nil.\n-- An array, a table and an iterator function are walked too, so this is only\n-- what a source such as `pairs(t)` hands over.\ntype Iteration<S, T> = [(state: S, previous: T | nil) => T | nil, S, T | nil]\n\n-- `for (const [k, v] in pairs(t))` / `ipairs(t)`: each item is one `[key,\n-- value]` \u2014 a table, as every array is. The analyzer types it from `t` itself\n-- (a record's keys as literals, an array's elements); these declare the\n-- names, and their shape for any other use. Walking a list only reads it, so\n-- a read-only one (`as const`, `readonly T[]`) is walked as well.\ndeclare function pairs<V>(t: readonly V[]): Iteration<readonly V[], [number, V]>\ndeclare function pairs<K, V>(t: { [K]: V }): Iteration<{ [K]: V }, [K, V]>\ndeclare function ipairs<V>(t: readonly V[]): Iteration<readonly V[], [number, V]>\n\ndeclare function collectgarbage(option: \"count\"): number\ndeclare function gcinfo(): number\ndeclare function getfenv(target?: unknown): { [string]: unknown }\ndeclare function setfenv<T>(target: T, env: { [string]: unknown }): T\ndeclare function loadstring(source: string, chunkname?: string): [((...args: unknown[]) => unknown) | nil, string | nil]\n\ndeclare debug: {\n    traceback: (message?: string, level?: number) => string,\n}\n\ndeclare string: {\n    format: (fmt: string, ...args: unknown[]) => string,\n    sub: (s: string, i: number, j?: number) => string,\n    len: (s: string) => number,\n    upper: (s: string) => string,\n    lower: (s: string) => string,\n    rep: (s: string, n: number, sep?: string) => string,\n    reverse: (s: string) => string,\n    -- Where the pattern is, then what it captured \u2014 or nil.\n    find: (s: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n    -- What it captured (the whole match when there are no captures), as\n    -- JavaScript's `match` answers \u2014 or nil.\n    match: (s: string, pattern: string, init?: number) => [...string[]] | nil,\n    -- Each match's captures (the whole match when there are none), one\n    -- array at a time: `for (const [word] in s:gmatch(\"%a+\"))`.\n    gmatch: (s: string, pattern: string) => () => [string, ...string[]] | nil,\n    -- The new string, as JavaScript's `replace` answers; Luau's count of\n    -- replacements is left behind.\n    gsub: (s: string, pattern: string, repl: unknown, n?: number) => string,\n    -- One code for one position; an array of them for a range.\n    byte: ((s: string, i?: number) => number) & ((s: string, i: number, j: number) => number[]),\n    char: (...args: number[]) => string,\n}\n\ndeclare math: {\n    abs: (x: number) => number,\n    floor: (x: number) => number,\n    ceil: (x: number) => number,\n    fmod: (x: number, y: number) => number,\n    modf: (x: number) => [number, number],\n    sqrt: (x: number) => number,\n    pow: (x: number, y: number) => number,\n    exp: (x: number) => number,\n    log: (x: number, base?: number) => number,\n    log10: (x: number) => number,\n    frexp: (x: number) => [number, number],\n    ldexp: (m: number, e: number) => number,\n    min: (...args: number[]) => number,\n    max: (...args: number[]) => number, \n    sin: (x: number) => number,\n    cos: (x: number) => number,\n    tan: (x: number) => number,\n    asin: (x: number) => number,\n    acos: (x: number) => number,\n    atan: (x: number) => number,\n    atan2: (y: number, x: number) => number,\n    sinh: (x: number) => number,\n    cosh: (x: number) => number,\n    tanh: (x: number) => number,\n    rad: (deg: number) => number,\n    deg: (rad: number) => number,\n    random: (m?: number, n?: number) => number,\n    randomseed: (x: number) => nil,\n    huge: number,\n    pi: number,\n}\n\n\ndeclare table: {\n    -- `insert(t, v)` appends; `insert(t, pos, v)` puts it there.\n    insert: (<T>(t: T[], value: T) => nil) & (<T>(t: T[], pos: number, value: T) => nil),\n    remove: <T>(t: T[], pos?: number) => T | nil,\n    concat: (t: readonly (string | number)[], sep?: string, i?: number, j?: number) => string,\n    sort: <T>(t: T[], compare?: (a: T, b: T) => boolean) => nil,\n    -- Lua 5.1's originals. Deprecated there and gone from 5.2 on, but Luau\n    -- still answers to them, so code being ported still type-checks.\n    getn: <T>(t: readonly T[]) => number,\n    maxn: <T>(t: readonly T[]) => number,\n    foreach: <K, V, R>(t: { [K]: V }, f: (key: K, value: V) => R) => R | nil,\n    foreachi: <V, R>(t: readonly V[], f: (index: number, value: V) => R) => R | nil,\n}\n\ndeclare os: {\n    time: (t?: unknown) => number,\n    clock: () => number,\n    date: (format?: string, time?: number) => unknown,\n    difftime: (a: number, b: number) => number,\n}\n\ndeclare coroutine: {\n    create: (fn: (...args: unknown[]) => unknown) => thread,\n    -- Answers like `pcall`: `{ success, data, error }`, `data` what the\n    -- coroutine yielded or returned.\n    resume: (co: thread, ...args: unknown[]) => PcallResult<unknown>,\n    yield: (...args: unknown[]) => unknown,\n    wrap: (fn: (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown,\n    status: (co: thread) => string,\n    running: () => thread,\n}\n\n-- A string's, an array's and a table's methods \u2014 `text:trim()`,\n-- `names:filter(f)`, `point:keys()` \u2014 are the language's: their metatables\n-- are declared in @tilua/parser's prelude, and the compiler runs them. A\n-- library adds to one with `declare metatable` of the same target, as\n-- `@tilua-types/roblox` gives a string Luau's `split`.\n\n-- The console. Written with `:` \u2014 `console:log(value)` \u2014 and lowered by the\n-- compiler (standard.ts) into runtime/console.luau, not into `print`.\n--\n-- Every line starts with the place that called it: `[src/main:12]: ...`.\n-- `print` and `warn` are left as written; `error` puts `src/main.tilua:12:` in\n-- its message, as Lua does.\n--\n-- `log` expands what it is given the way a browser console does: a table is\n-- printed as its contents, not as an address. A function prints as the type it\n-- was inferred to have *and* the code it was written as, both of which the\n-- compiler passes along, since neither exists once the code is running.\n--\n-- `error` reports in the project's own files: a bundle is one Luau file, so\n-- Luau's own line numbers name a file nobody wrote. It does not raise on the\n-- calling thread \u2014 the error goes to `task.spawn`, so reporting a problem\n-- never becomes one.\ntype Console = {\n    log: (self: Console, ...args: unknown[]) => nil,\n    warn: (self: Console, ...args: unknown[]) => nil,\n    error: (self: Console, ...args: unknown[]) => nil,\n}\n\ndeclare console: Console\n";
 /** The standard library, parsed once. */
 declare function standardLibrary(): Program;
 /** The globals the standard library declares: `print`, `string`, ... */

package/dist/index.d.ts

@@ -1756,7 +1756,7 @@ resolveModule?: (specifier: string) => ModuleExports | undefined): ModuleExports
  * `ObjectValues<T>` and `ObjectEntries<T>`, an object's members as tuples in
  * the order they were written.
  */
-declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = Exclude<T, Falsy>\n\n-- `Exclude<T, U>` is the analyzer's own: what of `T` is not a `U`. Over a\n-- union it drops the members it takes whole; over `unknown`, `any`, a\n-- primitive or an unresolved parameter it is kept \u2014 `Exclude<string, \"a\">` is\n-- a string that is not `\"a\"` \u2014 unlike TypeScript's.\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = Exclude<T, nil>\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\n-- A class table builds with `new`: `InstanceType<typeof Dog>` is a `Dog`.\ntype InstanceType<T> = T extends { new: (...args: any[]) => infer R } ? R : never\ntype ConstructorParameters<T> = T extends { new: (...args: infer P) => any } ? P : never\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n\n-- ============================================================\n-- The metatables of the language's own values\n-- ============================================================\n\n-- A string's methods. The first group is Lua's string library, which a\n-- string really answers to; where Lua answers several values, tilua answers\n-- one, as the global functions do (`find` is an array, `gsub` the new\n-- string). The second group is written the way JavaScript writes it.\n--\n-- Positions are Lua's: `sub` and `slice` count from 1, and `indexOf` is\n-- `nil` when the text is not there.\ndeclare metatable string: {\n    __index: {\n        upper: (self: string) => string,\n        lower: (self: string) => string,\n        len: (self: string) => number,\n        sub: (self: string, i: number, j?: number) => string,\n        rep: (self: string, n: number, separator?: string) => string,\n        reverse: (self: string) => string,\n        format: (self: string, ...args: unknown[]) => string,\n        byte: ((self: string, i?: number) => number) & ((self: string, i: number, j: number) => number[]),\n        find: (self: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n        match: (self: string, pattern: string, init?: number) => [...string[]] | nil,\n        gmatch: (self: string, pattern: string) => () => [string, ...string[]] | nil,\n        gsub: (self: string, pattern: string, replacement: unknown, n?: number) => string,\n\n        trim: (self: string) => string,\n        trimStart: (self: string) => string,\n        trimEnd: (self: string) => string,\n        startsWith: (self: string, text: string) => boolean,\n        endsWith: (self: string, text: string) => boolean,\n        includes: (self: string, text: string) => boolean,\n        indexOf: (self: string, text: string, start?: number) => number | nil,\n        slice: (self: string, start?: number, stop?: number) => string,\n        replace: (self: string, text: string, replacement: string) => string,\n        replaceAll: (self: string, text: string, replacement: string) => string,\n        padStart: (self: string, length: number, padding?: string) => string,\n        padEnd: (self: string, length: number, padding?: string) => string,\n    },\n}\n\n-- An array's methods. Lua gives an array no metatable: the compiler lowers\n-- each call to a plain function, so they work on any array, one a Lua\n-- library made included.\n--\n-- Indices are Lua's: the first element is 1, and `indexOf` / `findIndex`\n-- answer `nil` rather than JavaScript's -1. `sort` takes Lua's comparator\n-- (true when `a` comes first). `push`, `pop`, `shift`, `unshift`,\n-- `sort` and `reverse` change the array; everything else returns a new one.\n-- The ones that only read take a `readonly T[]` too \u2014 `as const` lists, and\n-- what a function promised not to change \u2014 as TypeScript's `ReadonlyArray`.\n-- A `filter` whose test is a guard \u2014 `v is S`, or `v => v ~= nil` \u2014\n-- answers an array of what it let through.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: readonly T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: readonly T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (<S extends T>(self: readonly T[], test: (value: T, index: number) => value is S) => S[])\n            & ((self: readonly T[], test: (value: T, index: number) => boolean) => T[]),\n        map: <U>(self: readonly T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: readonly T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: readonly T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: readonly T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: readonly T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        -- Asking is not adding: any value may be looked for, and finding it\n        -- says it is one of the array's \u2014 `if (names:includes(s))` narrows `s`.\n        includes: (self: readonly T[], value: unknown) => value is T,\n        indexOf: (self: readonly T[], value: unknown, start?: number) => number | nil,\n        join: (self: readonly T[], separator?: string) => string,\n        concat: <U>(self: readonly T[], ...others: (readonly U[])[]) => (T | U)[],\n        slice: (self: readonly T[], start?: number, stop?: number) => T[],\n        flat: (self: readonly T[]) => T[],\n        reverse: (self: T[]) => T[],\n        sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],\n        push: (self: T[], ...args: T[]) => number,\n        pop: (self: T[]) => T | nil,\n        shift: (self: T[]) => T | nil,\n        unshift: (self: T[], ...args: T[]) => number,\n    },\n}\n\n-- A table's methods. Unlike JavaScript's `Object.keys`, they answer a\n-- tuple, in the order the table's type wrote its members:\n--\n--     const point = { x: 1, y: \"up\" }\n--     point:keys()     -- [\"x\", \"y\"]\n--     point:values()   -- [number, string]\n--     point:entries()  -- [[\"x\", number], [\"y\", string]]\n--\n-- A Lua table has no order of its own, so the compiler hands its runtime the\n-- keys as the type lists them. An optional member keeps its place, holding\n-- `nil` when it is missing; an indexer's keys follow the named ones. A\n-- member of the table's own with one of these names is what a call reaches,\n-- and a class instance, which has a metatable of its own, has none of them.\n--\n-- The rest are JavaScript's `Object` functions, written as methods of the\n-- table they take first:\n--\n--     point:hasOwn(\"x\")           -- Object.hasOwn(point, \"x\")\n--     point:assign({ z: 3 })      -- Object.assign(point, { z: 3 })\n--     point:freeze()              -- Object.freeze(point)\n--\n-- `hasOwn` asks the table itself, not what its metatable's `__index`\n-- lends it. `assign` copies each source's members onto the table, later ones\n-- over earlier ones, skipping a `nil` source, and answers the table. `freeze`\n-- is Luau's `table.freeze`; under Lua 5.1, which cannot freeze a table, the\n-- table is answered as it is and `isFrozen` is false.\ndeclare metatable<T extends {}> T: {\n    __index: {\n        keys: (self: T) => ObjectKeys<T>,\n        values: (self: T) => ObjectValues<T>,\n        entries: (self: T) => ObjectEntries<T>,\n\n        hasOwn: (self: T, key: unknown) => boolean,\n        hasOwnProperty: (self: T, key: unknown) => boolean,\n        assign: (<U>(self: T, source: U) => T & U)\n            & (<U, V>(self: T, a: U, b: V) => T & U & V)\n            & (<U, V, W>(self: T, a: U, b: V, c: W) => T & U & V & W)\n            -- Generic like the rest: a plain signature would be tried first.\n            & (<S extends {}>(self: T, ...sources: S[]) => T),\n        freeze: (self: T) => Readonly<T>,\n        isFrozen: (self: T) => boolean,\n    },\n}\n";
+declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `0` and `\"\"` are truthy.\n-- These are what truthiness narrowing computes, made available to write down.\ntype Falsy = nil | false\ntype Truthy<T> = Exclude<T, Falsy>\n\n-- `Exclude<T, U>` is the analyzer's own: what of `T` is not a `U`. Over a\n-- union it drops the members it takes whole; over `unknown`, `any`, a\n-- primitive or an unresolved parameter it is kept \u2014 `Exclude<string, \"a\">` is\n-- a string that is not `\"a\"` \u2014 unlike TypeScript's.\ntype Extract<T, U> = T extends U ? T : never\ntype NonNullable<T> = Exclude<T, nil>\n\ntype ReturnType<T> = T extends (...args: unknown[]) => infer R ? R : never\ntype Parameters<T> = T extends (...args: infer P) => unknown ? P : never\n\ntype Partial<T> = { [K in keyof T]?: T[K] }\ntype Required<T> = { [K in keyof T]-?: T[K] }\ntype Readonly<T> = { readonly [K in keyof T]: T[K] }\ntype Mutable<T> = { -readonly [K in keyof T]: T[K] }\n\n-- A class table builds with `new`: `InstanceType<typeof Dog>` is a `Dog`.\ntype InstanceType<T> = T extends { new: (...args: any[]) => infer R } ? R : never\ntype ConstructorParameters<T> = T extends { new: (...args: infer P) => any } ? P : never\n\ntype Pick<T, K> = { [P in K]: T[P] }\ntype Omit<T, K> = Pick<T, Exclude<keyof T, K>>\ntype Record<K, V> = { [P in K]: V }\n\n-- ============================================================\n-- The metatables of the language's own values\n-- ============================================================\n\n-- A string's methods. The first group is Lua's string library, which a\n-- string really answers to; where Lua answers several values, tilua answers\n-- one, as the global functions do (`find` is an array, `gsub` the new\n-- string). The second group is written the way JavaScript writes it.\n--\n-- Positions are Lua's: `sub` and `slice` count from 1, and `indexOf` is\n-- `nil` when the text is not there.\ndeclare metatable string: {\n    __index: {\n        upper: (self: string) => string,\n        lower: (self: string) => string,\n        len: (self: string) => number,\n        sub: (self: string, i: number, j?: number) => string,\n        rep: (self: string, n: number, separator?: string) => string,\n        reverse: (self: string) => string,\n        format: (self: string, ...args: unknown[]) => string,\n        byte: ((self: string, i?: number) => number) & ((self: string, i: number, j: number) => number[]),\n        find: (self: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n        match: (self: string, pattern: string, init?: number) => [...string[]] | nil,\n        gmatch: (self: string, pattern: string) => () => [string, ...string[]] | nil,\n        gsub: (self: string, pattern: string, replacement: unknown, n?: number) => string,\n\n        trim: (self: string) => string,\n        trimStart: (self: string) => string,\n        trimEnd: (self: string) => string,\n        startsWith: (self: string, text: string) => boolean,\n        endsWith: (self: string, text: string) => boolean,\n        includes: (self: string, text: string) => boolean,\n        indexOf: (self: string, text: string, start?: number) => number | nil,\n        slice: (self: string, start?: number, stop?: number) => string,\n        replace: (self: string, text: string, replacement: string) => string,\n        replaceAll: (self: string, text: string, replacement: string) => string,\n        padStart: (self: string, length: number, padding?: string) => string,\n        padEnd: (self: string, length: number, padding?: string) => string,\n    },\n}\n\n-- An array's methods. Lua gives an array no metatable: the compiler lowers\n-- each call to a plain function, so they work on any array, one a Lua\n-- library made included.\n--\n-- Indices are Lua's: the first element is 1, and `indexOf` / `findIndex`\n-- answer `nil` rather than JavaScript's -1. `sort` takes Lua's comparator\n-- (true when `a` comes first). `push`, `pop`, `shift`, `unshift`,\n-- `sort` and `reverse` change the array; everything else returns a new one.\n-- The ones that only read take a `readonly T[]` too \u2014 `as const` lists, and\n-- what a function promised not to change \u2014 as TypeScript's `ReadonlyArray`.\n-- A `filter` whose test is a guard \u2014 `v is S`, or `v => v ~= nil` \u2014\n-- answers an array of what it let through.\ndeclare metatable<T> T[]: {\n    __index: {\n        find: (self: readonly T[], test: (value: T, index: number) => boolean) => T | nil,\n        findIndex: (self: readonly T[], test: (value: T, index: number) => boolean) => number | nil,\n        filter: (<S extends T>(self: readonly T[], test: (value: T, index: number) => value is S) => S[])\n            & ((self: readonly T[], test: (value: T, index: number) => boolean) => T[]),\n        map: <U>(self: readonly T[], transform: (value: T, index: number) => U) => U[],\n        forEach: (self: readonly T[], visit: (value: T, index: number) => nil) => nil,\n        some: (self: readonly T[], test: (value: T, index: number) => boolean) => boolean,\n        every: (self: readonly T[], test: (value: T, index: number) => boolean) => boolean,\n        reduce: <U>(self: readonly T[], step: (total: U, value: T, index: number) => U, initial: U) => U,\n        -- Asking is not adding: any value may be looked for, and finding it\n        -- says it is one of the array's \u2014 `if (names:includes(s))` narrows `s`.\n        includes: (self: readonly T[], value: unknown) => value is T,\n        indexOf: (self: readonly T[], value: unknown, start?: number) => number | nil,\n        join: (self: readonly T[], separator?: string) => string,\n        concat: <U>(self: readonly T[], ...others: (readonly U[])[]) => (T | U)[],\n        slice: (self: readonly T[], start?: number, stop?: number) => T[],\n        flat: (self: readonly T[]) => T[],\n        -- JavaScript's, as arrays rather than iterators: `for (const [i, v] in\n        -- xs:entries())` walks positions and values, counting from 1.\n        keys: (self: readonly T[]) => number[],\n        values: (self: readonly T[]) => T[],\n        entries: (self: readonly T[]) => [number, T][],\n        reverse: (self: T[]) => T[],\n        sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],\n        push: (self: T[], ...args: T[]) => number,\n        pop: (self: T[]) => T | nil,\n        shift: (self: T[]) => T | nil,\n        unshift: (self: T[], ...args: T[]) => number,\n    },\n}\n\n-- A table's methods. Unlike JavaScript's `Object.keys`, they answer a\n-- tuple, in the order the table's type wrote its members:\n--\n--     const point = { x: 1, y: \"up\" }\n--     point:keys()     -- [\"x\", \"y\"]\n--     point:values()   -- [number, string]\n--     point:entries()  -- [[\"x\", number], [\"y\", string]]\n--\n-- A Lua table has no order of its own, so the compiler hands its runtime the\n-- keys as the type lists them. An optional member keeps its place, holding\n-- `nil` when it is missing; an indexer's keys follow the named ones. A\n-- member of the table's own with one of these names is what a call reaches,\n-- and a class instance, which has a metatable of its own, has none of them.\n--\n-- The rest are JavaScript's `Object` functions, written as methods of the\n-- table they take first:\n--\n--     point:hasOwn(\"x\")           -- Object.hasOwn(point, \"x\")\n--     point:assign({ z: 3 })      -- Object.assign(point, { z: 3 })\n--     point:freeze()              -- Object.freeze(point)\n--\n-- `hasOwn` asks the table itself, not what its metatable's `__index`\n-- lends it. `assign` copies each source's members onto the table, later ones\n-- over earlier ones, skipping a `nil` source, and answers the table. `freeze`\n-- is Luau's `table.freeze`; under Lua 5.1, which cannot freeze a table, the\n-- table is answered as it is and `isFrozen` is false.\ndeclare metatable<T extends {}> T: {\n    __index: {\n        keys: (self: T) => ObjectKeys<T>,\n        values: (self: T) => ObjectValues<T>,\n        entries: (self: T) => ObjectEntries<T>,\n\n        hasOwn: (self: T, key: unknown) => boolean,\n        hasOwnProperty: (self: T, key: unknown) => boolean,\n        assign: (<U>(self: T, source: U) => T & U)\n            & (<U, V>(self: T, a: U, b: V) => T & U & V)\n            & (<U, V, W>(self: T, a: U, b: V, c: W) => T & U & V & W)\n            -- Generic like the rest: a plain signature would be tried first.\n            & (<S extends {}>(self: T, ...sources: S[]) => T),\n        freeze: (self: T) => Readonly<T>,\n        isFrozen: (self: T) => boolean,\n    },\n}\n";
 
 /**
  * The Lua 5.1 standard library, always there — as TypeScript always has
@@ -1773,7 +1773,7 @@ declare const PRELUDE_SOURCE = "\n-- In Luau only `nil` and `false` are falsy: `
  * `@tilua-types/lua`, where this used to live, is not loaded when a project
  * still names it: it would declare everything twice.
  */
-declare const STANDARD_LIBRARY_SOURCE = "\n-- The Lua 5.1 standard library, written in tilua.\n--\n-- This is the floor every tilua project stands on, the way TypeScript stands\n-- on JavaScript's: the functions and libraries Lua itself defines, there in\n-- every file without being asked for. Nothing here is Luau's or Roblox's \u2014\n-- `buffer`, `table.create` and the rest live one layer up in\n-- `@tilua-types/roblox`, which adds to it.\n--\n-- Lua's `type()` is not here: what a value is, is asked with the language's\n-- own `typeof v`, which also tells an array from an object.\n--\n-- Adding to it is literal: a name declared again in a later file keeps what\n-- earlier files gave it. `declare table: { find: ... }` in `@tilua-types/roblox` does\n-- not replace this `table`, it extends it, and overloads of a function\n-- accumulate the same way. So the layers really are layers.\n\n-- ============================================================\n-- Base library\n-- ============================================================\n\ndeclare _G: { [string]: unknown }\ndeclare _VERSION: string\n\ndeclare function require(module: unknown): unknown\ndeclare function tostring(value: unknown): string\ndeclare function tonumber(value: unknown, base?: number): number | nil\ndeclare function print(...args: unknown[]): nil\n-- `error` never returns, which is what lets\n-- `if v == nil then error(\"...\") end` narrow the rest of the block.\ndeclare function error(message: unknown, level?: number): never\n\n-- `asserts value` \u2014 narrows the *rest of the enclosing block*, the way\n-- TypeScript's assertion signatures do:\n--\n--     const part = workspace:FindFirstChild(\"Part\")  -- Instance | nil\n--     assert(part)\n--     part.Name                                      -- Instance, no `?`\n\ndeclare function assert<T>(value: T, message?: string): asserts value\n\n-- `pcall` and `xpcall` answer the way a JavaScript result object does:\n--\n--     const { success, data, error } = pcall(load, \"config\")\n--     if (success) { use(data) } else { warn(error) }\n--\n-- `data` is what the function returned. These are not Luau's own `pcall`:\n-- where Luau answers several values, tilua has one, and the compiler puts its\n-- own functions in place of those globals (runtime/result.luau) \u2014 for calls,\n-- and for the global read as a value alike. The same goes for `string.find`,\n-- `string.match`, `string.gsub`, `string.byte`, `math.modf`, `math.frexp`,\n-- `next`, `select`, `unpack`, `loadstring`, `pairs`, `ipairs` and\n-- `string.gmatch` below.\ntype PcallResult<T> = { success: true, data: T, error: nil } | { success: false, data: nil, error: unknown }\n\ndeclare function pcall<A extends unknown[], T>(fn: (...args: A) => T, ...args: A): PcallResult<T>\ndeclare function xpcall<A extends unknown[], T>(fn: (...args: A) => T, handler: (err: unknown) => unknown, ...args: A): PcallResult<T>\n-- `select(\"#\", ...args)` counts; `select(n, ...args)` is what follows the\n-- n-th, as an array.\ndeclare function select(n: \"#\", ...args: unknown[]): number\ndeclare function select<T>(n: number, ...args: T[]): T[]\n-- A copy of the list, or of part of it.\ndeclare function unpack<V>(list: V[], i?: number, j?: number): V[]\ndeclare function rawget(t: unknown, key: unknown): unknown\ndeclare function rawset<T>(t: T, key: unknown, value: unknown): T\ndeclare function rawequal(a: unknown, b: unknown): boolean\ndeclare function setmetatable<T>(t: T, mt: unknown): T\ndeclare function getmetatable(t: unknown): unknown\ndeclare function newproxy(addMeta?: boolean): unknown\n-- The entry after `key` \u2014 or nil, past the last one.\ndeclare function next<K, V>(t: { [K]: V }, key?: K): [K, V] | nil\n\n-- What `for (const item in source)` walks: `step` is called with the state\n-- and the item before it \u2014 `first` the first time \u2014 until it answers nil.\n-- An array, a table and an iterator function are walked too, so this is only\n-- what a source such as `pairs(t)` hands over.\ntype Iteration<S, T> = [(state: S, previous: T | nil) => T | nil, S, T | nil]\n\n-- `for (const [k, v] in pairs(t))` / `ipairs(t)`: each item is one `[key,\n-- value]` \u2014 a table, as every array is. The analyzer types it from `t` itself\n-- (a record's keys as literals, an array's elements); these declare the\n-- names, and their shape for any other use.\ndeclare function pairs<V>(t: V[]): Iteration<V[], [number, V]>\ndeclare function pairs<K, V>(t: { [K]: V }): Iteration<{ [K]: V }, [K, V]>\ndeclare function ipairs<V>(t: V[]): Iteration<V[], [number, V]>\n\ndeclare function collectgarbage(option: \"count\"): number\ndeclare function gcinfo(): number\ndeclare function getfenv(target?: unknown): { [string]: unknown }\ndeclare function setfenv<T>(target: T, env: { [string]: unknown }): T\ndeclare function loadstring(source: string, chunkname?: string): [((...args: unknown[]) => unknown) | nil, string | nil]\n\ndeclare debug: {\n    traceback: (message?: string, level?: number) => string,\n}\n\ndeclare string: {\n    format: (fmt: string, ...args: unknown[]) => string,\n    sub: (s: string, i: number, j?: number) => string,\n    len: (s: string) => number,\n    upper: (s: string) => string,\n    lower: (s: string) => string,\n    rep: (s: string, n: number, sep?: string) => string,\n    reverse: (s: string) => string,\n    -- Where the pattern is, then what it captured \u2014 or nil.\n    find: (s: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n    -- What it captured (the whole match when there are no captures), as\n    -- JavaScript's `match` answers \u2014 or nil.\n    match: (s: string, pattern: string, init?: number) => [...string[]] | nil,\n    -- Each match's captures (the whole match when there are none), one\n    -- array at a time: `for (const [word] in s:gmatch(\"%a+\"))`.\n    gmatch: (s: string, pattern: string) => () => [string, ...string[]] | nil,\n    -- The new string, as JavaScript's `replace` answers; Luau's count of\n    -- replacements is left behind.\n    gsub: (s: string, pattern: string, repl: unknown, n?: number) => string,\n    -- One code for one position; an array of them for a range.\n    byte: ((s: string, i?: number) => number) & ((s: string, i: number, j: number) => number[]),\n    char: (...args: number[]) => string,\n}\n\ndeclare math: {\n    abs: (x: number) => number,\n    floor: (x: number) => number,\n    ceil: (x: number) => number,\n    fmod: (x: number, y: number) => number,\n    modf: (x: number) => [number, number],\n    sqrt: (x: number) => number,\n    pow: (x: number, y: number) => number,\n    exp: (x: number) => number,\n    log: (x: number, base?: number) => number,\n    log10: (x: number) => number,\n    frexp: (x: number) => [number, number],\n    ldexp: (m: number, e: number) => number,\n    min: (...args: number[]) => number,\n    max: (...args: number[]) => number, \n    sin: (x: number) => number,\n    cos: (x: number) => number,\n    tan: (x: number) => number,\n    asin: (x: number) => number,\n    acos: (x: number) => number,\n    atan: (x: number) => number,\n    atan2: (y: number, x: number) => number,\n    sinh: (x: number) => number,\n    cosh: (x: number) => number,\n    tanh: (x: number) => number,\n    rad: (deg: number) => number,\n    deg: (rad: number) => number,\n    random: (m?: number, n?: number) => number,\n    randomseed: (x: number) => nil,\n    huge: number,\n    pi: number,\n}\n\n\ndeclare table: {\n    -- `insert(t, v)` appends; `insert(t, pos, v)` puts it there.\n    insert: (<T>(t: T[], value: T) => nil) & (<T>(t: T[], pos: number, value: T) => nil),\n    remove: <T>(t: T[], pos?: number) => T | nil,\n    concat: (t: (string | number)[], sep?: string, i?: number, j?: number) => string,\n    sort: <T>(t: T[], compare?: (a: T, b: T) => boolean) => nil,\n    -- Lua 5.1's originals. Deprecated there and gone from 5.2 on, but Luau\n    -- still answers to them, so code being ported still type-checks.\n    getn: <T>(t: T[]) => number,\n    maxn: <T>(t: T[]) => number,\n    foreach: <K, V, R>(t: { [K]: V }, f: (key: K, value: V) => R) => R | nil,\n    foreachi: <V, R>(t: V[], f: (index: number, value: V) => R) => R | nil,\n}\n\ndeclare os: {\n    time: (t?: unknown) => number,\n    clock: () => number,\n    date: (format?: string, time?: number) => unknown,\n    difftime: (a: number, b: number) => number,\n}\n\ndeclare coroutine: {\n    create: (fn: (...args: unknown[]) => unknown) => thread,\n    -- Answers like `pcall`: `{ success, data, error }`, `data` what the\n    -- coroutine yielded or returned.\n    resume: (co: thread, ...args: unknown[]) => PcallResult<unknown>,\n    yield: (...args: unknown[]) => unknown,\n    wrap: (fn: (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown,\n    status: (co: thread) => string,\n    running: () => thread,\n}\n\n-- A string's, an array's and a table's methods \u2014 `text:trim()`,\n-- `names:filter(f)`, `point:keys()` \u2014 are the language's: their metatables\n-- are declared in @tilua/parser's prelude, and the compiler runs them. A\n-- library adds to one with `declare metatable` of the same target, as\n-- `@tilua-types/roblox` gives a string Luau's `split`.\n\n-- The console. Written with `:` \u2014 `console:log(value)` \u2014 and lowered by the\n-- compiler (standard.ts) into runtime/console.luau, not into `print`.\n--\n-- Every line starts with the place that called it: `[src/main:12]: ...`.\n-- `print` and `warn` are left as written; `error` puts `src/main.tilua:12:` in\n-- its message, as Lua does.\n--\n-- `log` expands what it is given the way a browser console does: a table is\n-- printed as its contents, not as an address. A function prints as the type it\n-- was inferred to have *and* the code it was written as, both of which the\n-- compiler passes along, since neither exists once the code is running.\n--\n-- `error` reports in the project's own files: a bundle is one Luau file, so\n-- Luau's own line numbers name a file nobody wrote. It does not raise on the\n-- calling thread \u2014 the error goes to `task.spawn`, so reporting a problem\n-- never becomes one.\ntype Console = {\n    log: (self: Console, ...args: unknown[]) => nil,\n    warn: (self: Console, ...args: unknown[]) => nil,\n    error: (self: Console, ...args: unknown[]) => nil,\n}\n\ndeclare console: Console\n";
+declare const STANDARD_LIBRARY_SOURCE = "\n-- The Lua 5.1 standard library, written in tilua.\n--\n-- This is the floor every tilua project stands on, the way TypeScript stands\n-- on JavaScript's: the functions and libraries Lua itself defines, there in\n-- every file without being asked for. Nothing here is Luau's or Roblox's \u2014\n-- `buffer`, `table.create` and the rest live one layer up in\n-- `@tilua-types/roblox`, which adds to it.\n--\n-- Lua's `type()` is not here: what a value is, is asked with the language's\n-- own `typeof v`, which also tells an array from an object.\n--\n-- Adding to it is literal: a name declared again in a later file keeps what\n-- earlier files gave it. `declare table: { find: ... }` in `@tilua-types/roblox` does\n-- not replace this `table`, it extends it, and overloads of a function\n-- accumulate the same way. So the layers really are layers.\n\n-- ============================================================\n-- Base library\n-- ============================================================\n\ndeclare _G: { [string]: unknown }\ndeclare _VERSION: string\n\ndeclare function require(module: unknown): unknown\ndeclare function tostring(value: unknown): string\ndeclare function tonumber(value: unknown, base?: number): number | nil\ndeclare function print(...args: unknown[]): nil\n-- `error` never returns, which is what lets\n-- `if v == nil then error(\"...\") end` narrow the rest of the block.\ndeclare function error(message: unknown, level?: number): never\n\n-- `asserts value` \u2014 narrows the *rest of the enclosing block*, the way\n-- TypeScript's assertion signatures do:\n--\n--     const part = workspace:FindFirstChild(\"Part\")  -- Instance | nil\n--     assert(part)\n--     part.Name                                      -- Instance, no `?`\n\ndeclare function assert<T>(value: T, message?: string): asserts value\n\n-- `pcall` and `xpcall` answer the way a JavaScript result object does:\n--\n--     const { success, data, error } = pcall(load, \"config\")\n--     if (success) { use(data) } else { warn(error) }\n--\n-- `data` is what the function returned. These are not Luau's own `pcall`:\n-- where Luau answers several values, tilua has one, and the compiler puts its\n-- own functions in place of those globals (runtime/result.luau) \u2014 for calls,\n-- and for the global read as a value alike. The same goes for `string.find`,\n-- `string.match`, `string.gsub`, `string.byte`, `math.modf`, `math.frexp`,\n-- `next`, `select`, `unpack`, `loadstring`, `pairs`, `ipairs` and\n-- `string.gmatch` below.\ntype PcallResult<T> = { success: true, data: T, error: nil } | { success: false, data: nil, error: unknown }\n\ndeclare function pcall<A extends unknown[], T>(fn: (...args: A) => T, ...args: A): PcallResult<T>\ndeclare function xpcall<A extends unknown[], T>(fn: (...args: A) => T, handler: (err: unknown) => unknown, ...args: A): PcallResult<T>\n-- `select(\"#\", ...args)` counts; `select(n, ...args)` is what follows the\n-- n-th, as an array.\ndeclare function select(n: \"#\", ...args: unknown[]): number\ndeclare function select<T>(n: number, ...args: T[]): T[]\n-- A copy of the list, or of part of it.\ndeclare function unpack<V>(list: readonly V[], i?: number, j?: number): V[]\ndeclare function rawget(t: unknown, key: unknown): unknown\ndeclare function rawset<T>(t: T, key: unknown, value: unknown): T\ndeclare function rawequal(a: unknown, b: unknown): boolean\ndeclare function setmetatable<T>(t: T, mt: unknown): T\ndeclare function getmetatable(t: unknown): unknown\ndeclare function newproxy(addMeta?: boolean): unknown\n-- The entry after `key` \u2014 or nil, past the last one.\ndeclare function next<K, V>(t: { [K]: V }, key?: K): [K, V] | nil\n\n-- What `for (const item in source)` walks: `step` is called with the state\n-- and the item before it \u2014 `first` the first time \u2014 until it answers nil.\n-- An array, a table and an iterator function are walked too, so this is only\n-- what a source such as `pairs(t)` hands over.\ntype Iteration<S, T> = [(state: S, previous: T | nil) => T | nil, S, T | nil]\n\n-- `for (const [k, v] in pairs(t))` / `ipairs(t)`: each item is one `[key,\n-- value]` \u2014 a table, as every array is. The analyzer types it from `t` itself\n-- (a record's keys as literals, an array's elements); these declare the\n-- names, and their shape for any other use. Walking a list only reads it, so\n-- a read-only one (`as const`, `readonly T[]`) is walked as well.\ndeclare function pairs<V>(t: readonly V[]): Iteration<readonly V[], [number, V]>\ndeclare function pairs<K, V>(t: { [K]: V }): Iteration<{ [K]: V }, [K, V]>\ndeclare function ipairs<V>(t: readonly V[]): Iteration<readonly V[], [number, V]>\n\ndeclare function collectgarbage(option: \"count\"): number\ndeclare function gcinfo(): number\ndeclare function getfenv(target?: unknown): { [string]: unknown }\ndeclare function setfenv<T>(target: T, env: { [string]: unknown }): T\ndeclare function loadstring(source: string, chunkname?: string): [((...args: unknown[]) => unknown) | nil, string | nil]\n\ndeclare debug: {\n    traceback: (message?: string, level?: number) => string,\n}\n\ndeclare string: {\n    format: (fmt: string, ...args: unknown[]) => string,\n    sub: (s: string, i: number, j?: number) => string,\n    len: (s: string) => number,\n    upper: (s: string) => string,\n    lower: (s: string) => string,\n    rep: (s: string, n: number, sep?: string) => string,\n    reverse: (s: string) => string,\n    -- Where the pattern is, then what it captured \u2014 or nil.\n    find: (s: string, pattern: string, init?: number, plain?: boolean) => [number, number, ...string[]] | nil,\n    -- What it captured (the whole match when there are no captures), as\n    -- JavaScript's `match` answers \u2014 or nil.\n    match: (s: string, pattern: string, init?: number) => [...string[]] | nil,\n    -- Each match's captures (the whole match when there are none), one\n    -- array at a time: `for (const [word] in s:gmatch(\"%a+\"))`.\n    gmatch: (s: string, pattern: string) => () => [string, ...string[]] | nil,\n    -- The new string, as JavaScript's `replace` answers; Luau's count of\n    -- replacements is left behind.\n    gsub: (s: string, pattern: string, repl: unknown, n?: number) => string,\n    -- One code for one position; an array of them for a range.\n    byte: ((s: string, i?: number) => number) & ((s: string, i: number, j: number) => number[]),\n    char: (...args: number[]) => string,\n}\n\ndeclare math: {\n    abs: (x: number) => number,\n    floor: (x: number) => number,\n    ceil: (x: number) => number,\n    fmod: (x: number, y: number) => number,\n    modf: (x: number) => [number, number],\n    sqrt: (x: number) => number,\n    pow: (x: number, y: number) => number,\n    exp: (x: number) => number,\n    log: (x: number, base?: number) => number,\n    log10: (x: number) => number,\n    frexp: (x: number) => [number, number],\n    ldexp: (m: number, e: number) => number,\n    min: (...args: number[]) => number,\n    max: (...args: number[]) => number, \n    sin: (x: number) => number,\n    cos: (x: number) => number,\n    tan: (x: number) => number,\n    asin: (x: number) => number,\n    acos: (x: number) => number,\n    atan: (x: number) => number,\n    atan2: (y: number, x: number) => number,\n    sinh: (x: number) => number,\n    cosh: (x: number) => number,\n    tanh: (x: number) => number,\n    rad: (deg: number) => number,\n    deg: (rad: number) => number,\n    random: (m?: number, n?: number) => number,\n    randomseed: (x: number) => nil,\n    huge: number,\n    pi: number,\n}\n\n\ndeclare table: {\n    -- `insert(t, v)` appends; `insert(t, pos, v)` puts it there.\n    insert: (<T>(t: T[], value: T) => nil) & (<T>(t: T[], pos: number, value: T) => nil),\n    remove: <T>(t: T[], pos?: number) => T | nil,\n    concat: (t: readonly (string | number)[], sep?: string, i?: number, j?: number) => string,\n    sort: <T>(t: T[], compare?: (a: T, b: T) => boolean) => nil,\n    -- Lua 5.1's originals. Deprecated there and gone from 5.2 on, but Luau\n    -- still answers to them, so code being ported still type-checks.\n    getn: <T>(t: readonly T[]) => number,\n    maxn: <T>(t: readonly T[]) => number,\n    foreach: <K, V, R>(t: { [K]: V }, f: (key: K, value: V) => R) => R | nil,\n    foreachi: <V, R>(t: readonly V[], f: (index: number, value: V) => R) => R | nil,\n}\n\ndeclare os: {\n    time: (t?: unknown) => number,\n    clock: () => number,\n    date: (format?: string, time?: number) => unknown,\n    difftime: (a: number, b: number) => number,\n}\n\ndeclare coroutine: {\n    create: (fn: (...args: unknown[]) => unknown) => thread,\n    -- Answers like `pcall`: `{ success, data, error }`, `data` what the\n    -- coroutine yielded or returned.\n    resume: (co: thread, ...args: unknown[]) => PcallResult<unknown>,\n    yield: (...args: unknown[]) => unknown,\n    wrap: (fn: (...args: unknown[]) => unknown) => (...args: unknown[]) => unknown,\n    status: (co: thread) => string,\n    running: () => thread,\n}\n\n-- A string's, an array's and a table's methods \u2014 `text:trim()`,\n-- `names:filter(f)`, `point:keys()` \u2014 are the language's: their metatables\n-- are declared in @tilua/parser's prelude, and the compiler runs them. A\n-- library adds to one with `declare metatable` of the same target, as\n-- `@tilua-types/roblox` gives a string Luau's `split`.\n\n-- The console. Written with `:` \u2014 `console:log(value)` \u2014 and lowered by the\n-- compiler (standard.ts) into runtime/console.luau, not into `print`.\n--\n-- Every line starts with the place that called it: `[src/main:12]: ...`.\n-- `print` and `warn` are left as written; `error` puts `src/main.tilua:12:` in\n-- its message, as Lua does.\n--\n-- `log` expands what it is given the way a browser console does: a table is\n-- printed as its contents, not as an address. A function prints as the type it\n-- was inferred to have *and* the code it was written as, both of which the\n-- compiler passes along, since neither exists once the code is running.\n--\n-- `error` reports in the project's own files: a bundle is one Luau file, so\n-- Luau's own line numbers name a file nobody wrote. It does not raise on the\n-- calling thread \u2014 the error goes to `task.spawn`, so reporting a problem\n-- never becomes one.\ntype Console = {\n    log: (self: Console, ...args: unknown[]) => nil,\n    warn: (self: Console, ...args: unknown[]) => nil,\n    error: (self: Console, ...args: unknown[]) => nil,\n}\n\ndeclare console: Console\n";
 /** The standard library, parsed once. */
 declare function standardLibrary(): Program;
 /** The globals the standard library declares: `print`, `string`, ... */

package/dist/index.js

@@ -94,6 +94,14 @@ function isAlphaNumeric(ch) {
   return isAlpha(ch) || isDigit(ch);
 }
 var KeywordSet = new Set(Keywords);
+var TS_SPELLINGS = [
+  ["!==", "~=", "Operator"],
+  ["===", "==", "Operator"],
+  ["!=", "~=", "Operator"],
+  ["&&", "and", "Keyword"],
+  ["||", "or", "Keyword"],
+  ["!", "not", "Keyword"]
+];
 var OperatorSet = new Set(Operators);
 var SortedSymbols = [...Operators, ...Punctuators].sort((a, b) => b.length - a.length);
 var LexError = class extends Error {
@@ -554,6 +562,15 @@ function tokenize(source, options = {}) {
       tokens.push(readIdentifierOrKeyword());
       continue;
     }
+    const spelled = TS_SPELLINGS.find(([written]) => source.startsWith(written, cursor));
+    if (spelled) {
+      const [written, meant, kind] = spelled;
+      const startLine = line, startColumn = column;
+      fail(`tilua writes '${meant}', not '${written}'`, startLine, startColumn);
+      for (let k = 0; k < written.length; k++) advance();
+      tokens.push(kind === "Keyword" ? { type: "Keyword", value: meant, ...makeBase(startLine, startColumn) } : { type: "Operator", value: meant, ...makeBase(startLine, startColumn) });
+      continue;
+    }
     const symbol = readOperatorOrPunctuator();
     if (symbol) tokens.push(symbol);
   }
@@ -4362,7 +4379,7 @@ declare function xpcall<A extends unknown[], T>(fn: (...args: A) => T, handler:
 declare function select(n: "#", ...args: unknown[]): number
 declare function select<T>(n: number, ...args: T[]): T[]
 -- A copy of the list, or of part of it.
-declare function unpack<V>(list: V[], i?: number, j?: number): V[]
+declare function unpack<V>(list: readonly V[], i?: number, j?: number): V[]
 declare function rawget(t: unknown, key: unknown): unknown
 declare function rawset<T>(t: T, key: unknown, value: unknown): T
 declare function rawequal(a: unknown, b: unknown): boolean
@@ -4381,10 +4398,11 @@ type Iteration<S, T> = [(state: S, previous: T | nil) => T | nil, S, T | nil]
 -- \`for (const [k, v] in pairs(t))\` / \`ipairs(t)\`: each item is one \`[key,
 -- value]\` \u2014 a table, as every array is. The analyzer types it from \`t\` itself
 -- (a record's keys as literals, an array's elements); these declare the
--- names, and their shape for any other use.
-declare function pairs<V>(t: V[]): Iteration<V[], [number, V]>
+-- names, and their shape for any other use. Walking a list only reads it, so
+-- a read-only one (\`as const\`, \`readonly T[]\`) is walked as well.
+declare function pairs<V>(t: readonly V[]): Iteration<readonly V[], [number, V]>
 declare function pairs<K, V>(t: { [K]: V }): Iteration<{ [K]: V }, [K, V]>
-declare function ipairs<V>(t: V[]): Iteration<V[], [number, V]>
+declare function ipairs<V>(t: readonly V[]): Iteration<readonly V[], [number, V]>
 
 declare function collectgarbage(option: "count"): number
 declare function gcinfo(): number
@@ -4458,14 +4476,14 @@ declare table: {
     -- \`insert(t, v)\` appends; \`insert(t, pos, v)\` puts it there.
     insert: (<T>(t: T[], value: T) => nil) & (<T>(t: T[], pos: number, value: T) => nil),
     remove: <T>(t: T[], pos?: number) => T | nil,
-    concat: (t: (string | number)[], sep?: string, i?: number, j?: number) => string,
+    concat: (t: readonly (string | number)[], sep?: string, i?: number, j?: number) => string,
     sort: <T>(t: T[], compare?: (a: T, b: T) => boolean) => nil,
     -- Lua 5.1's originals. Deprecated there and gone from 5.2 on, but Luau
     -- still answers to them, so code being ported still type-checks.
-    getn: <T>(t: T[]) => number,
-    maxn: <T>(t: T[]) => number,
+    getn: <T>(t: readonly T[]) => number,
+    maxn: <T>(t: readonly T[]) => number,
     foreach: <K, V, R>(t: { [K]: V }, f: (key: K, value: V) => R) => R | nil,
-    foreachi: <V, R>(t: V[], f: (index: number, value: V) => R) => R | nil,
+    foreachi: <V, R>(t: readonly V[], f: (index: number, value: V) => R) => R | nil,
 }
 
 declare os: {
@@ -5358,6 +5376,11 @@ declare metatable<T> T[]: {
         concat: <U>(self: readonly T[], ...others: (readonly U[])[]) => (T | U)[],
         slice: (self: readonly T[], start?: number, stop?: number) => T[],
         flat: (self: readonly T[]) => T[],
+        -- JavaScript's, as arrays rather than iterators: \`for (const [i, v] in
+        -- xs:entries())\` walks positions and values, counting from 1.
+        keys: (self: readonly T[]) => number[],
+        values: (self: readonly T[]) => T[],
+        entries: (self: readonly T[]) => [number, T][],
         reverse: (self: T[]) => T[],
         sort: (self: T[], compare?: (a: T, b: T) => boolean) => T[],
         push: (self: T[], ...args: T[]) => number,
@@ -7145,7 +7168,7 @@ function keepsLiterals(paramType) {
   const members = paramType.constraint.kind === "union" ? paramType.constraint.types : [paramType.constraint];
   return members.some((m) => m.kind === "literal" || m.kind === "primitive" && (m.name === "string" || m.name === "number"));
 }
-var CLASS_LINKS = /* @__PURE__ */ new Set(["new", "ClassObject", "ParentClass"]);
+var CLASS_LINKS = /* @__PURE__ */ new Set(["new", "ClassObject", "ParentClass", "name"]);
 var CLASS_RESERVED = /* @__PURE__ */ new Set([
   "new",
   "ClassObject",
@@ -7903,6 +7926,7 @@ var TypeAnalyzer = class {
     });
     type.properties.set("new", construct);
     type.properties.set("ParentClass", { type: parent ?? nilType, optional: false, readonly: true });
+    type.properties.set("name", { type: stmt.name ? literal(stmt.name.name) : stringType, optional: false, readonly: true });
     return type;
   }
   /** The value side of the class `superclass` names when it is not
@@ -8162,6 +8186,9 @@ var TypeAnalyzer = class {
       if (CLASS_RESERVED.has(member.name.name)) {
         report(member.name, `'${member.name.name}' is what the compiler calls part of a class; a member cannot be named that`);
       }
+      if (member.name.name === "name" && !(member.type === "ClassField" && !member.isStatic)) {
+        report(member.name, "'name' is the class's own name, `Dog.name`: a static, a method or an accessor cannot be called that \u2014 an instance field can");
+      }
     }
     const seen = /* @__PURE__ */ new Map();
     for (const member of stmt.members) {
@@ -9002,6 +9029,13 @@ var TypeAnalyzer = class {
       case "array":
       case "tuple":
         return union([numberType, literal("length")]);
+      // A string is not indexed by position in Lua (`s[1]` is nil), so
+      // of its keys only `length` is there.
+      case "primitive":
+        return t.name === "string" ? literal("length") : neverType;
+      case "literal":
+      case "templateLiteral":
+        return t.kind === "templateLiteral" || t.base === "string" ? literal("length") : neverType;
       case "union": {
         const sets = t.types.map((m) => {
           const keys = this.keysOf(m);
@@ -9472,7 +9506,7 @@ var TypeAnalyzer = class {
           this.loops.set(stmt, { walks: "iteration", viaIter: false });
         } else {
           const [item, form] = this.iterationOf(stmt.iterator, sourceType);
-          this.bindPattern(stmt.variable, item, bodyEnv, "widen");
+          this.bindPattern(stmt.variable, item, bodyEnv, stmt.kind === "const" ? "keep" : "widen");
           this.loops.set(stmt, form);
         }
         this.visitBlock(stmt.body, bodyEnv);
@@ -10928,7 +10962,8 @@ var TypeAnalyzer = class {
       const name = source.callee.name;
       const src = this.expand(this.typeOf.get(source.arguments[0]) ?? unknownType);
       const iteration = { walks: "iteration", viaIter: false };
-      if (name === "ipairs") return [tuple([numberType, this.elementType(src, 0)]), iteration];
+      const element = src.kind === "array" ? src.element : src.kind === "tuple" ? union(tupleMembers(src).map((m) => m.kind === "spread" ? this.spreadElement(m.type) ?? unknownType : m)) : void 0;
+      if (name === "ipairs") return [tuple([numberType, element ?? this.elementType(src, 0)]), iteration];
       if (name === "pairs") {
         if (src.kind === "object") {
           return [tuple([
@@ -10936,7 +10971,7 @@ var TypeAnalyzer = class {
             src.indexer?.value ?? union([...src.properties.values()].map((p) => p.type))
           ]), iteration];
         }
-        if (src.kind === "array") return [tuple([numberType, src.element]), iteration];
+        if (element) return [tuple([numberType, element]), iteration];
       }
     }
     const handsOut = (t2, viaIter) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tilua/parser",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "description": "tilua parser for roblox",
   "main": "./dist/index.js",
   "module": "./dist/index.js",