@tilua/compiler 4.0.0 → 5.0.1

package/dist/index.d.cts

@@ -1,5 +1,5 @@
 import * as T from '@tilua/parser';
-import { LoweringPlugin, BuildTarget, TypeAnalysis, ScopeAnalysis, TiluaConfig, ConfigProblem } from '@tilua/parser';
+import { LoweringPlugin, BuildTarget, TypeAnalysis, ScopeAnalysis, OutputMode, TiluaConfig, ConfigProblem } from '@tilua/parser';
 export { LoweringPlugin, MethodCall, MethodLowering } from '@tilua/parser';
 import * as L from 'luau-parser';
 
@@ -88,11 +88,15 @@ interface ModuleContext {
     /** The bundle's name for this module. */
     readonly name: string;
     /** The bundle's name for the module `specifier` imports, or `undefined`
-     *  when there is no such module (reported). */
-    resolve(specifier: string): string | undefined;
+     *  when there is no such module (reported). `dynamic` says an `import()`
+     *  is asking: the module is needed when that runs, not before this one. */
+    resolve(specifier: string, dynamic?: boolean): string | undefined;
     /** The bundle's `require`: an expression that, called with a module's
      *  name, returns its exports table. */
     readonly require: L.Expression;
+    /** What `import("./x")` calls, with the module's name: the bundle's
+     *  wrapper around its `require`. Default: `require` itself. */
+    readonly import?: L.Expression;
     /** Luau reaching the bundle's line map — what a library's runtime reads,
      *  as `__LINES__`, to name the file a frame was written in. */
     readonly lines?: string;
@@ -129,6 +133,9 @@ interface LowerOptions {
      *  lowers what Luau adds to Lua and 5.1 has no syntax for — `a += b`,
      *  `continue`, `if c then a else b` as an expression, `//`. */
     readonly target?: Target;
+    /** The project leaves Lua's standard library out (`"noLib": true`), so
+     *  nothing of it is lowered either. */
+    readonly noLib?: boolean;
 }
 /** `"luau"` is Roblox's Lua. `"lua51"` is stock Lua 5.1, which has none of
  *  Luau's additions — and no `goto` either, so `continue` has to be built out
@@ -189,6 +196,13 @@ interface TiluaConfigJson {
      *  `a += b`, `continue`, `if c then a else b` as an expression, `//`,
      *  digit separators and binary literals. */
     target?: Target;
+    /** How many files the output is. `"single"` (the default) is one file;
+     *  `"chunks"` also writes a file for what only an `import()` reaches,
+     *  loaded when it is first asked for; `"modules"` writes one per module. */
+    output?: OutputMode;
+    /** Leave out Lua's standard library — `print`, `string`, `pcall` — which
+     *  is otherwise there for every file, as JavaScript's is in TypeScript. */
+    noLib?: boolean;
 }
 /** A config file's path, or the config itself. Relative paths — to a config
  *  file, and inside an inline config — resolve from `cwd`. */
@@ -214,6 +228,23 @@ interface BundleOptions {
     readonly typeCheck?: boolean;
     /** Which Lua the output must run on. Overrides the config's `target`. */
     readonly target?: Target;
+    /** How many files to make. Overrides the config's `output`; `"single"`
+     *  without either. */
+    readonly output?: OutputMode;
+    /** What the entry's file is called: `main.luau`. The other files of
+     *  `"chunks"` are named after it (`main_shop.luau`), and every file takes
+     *  its extension. Default: the entry's own name, with `.luau`. */
+    readonly outFile?: string;
+}
+/** One file of the output. */
+interface BundleFile {
+    /** Where it goes, from the folder the output is written to: `main.luau`,
+     *  `src/shop/buy.luau`. Files find each other by these, so they have to be
+     *  written as they are named. */
+    readonly path: string;
+    readonly code: string;
+    /** The modules in it, by name. */
+    readonly modules: string[];
 }
 interface BundleDiagnostic {
     /** Absolute path of the file it is about. */
@@ -227,9 +258,13 @@ interface BundleDiagnostic {
     readonly category: "syntax" | "scope" | "module" | "type" | "config";
 }
 interface BundleResult {
-    /** The bundle, or `undefined` when a module could not be compiled. Type
-     *  errors are reported but do not stop it. */
+    /** The bundle — the entry's file, when there are several — or `undefined`
+     *  when a module could not be compiled. Type errors are reported but do
+     *  not stop it. */
     readonly code?: string;
+    /** Every file of the output, the entry's first. Empty when there is no
+     *  bundle. */
+    readonly files: BundleFile[];
     /** The bundled modules' names, entry first. */
     readonly modules: string[];
     readonly diagnostics: BundleDiagnostic[];
@@ -248,4 +283,4 @@ interface CompileResult {
 }
 declare function compile(source: string, config?: ConfigInput): Promise<CompileResult>;
 
-export { type BundleDiagnostic, type BundleOptions, type BundleResult, type CompileResult, type ConfigInput, type Diagnostic, type LoadedLowering, type LowerDiagnostic, type LowerOptions, type LowerResult, type LoweringProblem, type ModuleContext, type ResolvedConfig, type TiluaConfigJson, bundle, compile, loadLowerings, lower, resolveConfig };
+export { type BundleDiagnostic, type BundleFile, type BundleOptions, type BundleResult, type CompileResult, type ConfigInput, type Diagnostic, type LoadedLowering, type LowerDiagnostic, type LowerOptions, type LowerResult, type LoweringProblem, type ModuleContext, type ResolvedConfig, type TiluaConfigJson, bundle, compile, loadLowerings, lower, resolveConfig };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import * as T from '@tilua/parser';
-import { LoweringPlugin, BuildTarget, TypeAnalysis, ScopeAnalysis, TiluaConfig, ConfigProblem } from '@tilua/parser';
+import { LoweringPlugin, BuildTarget, TypeAnalysis, ScopeAnalysis, OutputMode, TiluaConfig, ConfigProblem } from '@tilua/parser';
 export { LoweringPlugin, MethodCall, MethodLowering } from '@tilua/parser';
 import * as L from 'luau-parser';
 
@@ -88,11 +88,15 @@ interface ModuleContext {
     /** The bundle's name for this module. */
     readonly name: string;
     /** The bundle's name for the module `specifier` imports, or `undefined`
-     *  when there is no such module (reported). */
-    resolve(specifier: string): string | undefined;
+     *  when there is no such module (reported). `dynamic` says an `import()`
+     *  is asking: the module is needed when that runs, not before this one. */
+    resolve(specifier: string, dynamic?: boolean): string | undefined;
     /** The bundle's `require`: an expression that, called with a module's
      *  name, returns its exports table. */
     readonly require: L.Expression;
+    /** What `import("./x")` calls, with the module's name: the bundle's
+     *  wrapper around its `require`. Default: `require` itself. */
+    readonly import?: L.Expression;
     /** Luau reaching the bundle's line map — what a library's runtime reads,
      *  as `__LINES__`, to name the file a frame was written in. */
     readonly lines?: string;
@@ -129,6 +133,9 @@ interface LowerOptions {
      *  lowers what Luau adds to Lua and 5.1 has no syntax for — `a += b`,
      *  `continue`, `if c then a else b` as an expression, `//`. */
     readonly target?: Target;
+    /** The project leaves Lua's standard library out (`"noLib": true`), so
+     *  nothing of it is lowered either. */
+    readonly noLib?: boolean;
 }
 /** `"luau"` is Roblox's Lua. `"lua51"` is stock Lua 5.1, which has none of
  *  Luau's additions — and no `goto` either, so `continue` has to be built out
@@ -189,6 +196,13 @@ interface TiluaConfigJson {
      *  `a += b`, `continue`, `if c then a else b` as an expression, `//`,
      *  digit separators and binary literals. */
     target?: Target;
+    /** How many files the output is. `"single"` (the default) is one file;
+     *  `"chunks"` also writes a file for what only an `import()` reaches,
+     *  loaded when it is first asked for; `"modules"` writes one per module. */
+    output?: OutputMode;
+    /** Leave out Lua's standard library — `print`, `string`, `pcall` — which
+     *  is otherwise there for every file, as JavaScript's is in TypeScript. */
+    noLib?: boolean;
 }
 /** A config file's path, or the config itself. Relative paths — to a config
  *  file, and inside an inline config — resolve from `cwd`. */
@@ -214,6 +228,23 @@ interface BundleOptions {
     readonly typeCheck?: boolean;
     /** Which Lua the output must run on. Overrides the config's `target`. */
     readonly target?: Target;
+    /** How many files to make. Overrides the config's `output`; `"single"`
+     *  without either. */
+    readonly output?: OutputMode;
+    /** What the entry's file is called: `main.luau`. The other files of
+     *  `"chunks"` are named after it (`main_shop.luau`), and every file takes
+     *  its extension. Default: the entry's own name, with `.luau`. */
+    readonly outFile?: string;
+}
+/** One file of the output. */
+interface BundleFile {
+    /** Where it goes, from the folder the output is written to: `main.luau`,
+     *  `src/shop/buy.luau`. Files find each other by these, so they have to be
+     *  written as they are named. */
+    readonly path: string;
+    readonly code: string;
+    /** The modules in it, by name. */
+    readonly modules: string[];
 }
 interface BundleDiagnostic {
     /** Absolute path of the file it is about. */
@@ -227,9 +258,13 @@ interface BundleDiagnostic {
     readonly category: "syntax" | "scope" | "module" | "type" | "config";
 }
 interface BundleResult {
-    /** The bundle, or `undefined` when a module could not be compiled. Type
-     *  errors are reported but do not stop it. */
+    /** The bundle — the entry's file, when there are several — or `undefined`
+     *  when a module could not be compiled. Type errors are reported but do
+     *  not stop it. */
     readonly code?: string;
+    /** Every file of the output, the entry's first. Empty when there is no
+     *  bundle. */
+    readonly files: BundleFile[];
     /** The bundled modules' names, entry first. */
     readonly modules: string[];
     readonly diagnostics: BundleDiagnostic[];
@@ -248,4 +283,4 @@ interface CompileResult {
 }
 declare function compile(source: string, config?: ConfigInput): Promise<CompileResult>;
 
-export { type BundleDiagnostic, type BundleOptions, type BundleResult, type CompileResult, type ConfigInput, type Diagnostic, type LoadedLowering, type LowerDiagnostic, type LowerOptions, type LowerResult, type LoweringProblem, type ModuleContext, type ResolvedConfig, type TiluaConfigJson, bundle, compile, loadLowerings, lower, resolveConfig };
+export { type BundleDiagnostic, type BundleFile, type BundleOptions, type BundleResult, type CompileResult, type ConfigInput, type Diagnostic, type LoadedLowering, type LowerDiagnostic, type LowerOptions, type LowerResult, type LoweringProblem, type ModuleContext, type ResolvedConfig, type TiluaConfigJson, bundle, compile, loadLowerings, lower, resolveConfig };

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   lower,
   program,
   resolveConfig
-} from "./chunk-VZ7XC4BG.js";
+} from "./chunk-Y7QGXLCV.js";
 
 // src/compile.ts
 import { readFileSync } from "fs";
@@ -22,13 +22,14 @@ async function compile(source, config) {
     }
     throw error;
   }
-  const scopes = analyzeScopes(program2);
+  const { config: resolved, problems } = resolveConfig(config, resolve("main.tilua"));
+  const noLib = resolved?.noLib ?? false;
+  const scopes = analyzeScopes(program2, { noLib });
   const diagnostics = scopes.diagnostics.map((d) => ({
     message: d.message,
     line: d.node.line.start,
     column: d.node.column.start
   }));
-  const { config: resolved, problems } = resolveConfig(config, resolve("main.tilua"));
   const libraries = resolved ? resolveTypeLibraries(resolved) : { files: [], lowerings: [], problems: [] };
   const { lowerings, problems: loweringProblems } = await loadLowerings(libraries.lowerings);
   for (const p of [...problems, ...libraries.problems]) {
@@ -37,7 +38,8 @@ async function compile(source, config) {
   for (const p of loweringProblems) diagnostics.push({ message: p.message, line: 1, column: 1 });
   const libs = libraries.files.map((file) => parse(readFileSync(file, "utf8")));
   const lowered = lower(program2, scopes, {
-    types: analyzeTypes(program2, scopes, { libs, diagnostics: false }),
+    types: analyzeTypes(program2, scopes, { libs, noLib, diagnostics: false }),
+    noLib,
     lowerings,
     target: resolved?.target,
     source

package/package.json

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

package/runtime/array.luau

@@ -1,5 +1,13 @@
 local __NAME__ = {}
 
+-- `table.move`, which Lua 5.1 does not have.
+local __NAME___move = table.move or function(from, first, last, at, to)
+	for i = first, last do
+		to[at + i - first] = from[i]
+	end
+	return to
+end
+
 function __NAME__.find(t, test)
 	for i = 1, #t do
 		if test(t[i], i) then
@@ -96,10 +104,10 @@ end
 
 function __NAME__.concat(t, ...)
 	local out = __ARRAY__({})
-	table.move(t, 1, #t, 1, out)
+	__NAME___move(t, 1, #t, 1, out)
 	for i = 1, select("#", ...) do
 		local part = select(i, ...)
-		table.move(part, 1, #part, #out + 1, out)
+		__NAME___move(part, 1, #part, #out + 1, out)
 	end
 	return out
 end
@@ -122,12 +130,36 @@ function __NAME__.slice(t, start, stop)
 end
 
 -- One level, as JavaScript's `flat()` does by default.
+function __NAME__.keys(t)
+	local out = __ARRAY__({})
+	for i = 1, #t do
+		out[i] = i
+	end
+	return out
+end
+
+function __NAME__.values(t)
+	local out = __ARRAY__({})
+	for i = 1, #t do
+		out[i] = t[i]
+	end
+	return out
+end
+
+function __NAME__.entries(t)
+	local out = __ARRAY__({})
+	for i = 1, #t do
+		out[i] = __ARRAY__({ i, t[i] })
+	end
+	return out
+end
+
 function __NAME__.flat(t)
 	local out = __ARRAY__({})
 	for i = 1, #t do
 		local value = t[i]
 		if type(value) == "table" then
-			table.move(value, 1, #value, #out + 1, out)
+			__NAME___move(value, 1, #value, #out + 1, out)
 		else
 			out[#out + 1] = value
 		end
@@ -137,7 +169,7 @@ end
 
 function __NAME__.reverse(t)
 	local n = #t
-	for i = 1, n // 2 do
+	for i = 1, math.floor(n / 2) do
 		t[i], t[n - i + 1] = t[n - i + 1], t[i]
 	end
 	return t

package/runtime/console.luau

@@ -0,0 +1,227 @@
+-- The runtime behind `console:log`, `console:warn`, `console:error`, and the
+-- `error` a project calls.
+--
+-- Every entry takes where it was called from as its first argument, written
+-- by the compiler at the call, and puts it in front of what it prints, the way
+-- a browser console names the line that logged: `[src/shop/buy:12]: ...`. A
+-- bundle is one Luau file, so a line Luau reports names a file nobody wrote;
+-- this is the place the author can open. `error` puts it inside the message
+-- instead, as Lua does: `src/shop/buy.tilua:12: ...`.
+--
+-- A call to `print` or `warn` needs none of this: the compiler passes the
+-- place to the real function as an extra argument. Read as values
+-- (`local p = print`) there is no call site to be given, so the `*Value`
+-- forms work it out from the stack and the bundle's line map instead.
+
+local __NAME__ = {}
+
+local MAX_DEPTH = 4
+local ESCAPES = { ["\n"] = "\\n", ["\r"] = "\\r", ["\t"] = "\\t", ['"'] = '\\"', ["\\"] = "\\\\" }
+
+local function quote(text)
+	return '"' .. text:gsub('[%c"\\]', function(c)
+		return ESCAPES[c] or ("\\%d"):format(c:byte())
+	end) .. '"'
+end
+
+-- A table with 1..n and nothing else prints as a list, as it was written.
+local function isArray(value)
+	local count = 0
+	for key in pairs(value) do
+		if type(key) ~= "number" then
+			return false
+		end
+		count = count + 1
+	end
+	return count == #value
+end
+
+local function isIdentifier(key)
+	return type(key) == "string" and key:match("^[A-Za-z_][A-Za-z0-9_]*$") ~= nil
+end
+
+local render
+
+local function renderTable(value, seen, depth, indent)
+	if seen[value] then
+		return "<cycle>"
+	end
+	if depth > MAX_DEPTH then
+		return "..."
+	end
+	seen[value] = true
+	local inner = indent .. "  "
+	local parts = {}
+	local array = isArray(value)
+	if array then
+		for i = 1, #value do
+			parts[#parts + 1] = inner .. render(value[i], nil, seen, depth + 1, inner)
+		end
+	else
+		local keys = {}
+		for key in pairs(value) do
+			keys[#keys + 1] = key
+		end
+		table.sort(keys, function(a, b)
+			return tostring(a) < tostring(b)
+		end)
+		for _, key in ipairs(keys) do
+			local name = isIdentifier(key) and key or ("[" .. render(key, nil, seen, depth + 1, inner) .. "]")
+			parts[#parts + 1] = inner .. name .. " = " .. render(value[key], nil, seen, depth + 1, inner)
+		end
+	end
+	seen[value] = nil
+	if #parts == 0 then
+		return "{}"
+	end
+	local open = array and "[" or "{"
+	local close = array and "]" or "}"
+	return open .. "\n" .. table.concat(parts, ",\n") .. "\n" .. indent .. close
+end
+
+-- `meta` is what the compiler knew about this value and the runtime cannot:
+-- a function's type, and the code it was written as.
+render = function(value, meta, seen, depth, indent)
+	local kind = type(value)
+	if kind == "string" then
+		return quote(value)
+	end
+	if kind == "number" or kind == "boolean" or kind == "nil" then
+		return tostring(value)
+	end
+	if kind == "function" then
+		if meta == nil then
+			return "function"
+		end
+		if meta[2] == nil or meta[2] == "" then
+			return meta[1]
+		end
+		return meta[1] .. "  " .. meta[2]
+	end
+	if kind == "table" then
+		-- A value with its own `__tostring` (a Roblox Vector3, a class
+		-- instance that says how it reads) is trusted to describe itself.
+		local metatable = getmetatable(value)
+		if type(metatable) == "table" and rawget(metatable, "__tostring") ~= nil then
+			return tostring(value)
+		end
+		return renderTable(value, seen, depth, indent)
+	end
+	return tostring(value)
+end
+
+local function join(meta, count, ...)
+	local parts = {}
+	for i = 1, count do
+		parts[#parts + 1] = render((select(i, ...)), meta ~= nil and meta[i] or nil, {}, 1, "")
+	end
+	return table.concat(parts, " ")
+end
+
+local function prefixed(at, text)
+	if at == nil then
+		return text
+	end
+	return at .. ": " .. text
+end
+
+-- A line of the bundle, as the place in the project that wrote it.
+local lines = __LINES__
+local function place(line)
+	local origin = lines ~= nil and lines[tonumber(line)]
+	if not origin then
+		return nil
+	end
+	return origin[1] .. ":" .. tostring(origin[2])
+end
+
+-- The place of the function `level` frames above the caller of this, or nil.
+local function caller(level)
+	local line
+	if debug.info ~= nil then
+		line = debug.info(level + 1, "l")
+	elseif debug.getinfo ~= nil then
+		local info = debug.getinfo(level + 1, "l")
+		line = info and info.currentline
+	end
+	if line == nil or line < 0 then
+		return nil
+	end
+	return place(line)
+end
+
+-- Luau names the bundle in every frame; the project's files are what the
+-- reader knows. Frames the map has nothing for are dropped: they are this
+-- runtime's own, and the bundle's.
+local function trace(level)
+	local out = {}
+	for frame in debug.traceback("", level + 1):gmatch("[^\n]+") do
+		local line = frame:match(":(%d+)")
+		local at = line ~= nil and place(line) or nil
+		if at ~= nil then
+			local name = frame:match("function ([%w_.:]+)")
+			out[#out + 1] = "    at " .. at .. (name ~= nil and (" (" .. name .. ")") or "")
+		end
+	end
+	return table.concat(out, "\n")
+end
+
+-- Never on the caller's thread: reporting a problem must not become one.
+local detach = (task ~= nil and task.spawn) or function(f)
+	local ok, problem = pcall(f)
+	if not ok then
+		print(problem)
+	end
+end
+
+-- `tag` is how the line starts, `[src/a:12]:`, passed to `print` and `warn`
+-- as an argument of its own so the host joins it the way it joins the rest.
+function __NAME__.log(tag, meta, ...)
+	print(tag, join(meta, select("#", ...), ...))
+end
+
+function __NAME__.warn(tag, meta, ...)
+	local text = join(meta, select("#", ...), ...)
+	if warn ~= nil then
+		warn(tag, text)
+	else
+		print(tag, "[warn]", text)
+	end
+end
+
+function __NAME__.error(tag, meta, ...)
+	local message = tag .. " " .. join(meta, select("#", ...), ...)
+	local where = trace(2)
+	detach(function()
+		error(where ~= "" and (message .. "\n" .. where) or message, 0)
+	end)
+end
+
+-- `error(message, level)`, raised for real — `pcall` still catches it — with
+-- the position already in the project's files. Level 1, the default, is the
+-- call itself, which the compiler wrote down; a higher level is a caller the
+-- compiler could not see, so it is read off the stack. A message that is not
+-- a string, or level 0, carries no position in Lua either.
+function __NAME__.raise(at, message, level)
+	if level == nil then
+		level = 1
+	end
+	if type(message) ~= "string" or level == 0 then
+		error(message, 0)
+	end
+	local where = at
+	if level > 1 then
+		where = caller(level + 1)
+	end
+	error(prefixed(where, message), 0)
+end
+
+function __NAME__.raiseValue(message, level)
+	if level == nil then
+		level = 1
+	end
+	if type(message) ~= "string" or level == 0 then
+		error(message, 0)
+	end
+	error(prefixed(caller(level + 1), message), 0)
+end

package/runtime/result.luau

@@ -0,0 +1,122 @@
+local __NAME__ = {}
+
+-- The globals whose Luau answer is several values, as tilua has them: one
+-- value — an array, or an object. The compiler calls these instead of the
+-- globals they stand for, and reading one of those globals as a value
+-- (`local p = pcall`) gives the function here, so the two never disagree.
+
+-- `pcall`'s `ok, ...` as `{ success, data, error }`. `data` is what the
+-- function returned: one value, since a tilua function returns one.
+local function result(ok, ...)
+	if ok then
+		return { success = true, data = (...) }
+	end
+	return { success = false, error = (...) }
+end
+
+function __NAME__.pcall(f, ...)
+	return result(pcall(f, ...))
+end
+
+function __NAME__.xpcall(f, handler, ...)
+	return result(xpcall(f, handler, ...))
+end
+
+function __NAME__.resume(co, ...)
+	return result(coroutine.resume(co, ...))
+end
+
+-- Several values as an array — or nil, when all there was is nil.
+local function values(...)
+	if select("#", ...) <= 1 and (...) == nil then
+		return nil
+	end
+	return { ... }
+end
+
+function __NAME__.find(s, pattern, init, plain)
+	return values(string.find(s, pattern, init, plain))
+end
+
+function __NAME__.match(s, pattern, init)
+	return values(string.match(s, pattern, init))
+end
+
+function __NAME__.gsub(s, pattern, replacement, n)
+	return (string.gsub(s, pattern, replacement, n))
+end
+
+function __NAME__.byte(s, i, j)
+	if j == nil then
+		return (string.byte(s, i))
+	end
+	return { string.byte(s, i, j) }
+end
+
+function __NAME__.modf(x)
+	return { math.modf(x) }
+end
+
+function __NAME__.frexp(x)
+	return { math.frexp(x) }
+end
+
+function __NAME__.next(t, key)
+	local k, v = next(t, key)
+	if k == nil then
+		return nil
+	end
+	return { k, v }
+end
+
+function __NAME__.select(n, ...)
+	if n == "#" then
+		return select("#", ...)
+	end
+	return { select(n, ...) }
+end
+
+function __NAME__.unpack(list, i, j)
+	return { (table.unpack or unpack)(list, i or 1, j or #list) }
+end
+
+-- `pairs(t)` and `ipairs(t)` as an iteration — `{ step, state, first }`,
+-- which a loop walks with. Each step answers one `{ key, value }`, and is
+-- handed the one before it.
+local function pairsStep(t, previous)
+	local k, v = next(t, previous ~= nil and previous[1] or nil)
+	if k == nil then
+		return nil
+	end
+	return { k, v }
+end
+
+function __NAME__.pairs(t)
+	return { pairsStep, t, nil }
+end
+
+local function ipairsStep(t, previous)
+	local i = (previous ~= nil and previous[1] or 0) + 1
+	local v = t[i]
+	if v == nil then
+		return nil
+	end
+	return { i, v }
+end
+
+function __NAME__.ipairs(t)
+	return { ipairsStep, t, nil }
+end
+
+-- An iterator function: each call is one match's captures, as an array.
+function __NAME__.gmatch(s, pattern)
+	local step = string.gmatch(s, pattern)
+	return function()
+		return values(step())
+	end
+end
+
+function __NAME__.loadstring(source, chunkname)
+	local f, message = loadstring(source, chunkname)
+	return { f, message }
+end