storm-lua-minify 0.2.0 → 0.3.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 Nona Takahara, Mathias Bynens
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 Nona Takahara, Mathias Bynens
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,37 +1,79 @@
-# storm-lua-minify
-
-このプログラムは [mathiasbynens/luamin](https://github.com/mathiasbynens/luamin) をベースにした Stormworks: Build and Rescue 向けのLua minifierです。
-
-Stormworks: Build and Rescue 以外の用途にも使用可能です。
-
-# 使い方
-
-```
-npm i storm-lua-minify
-
-npx storm-lua-minify script.lua
-```
-
-- `-m`オプションを付加すると、モジュールの挙動をLuaの実際の挙動に近づけます
-
-# テスト
-
-```
-npm ci
-npm run build
-npm test
-```
-
-# Lint / Format
-
-```
-npm run lint          # ESLint
-npm run format:check  # Prettierのフォーマットチェック
-npm run format        # Prettierでフォーマット
-```
-
-`test/` 以下にスナップショット・ラウンドトリップパース・識別子衝突検知のテストがあります。
-既知バグ（#11, #12 など）の再現ケースは `test.todo` として登録されており、`npm test` は成功しますが、
-修正が入るまではそのテスト自体は失敗した状態のまま todo 扱いになります。
-
-スナップショットを更新する場合は `UPDATE_SNAPSHOTS=1 npm test` を実行してください。
+# storm-lua-minify
+
+このプログラムは [mathiasbynens/luamin](https://github.com/mathiasbynens/luamin) をベースにした Stormworks: Build and Rescue 向けのLua minifierです。
+
+Stormworks: Build and Rescue 以外の用途にも使用可能です。
+
+# 使い方
+
+```
+npm i storm-lua-minify
+
+npx storm-lua-minify script.lua
+```
+
+- `-m`オプションを付加すると、モジュールの挙動をLuaの実際の挙動に近づけます
+
+# Source Map
+
+このツールは、ミニファイ後のコードと合わせて [Source Map](https://tc39.es/source-map/) (`.lua.map`) を出力します。
+
+## sourceMappingURLアノテーションの出力形式
+
+出力される `.min.lua` の末尾に付く `sourceMappingURL` アノテーションの書式は、3種類から選べます。
+
+| オプション                         | 書式                                        | 特徴                                                                                                                                                       |
+| ---------------------------------- | ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| （既定）                           | 複数行の `--[[`〜`]]` ブロックコメント      | 過去のバージョンと同じ出力。既存ツールとの互換性を優先する場合はこのまま使う                                                                               |
+| `--single-line-source-mapping-url` | 単一行の `--` ラインコメント                | 有効なLuaのまま、Source Map仕様が定める「アノテーションは生成コードの最終行に置く」という規則を満たす                                                      |
+| `--strict-source-mapping-url`      | Luaコメントで包まないマーカー文字列そのまま | 規則を厳密に満たすが、出力ファイルの最終行は有効なLua文ではなくなる（Lua文法上、`//`から始まる行をコメント化なしに構文解析可能にする方法は存在しないため） |
+
+「最終行に置く」規則を厳密な前提とするツール（生成コードの末尾だけを見て `sourceMappingURL` を解決する実装など）と組み合わせる場合は、`--single-line-source-mapping-url` を試してください。
+
+## sourcesContent
+
+`.lua.map` の `sourcesContent` には、エントリファイルおよび `require`/`dofile` で参照される全モジュールの元テキストがそのまま埋め込まれます。ビューア側で元の `.lua` ファイルに個別にアクセスできなくても、Source Mapファイル単体で元コードを参照できます。
+
+## キーワードトークンのマッピング
+
+識別子・リテラル・式などASTノードに対応する出力は、それぞれ元ソース上の対応する位置に正確にマッピングされます。加えて、`then`/`elseif`/`else`/`end`/`do`/`until` といった、AST上では文・式の境界としてしか位置を持たないキーワードについても、それぞれが実際に出現する位置に個別にマッピングされます（例: `if`〜`then`〜`end` の `then` と `end` は、`if` とは別の、それぞれ自身の出現位置を持ちます）。トークン単位で対応関係を表示するビューアと組み合わせる際は、この粒度でのマッピングが利用されます。
+
+## 識別子短縮関連のオプション
+
+既定では以下がすべて有効です。デバッグ用途や意図しない出力になった場合は個別に無効化できます。
+
+- `--no-rename`: すべての識別子短縮を無効にします
+- `--no-merge-locals`: 連続する`local`変数宣言のまとめ上げを無効にします
+- `--no-global-rename`: 代入されている（＝スクリプト内部でのみ使われている）グローバル識別子の短縮を無効にします
+- `--no-global-alias`: 短縮できない外部グローバル識別子（`screen`など、代入されず参照のみされるもの）を、頻出する場合にローカル変数へ代入して短縮する最適化を無効にします
+- `--reserved-globals-config <path>`: `{"neverRenameGlobals": ["name", ...]}`形式のJSONファイルを指定し、**代入されていても常にリネームしないグローバル名**を列挙します
+
+### ⚠️ `--reserved-globals-config` について（重要）
+
+`--no-global-rename`が有効な場合、このツールは「プログラム中のどこかで代入されているグローバル名」を自動的に内部専用とみなしてリネームします。これは通常のスクリプト内部の状態変数には安全ですが、**実行環境（エンジンなど）が特定の名前のグローバル関数・変数を探して呼び出す規約がある場合、その名前を誤ってリネームしてしまうと、静かに（エラーなく）呼び出されなくなるバグになります**。
+
+そのような規約（例: Stormworksのマイクロコントローラーでエンジン側が呼び出す特定名のコールバック関数など）が対象のスクリプトにある場合は、必ず`--reserved-globals-config`でその名前を保護対象として指定してください。規約を把握していない場合は、安全のため`--no-global-rename`で本機能自体を無効にすることを推奨します。
+
+# 開発・テスト
+
+開発はpnpmに変更になっています（v0.3.0リリース時点より）
+
+```
+pnpm ci
+pnpm run build
+pnpm test
+```
+
+# Lint / Format
+
+```
+pnpm run lint          # ESLint
+pnpm run format:check  # Prettierのフォーマットチェック
+pnpm run format        # Prettierでフォーマット
+```
+
+`test/` 以下にスナップショット・ラウンドトリップパース・識別子衝突検知のテストがあります。
+既知バグ（#11, #12 など）の再現ケースは `test.todo` として登録されており、`npm test` は成功しますが、
+修正が入るまではそのテスト自体は失敗した状態のまま todo 扱いになります。
+
+スナップショットを更新する場合は `UPDATE_SNAPSHOTS=1 npm test` を実行してください。

package/dist/ast2lua.js

@@ -6,6 +6,8 @@ exports.MinifyFile = exports.IDENTIFIER_PARTS = void 0;
 exports.isKeyword = isKeyword;
 const source_map_1 = require("source-map");
 const linker_1 = require("./linker");
+const keywordLocator_1 = require("./keywordLocator");
+const transform_1 = require("./transform");
 const PRECEDENCE = {
     or: 1,
     and: 2,
@@ -269,6 +271,47 @@ class MinifyFile {
         // ファイル名（Linkパスで解決済み）なので、ここで出力するノードの由来ファイルとして正しい。
         return new source_map_1.SourceNode(line == undefined ? null : line, column == undefined ? null : column, this.fileName, chuncks, name);
     }
+    _keywordLocator;
+    /**
+     * luaparseのASTはキーワード単体の位置を持たないため、`then`/`do`/`until`の
+     * ような「文・式の間に挟まるキーワード」の正確な位置は、モジュールの
+     * ソースを再トークン化して求める（#14）。初回アクセス時に1回だけ構築する。
+     */
+    keywordLocator() {
+        if (!this._keywordLocator) {
+            const sourceText = this.minifier.moduleSourceText.get(this.moduleName);
+            if (sourceText == undefined) {
+                throw new Error(this.moduleName + " is not found");
+            }
+            this._keywordLocator = new keywordLocator_1.KeywordLocator(sourceText, this.minifier.luaParseSettings);
+        }
+        return this._keywordLocator;
+    }
+    /**
+     * `anchor`ノードの直後（`anchor.loc.end`以降）で最初に現れる`value`という
+     * 値のキーワードトークンを探し、その位置を持つ`SourceNode`を返す。
+     * `anchor`は「探しているキーワードの直前に必ず存在する、既に位置が分かって
+     * いるノード」（例: `then`の場合は条件式）を渡す。ASTの入れ子構造上、
+     * その直前ノードの`loc.end`以降を走査すれば、ネストした同名キーワード
+     * （入れ子の`if...then`等）を誤って拾うことはない。
+     */
+    keywordAfter(anchor, value) {
+        return this.keywordFrom(anchor.loc?.end, value);
+    }
+    keywordFrom(from, value) {
+        const pos = from ? this.keywordLocator().findFrom(from, value) : undefined;
+        return new source_map_1.SourceNode(pos?.line ?? null, pos?.column ?? null, this.fileName, value);
+    }
+    /**
+     * `if`/`while`/`do`/`for`/`function`を締める`end`キーワードの位置を返す。
+     * これらの文は必ず`end`で終わり、末尾に余計な内容が続かないため、
+     * 文全体の`loc.end`（luaparseが既に計算済み）から`end`の文字数(3)を
+     * 引くだけで、再トークン化なしに正確な位置を求められる。
+     */
+    endKeyword(node) {
+        const end = node.loc?.end;
+        return new source_map_1.SourceNode(end?.line ?? null, end == undefined ? null : end.column - 3, this.fileName, "end");
+    }
     formatStatementList(body) {
         const result = this.sourceNodeHelper(undefined, []);
         wrapArray(body).forEach((statement) => {
@@ -380,12 +423,12 @@ class MinifyFile {
                 if (clause.type == "IfClause") {
                     addWithSeparator(clauseMap, "if");
                     addWithSeparator(clauseMap, this.formatExpression(clause.condition));
-                    addWithSeparator(clauseMap, "then");
+                    addWithSeparator(clauseMap, this.keywordAfter(clause.condition, "then"));
                 }
                 else if (clause.type == "ElseifClause") {
                     addWithSeparator(clauseMap, "elseif");
                     addWithSeparator(clauseMap, this.formatExpression(clause.condition));
-                    addWithSeparator(clauseMap, "then");
+                    addWithSeparator(clauseMap, this.keywordAfter(clause.condition, "then"));
                 }
                 else {
                     addWithSeparator(clauseMap, "else");
@@ -393,21 +436,21 @@ class MinifyFile {
                 addWithSeparator(clauseMap, this.formatStatementList(clause.body));
                 addWithSeparator(result, clauseMap);
             });
-            addWithSeparator(result, "end");
+            addWithSeparator(result, this.endKeyword(statement));
             return result;
         }
         else if (statement.type == "WhileStatement") {
             const result = this.sourceNodeHelper(statement, "while");
             addWithSeparator(result, this.formatExpression(statement.condition));
-            addWithSeparator(result, "do");
+            addWithSeparator(result, this.keywordAfter(statement.condition, "do"));
             addWithSeparator(result, this.formatStatementList(statement.body));
-            addWithSeparator(result, "end");
+            addWithSeparator(result, this.endKeyword(statement));
             return result;
         }
         else if (statement.type == "DoStatement") {
             const result = this.sourceNodeHelper(statement, "do");
             addWithSeparator(result, this.formatStatementList(statement.body));
-            addWithSeparator(result, "end");
+            addWithSeparator(result, this.endKeyword(statement));
             return result;
         }
         else if (statement.type == "ReturnStatement") {
@@ -426,7 +469,13 @@ class MinifyFile {
         else if (statement.type == "RepeatStatement") {
             const result = this.sourceNodeHelper(statement, "repeat");
             addWithSeparator(result, this.formatStatementList(statement.body));
-            addWithSeparator(result, "until");
+            // body内の最後の文があればその直後、無ければ`repeat`キーワード自身の
+            // 開始位置から`until`を探す（bodyが空でも、その手前には`repeat`しか
+            // 存在しないため安全に検索できる）。
+            const untilAnchor = statement.body.length
+                ? statement.body[statement.body.length - 1].loc?.end
+                : statement.loc?.start;
+            addWithSeparator(result, this.keywordFrom(untilAnchor, "until"));
             addWithSeparator(result, this.formatExpression(statement.condition));
             return result;
         }
@@ -451,7 +500,7 @@ class MinifyFile {
             }
             addWithSeparator(result, ")");
             addWithSeparator(result, this.formatStatementList(statement.body));
-            addWithSeparator(result, "end");
+            addWithSeparator(result, this.endKeyword(statement));
             return result;
         }
         else if (statement.type == "ForGenericStatement") {
@@ -466,9 +515,9 @@ class MinifyFile {
             addWithSeparator(result, variables.slice(0, -1));
             addWithSeparator(result, "in");
             addWithSeparator(result, iterators.slice(0, -1));
-            addWithSeparator(result, "do");
+            addWithSeparator(result, this.keywordAfter(statement.iterators[statement.iterators.length - 1], "do"));
             addWithSeparator(result, this.formatStatementList(statement.body));
-            addWithSeparator(result, "end");
+            addWithSeparator(result, this.endKeyword(statement));
             return result;
         }
         else if (statement.type == "ForNumericStatement") {
@@ -483,9 +532,9 @@ class MinifyFile {
                 addWithSeparator(result, ",");
                 addWithSeparator(result, this.formatExpression(statement.step));
             }
-            addWithSeparator(result, "do");
+            addWithSeparator(result, this.keywordAfter(statement.step ?? statement.end, "do"));
             addWithSeparator(result, this.formatStatementList(statement.body));
-            addWithSeparator(result, "end");
+            addWithSeparator(result, this.endKeyword(statement));
             return result;
         }
         else if (statement.type == "LabelStatement") {
@@ -663,7 +712,7 @@ class MinifyFile {
             result.add(")");
             const body = this.formatStatementList(expression.body);
             addWithSeparator(result, body);
-            addWithSeparator(result, "end");
+            addWithSeparator(result, this.endKeyword(expression));
             return result;
         }
         else if (expression.type == "TableConstructorExpression") {
@@ -776,7 +825,11 @@ class MinifyFile {
         const renamed = this.minifier
             .getRenameResult(this.moduleName)
             .nameOf(nameItem);
-        return this.sourceNodeHelper(nameItem, renamed ?? nameItem.name, nameItem.name);
+        // #8bのエイリアス化はノードの`.name`自体を書き換えるため、loc（元のソース上の
+        // 位置）はそのままでもnameItem.nameはもう元の識別子名ではない。Source Mapの
+        // namesフィールドには常に「元のソースで書かれていた名前」を載せる必要がある。
+        const originalName = (0, transform_1.originalNameOf)(nameItem) ?? nameItem.name;
+        return this.sourceNodeHelper(nameItem, renamed ?? nameItem.name, originalName);
     }
 }
 exports.MinifyFile = MinifyFile;

package/dist/cli.js

@@ -11,10 +11,14 @@ const minifier_1 = require("./minifier");
 const output_1 = require("./output");
 const program = new commander_1.Command();
 program
-    .version("0.1.3")
+    .version("0.3.0")
     .description("A Lua minifier also outputs source map")
     .option("-m, --module-like-lua", "require・dofileの動作を実際のLuaに近づけます")
     .option("--no-rename", "識別子の短縮(リネーム)を無効にします（デバッグ用途）")
+    .option("--no-global-rename", "内部でのみ使用するグローバル識別子の短縮を無効にします（デバッグ用途）")
+    .option("--no-merge-locals", "連続するローカル変数宣言のまとめ上げを無効にします（デバッグ用途）")
+    .option("--no-global-alias", "外部グローバル識別子（リネームできないもの）のローカル代入短縮を無効にします（デバッグ用途）")
+    .option("--reserved-globals-config <path>", '代入されていても短縮しないグローバル名を列挙したJSON設定ファイルのパス（{"neverRenameGlobals":["onTick",...]}形式）。エンジン側のコールバック規約名など、常に元の名前のまま残す必要がある識別子を指定します')
     .option("--single-line-source-mapping-url", "sourceMappingURLアノテーションを単一行の--コメントで出力します（Source Map仕様の「最終行」ルールに従いますが、既定の複数行ブロックコメント形式を前提とするツールとは組み合わせられません）")
     .option("--strict-source-mapping-url", "sourceMappingURLアノテーションをLuaコメントで一切包まず、Source Map仕様のマーカー文字列(//# sourceMappingURL=...)そのままを出力します。Luaの文法上この形式と有効なLuaコードは両立できないため、出力ファイルの最終行は有効なLua文ではなくなります");
 program.parse(process.argv);
@@ -25,7 +29,29 @@ const luaparseSetting = {
     ranges: true,
     scope: true,
 };
-const { singleLineSourceMappingUrl, strictSourceMappingUrl, ...mode } = program.opts();
+function isReservedGlobalsConfig(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (Array.isArray(candidate.neverRenameGlobals) &&
+        candidate.neverRenameGlobals.every((name) => typeof name === "string"));
+}
+function loadNeverRenameGlobals(configPath) {
+    if (!fs_1.default.existsSync(configPath)) {
+        throw new Error("Reserved globals config not found: " + configPath);
+    }
+    const parsed = JSON.parse(fs_1.default.readFileSync(configPath).toString());
+    if (!isReservedGlobalsConfig(parsed)) {
+        throw new Error(configPath +
+            ' must be a JSON object of the form {"neverRenameGlobals": ["name", ...]}');
+    }
+    return new Set(parsed.neverRenameGlobals);
+}
+const { singleLineSourceMappingUrl, strictSourceMappingUrl, reservedGlobalsConfig, ...mode } = program.opts();
+if (reservedGlobalsConfig) {
+    mode.neverRenameGlobals = loadNeverRenameGlobals(reservedGlobalsConfig);
+}
 // 既定は旧バージョンと互換の複数行ブロックコメント("legacy")。
 // --strict-source-mapping-url > --single-line-source-mapping-url の優先順で上書きする。
 const sourceMappingUrlStyle = strictSourceMappingUrl

package/dist/globalRename.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyAndRenameGlobals = classifyAndRenameGlobals;
+const renamer_1 = require("./renamer");
+const linker_1 = require("./linker");
+function classifyAndRenameGlobals(moduleResolve, neverRename, reserved) {
+    const everWritten = new Set();
+    const totalReferenceCount = new Map();
+    moduleResolve.forEach((resolved) => {
+        resolved.globals.forEach((binding) => {
+            if (binding.writes.length > 0) {
+                everWritten.add(binding.name);
+            }
+            totalReferenceCount.set(binding.name, (totalReferenceCount.get(binding.name) ?? 0) +
+                binding.references.length);
+        });
+    });
+    // require/dofileはPrintパスが名前文字列で再検出するため、通常は代入対象に
+    // ならないが（そのため既にeverWrittenに入らない）、ユーザーコードが
+    // `require = ...`のように再代入する非現実的なケースへの防御として明示的にも除外する。
+    const qualifying = [...everWritten].filter((name) => !neverRename.has(name) && !linker_1.RESERVED_MODULE_FUNCTION_NAMES.has(name));
+    const orderedNames = qualifying.sort((a, b) => (totalReferenceCount.get(b) ?? 0) - (totalReferenceCount.get(a) ?? 0));
+    const usedShortNames = new Set(reserved);
+    const globalRenames = new Map();
+    let counter = 0;
+    orderedNames.forEach((name) => {
+        let candidate;
+        do {
+            candidate = (0, renamer_1.generateCandidate)(counter++);
+        } while (!(0, renamer_1.isAvailable)(candidate, usedShortNames));
+        usedShortNames.add(candidate);
+        globalRenames.set(name, candidate);
+    });
+    return globalRenames;
+}

package/dist/keywordLocator.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeywordLocator = void 0;
+const luaparse_1 = __importDefault(require("luaparse"));
+// luaparseの型定義(@types/luaparse)には`tokenTypes`が含まれないため、
+// 実行時の値を直接参照する。luaparse 0.3.1のソース上の定義は
+// `var EOF = 1, StringLiteral = 2, Keyword = 4, ...`。
+const tokenTypes = luaparse_1.default.tokenTypes;
+function comparePosition(a, b) {
+    return a.line !== b.line ? a.line - b.line : a.column - b.column;
+}
+/**
+ * luaparseのASTは文・式の境界にしか`loc`を持たず、`then`/`do`/`until`のような
+ * キーワード単体の出現位置は保持しない。このクラスはluaparseの低レベル
+ * 再トークン化API（`parse(code, {wait: true, ...})` + `lex()`）でモジュールの
+ * ソースを再走査し、キーワードトークンの正確な位置を検索できるようにする（#14）。
+ */
+class KeywordLocator {
+    tokens;
+    constructor(sourceText, luaParseSettings) {
+        const parser = luaparse_1.default.parse(sourceText, {
+            ...luaParseSettings,
+            wait: true,
+        });
+        const tokens = [];
+        for (;;) {
+            const token = parser.lex();
+            if (token.type === tokenTypes.EOF) {
+                break;
+            }
+            if (token.type === tokenTypes.Keyword) {
+                tokens.push({
+                    value: token.value,
+                    line: token.line,
+                    column: token.range[0] - token.lineStart,
+                });
+            }
+        }
+        this.tokens = tokens;
+    }
+    /**
+     * `from`（含む）以降で最初に現れる、値が`value`と一致するキーワードトークンの
+     * 開始位置を返す。見つからない場合はundefined。
+     */
+    findFrom(from, value) {
+        let lo = 0;
+        let hi = this.tokens.length;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (comparePosition(this.tokens[mid], from) < 0) {
+                lo = mid + 1;
+            }
+            else {
+                hi = mid;
+            }
+        }
+        for (let i = lo; i < this.tokens.length; i++) {
+            if (this.tokens[i].value === value) {
+                return { line: this.tokens[i].line, column: this.tokens[i].column };
+            }
+        }
+        return undefined;
+    }
+}
+exports.KeywordLocator = KeywordLocator;

package/dist/linker.js

@@ -1,7 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.RESERVED_MODULE_FUNCTION_NAMES = void 0;
 exports.staticStringArgument = staticStringArgument;
 exports.findModuleReferences = findModuleReferences;
+// require/dofileは、Linkパス（このファイルのfindModuleReferences）だけでなく
+// Printパス（ast2lua.tsのmatchModuleCallExpression、minifier.tsの
+// buildRequireWrapper/collectRequireTargets）でも、この2つの名前文字列を
+// 手がかりに呼び出しを再検出している。そのため、識別子リネーム系のパス
+// （#8a: globalRename.ts、#8b: transform.tsのinsertGlobalAliases）は、
+// これらの名前を書き換え候補から常に除外しなければならない。書き換えると
+// Printパスがrequire/dofile呼び出しを検出できなくなり、モジュール解決が
+// 静かに壊れる（ディスパッチテーブルの生成漏れ等）。
+exports.RESERVED_MODULE_FUNCTION_NAMES = new Set([
+    "require",
+    "dofile",
+]);
 /**
  * Chunk配下を型を問わず再帰的に走査するジェネリックウォーカー。
  * printerとは独立に、AST全体からrequire/dofile呼び出しを見つけ出すために使う（#18）。

package/dist/minifier.js

@@ -12,6 +12,8 @@ const ast2lua_1 = require("./ast2lua");
 const linker_1 = require("./linker");
 const resolver_1 = require("./resolver");
 const renamer_1 = require("./renamer");
+const globalRename_1 = require("./globalRename");
+const transform_1 = require("./transform");
 const NO_RENAME = {
     nameOf: () => undefined,
     usedNames: new Set(),
@@ -31,6 +33,8 @@ class Minifier {
     moduleResolve = new Map();
     // モジュールごとのRenameパスの結果（初回アクセス時に計算しキャッシュする）
     renameCache = new Map();
+    // #8a: プログラム全体を横断して決定された「内部グローバル名 -> 短縮名」の対応
+    globalRenames = new Map();
     constructor(entryFilePath, luaParseSettings, mode) {
         this.identifiersInUse = new Set();
         this.moduleSourceText = new Map();
@@ -44,6 +48,8 @@ class Minifier {
     }
     parse() {
         this.link();
+        this.computeGlobalRenames();
+        this.transformAll();
         this.renameAll();
         const parts = [];
         const entryComments = this.moduleAST.get(this.entryModule)?.comments;
@@ -122,11 +128,79 @@ class Minifier {
             if (!resolved) {
                 throw new Error(moduleName + " is not found");
             }
-            const result = (0, renamer_1.assignRenames)(resolved, this.identifiersInUse);
+            const result = (0, renamer_1.assignRenames)(resolved, this.identifiersInUse, this.globalRenames);
             this.renameCache.set(moduleName, result);
             result.usedNames.forEach((name) => this.identifiersInUse.add(name));
         });
     }
+    /**
+     * Transformパス（#8b, #9）: モジュールごとにASTレベルの最適化を適用する。
+     * computeGlobalRenamesの後・renameAllの前に実行する必要がある（renameは
+     * このパスが確定させた最終的な文構造を前提に短縮名を割り当てるため）。
+     *
+     * 実行順序は 8b（エイリアス挿入）→ #9（local宣言のまとめ上げ）。
+     * 8bが挿入する複数の1変数1式local文は、#9のまとめ上げ対象としてそのまま
+     * 束ねられるため、8bを先に行うことで両者の効果が重なる。
+     *
+     * 8bは新しい識別子ノード（エイリアスの宣言と、書き換えられた参照）を生成する。
+     * これらのノードは元のResolveパス結果には存在しないため、#9のハザード1判定
+     * （「候補文がグループ内で宣言済みの変数を参照していないか」）が正しく働くには、
+     * 8bの直後・#9の直前でResolveパスを再実行しておく必要がある。この順序を
+     * 誤ると、8bがrequire等の頻出グローバルをエイリアス化した際に、そのエイリアス
+     * 宣言自体と「エイリアス経由で呼び出す側」の文を#9が誤って1つのlocal文に
+     * まとめてしまい（エイリアス変数がまだ束縛される前のスコープで参照される形に
+     * なり）、意味が壊れる（要修正が発覚した実例）。
+     */
+    transformAll() {
+        // globalRenames.keys()は8aが実際にリネームした（=代入もされていた）名前のみ。
+        // neverRenameGlobalsは代入されていない名前にも及ぶ保護指定なので、8bのエイリアス化
+        // が誤ってそれらを書き換えてしまわないよう、必ず両方をあわせてexcludeNamesに渡す。
+        const excludeGlobalNames = new Set([
+            ...this.globalRenames.keys(),
+            ...(this.mode.neverRenameGlobals ?? []),
+        ]);
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            let resolved = this.moduleResolve.get(moduleName);
+            if (!ast || !resolved) {
+                throw new Error(moduleName + " is not found");
+            }
+            if (this.mode.rename !== false && this.mode.globalAlias !== false) {
+                (0, transform_1.insertGlobalAliases)(ast, resolved, {
+                    excludeNames: excludeGlobalNames,
+                });
+                resolved = (0, resolver_1.resolveScopes)(ast);
+            }
+            if (this.mode.mergeLocals !== false) {
+                (0, transform_1.mergeLocalDeclarations)(ast, resolved, {
+                    preserveRequireSplice: !this.mode.moduleLikeLua,
+                });
+            }
+            this.moduleResolve.set(moduleName, resolved);
+        });
+    }
+    /**
+     * #8aのGlobal Renameパス: リンクされた全モジュールを横断して、代入されている
+     * グローバル（neverRenameGlobalsに含まれるものを除く）に短縮名を割り当てる。
+     * グローバルは1つのランタイム束縛をモジュール間で共有するため、この判定・採番は
+     * renameAll（モジュールごとに独立して行うローカルのリネーム）より前に、
+     * 一度だけ行う必要がある。
+     *
+     * 選ばれた短縮名はrenameAllの前にidentifiersInUseへ予約し、元の長い名前の予約は
+     * 解除する（もう出力に現れないため）。順序を誤ると、
+     * ローカルの短縮名がグローバルの新しい短縮名と衝突しうる。
+     */
+    computeGlobalRenames() {
+        if (this.mode.rename === false || this.mode.globalRename === false) {
+            return;
+        }
+        const neverRename = this.mode.neverRenameGlobals ?? new Set();
+        this.globalRenames = (0, globalRename_1.classifyAndRenameGlobals)(this.moduleResolve, neverRename, this.identifiersInUse);
+        this.globalRenames.forEach((shortName, originalName) => {
+            this.identifiersInUse.add(shortName);
+            this.identifiersInUse.delete(originalName);
+        });
+    }
     printModule(moduleName) {
         const ast = this.moduleAST.get(moduleName);
         const fileName = this.moduleNameAndFileName.get(moduleName);

package/dist/renamer.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAvailable = isAvailable;
+exports.generateCandidate = generateCandidate;
 exports.assignRenames = assignRenames;
 const ast2lua_1 = require("./ast2lua");
 function isAvailable(id, reserved) {
@@ -42,7 +44,11 @@ function assignSlots(scope, active) {
     });
     return slotOf;
 }
-function assignRenames(resolveResult, reserved) {
+function assignRenames(resolveResult, reserved, 
+// #8a: プログラム全体を横断して決定されたグローバル識別子の短縮名。
+// 全モジュールに対して同じマップを渡すことで、モジュールをまたいで
+// 共有される1つのランタイム束縛に一貫した短縮名を割り当てられる。
+globalRenames) {
     const slotOf = assignSlots(resolveResult.chunkScope, new Set());
     // スロットの通算参照回数（宣言自体も1回として数える）を集計する。
     const weightOfSlot = new Map();
@@ -80,7 +86,15 @@ function assignRenames(resolveResult, reserved) {
                 return undefined;
             }
             const symbol = resolveResult.symbolOf(identifier);
-            return symbol ? nameOfSymbol.get(symbol) : undefined;
+            if (symbol) {
+                return nameOfSymbol.get(symbol);
+            }
+            // フィールド名（`.foo`）はここに来るが、これらはisGlobalReferenceが
+            // falseになるため名前文字列がたまたま一致しても誤ってリネームしない。
+            if (globalRenames && resolveResult.isGlobalReference(identifier)) {
+                return globalRenames.get(identifier.name);
+            }
+            return undefined;
         },
         usedNames: new Set(nameOfSlot.values()),
     };