storm-lua-minify 0.1.3 → 0.3.0

package/README.md

@@ -13,3 +13,67 @@ 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

@@ -2,8 +2,12 @@
 // based on "luamin": Copyright Mathias Bynens <https://mathiasbynens.be/>
 // SPDX-License-Identifier: MIT
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MinifyFile = void 0;
+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,
@@ -13,28 +17,25 @@ const PRECEDENCE = {
     ">=": 3,
     "~=": 3,
     "==": 3,
-    "..": 5,
-    "+": 6,
-    "-": 6, // binary -
-    "*": 7,
-    "/": 7,
-    "%": 7,
-    unarynot: 8,
-    "unary#": 8,
-    "unary-": 8, // unary -
-    "^": 10,
+    "|": 4,
+    "~": 5, // binary ~ (bxor)
+    "&": 6,
+    "<<": 7,
+    ">>": 7,
+    "..": 9,
+    "+": 10,
+    "-": 10, // binary -
+    "*": 11,
+    "/": 11,
+    "//": 11,
+    "%": 11,
+    unarynot: 12,
+    "unary#": 12,
+    "unary-": 12, // unary -
+    "unary~": 12, // unary ~ (bnot)
+    "^": 14,
 };
-const IDENTIFIER_PARTS = [
-    "0",
-    "1",
-    "2",
-    "3",
-    "4",
-    "5",
-    "6",
-    "7",
-    "8",
-    "9",
+exports.IDENTIFIER_PARTS = [
     "a",
     "b",
     "c",
@@ -95,6 +96,7 @@ function wrapArray(obj) {
     }
     return [obj];
 }
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- 現時点では未参照だが、オリジナル(luamin)由来のコードのため残置
 function generateZeroes(length) {
     let zero = "0";
     let result = "";
@@ -108,7 +110,6 @@ function generateZeroes(length) {
         if (length & 1) {
             result += zero;
         }
-        // eslint-disable-next-line no-cond-assign
         if ((length >>= 1)) {
             zero += zero;
         }
@@ -206,11 +207,13 @@ function insertSeparator(a, b, separator = " ") {
 }
 class MinifyFile {
     fileName;
+    moduleName;
     ast;
     minifier;
     mode;
-    constructor(fileName, ast, minifier, mode) {
+    constructor(fileName, moduleName, ast, minifier, mode) {
         this.fileName = fileName;
+        this.moduleName = moduleName;
         this.ast = ast;
         this.minifier = minifier;
         this.mode = mode;
@@ -219,7 +222,10 @@ class MinifyFile {
         const body = this.formatStatementList(this.ast.body);
         if (!noComment && this.ast.comments) {
             const comments = this.ast.comments;
-            comments.reverse().filter(v => v.raw.includes("--#") || v.raw.includes("[[#")).forEach(comment => {
+            comments
+                .reverse()
+                .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
+                .forEach((comment) => {
                 body.prepend([this.sourceNodeHelper(comment, comment.raw), "\n"]);
             });
             return body;
@@ -228,11 +234,83 @@ class MinifyFile {
             return body;
         }
     }
+    /**
+     * モジュール本体の最後の文が「単一の式を返すreturn文」であるときに限り、
+     * それ以外の文と最後の式を分けて返す。requireを式（IIFE）ではなく文として
+     * 展開したい呼び出し側（#29のレビュー対応）が利用する。
+     * 該当しない場合はundefinedを返し、呼び出し側はIIFE方式へフォールバックする。
+     */
+    parseAsStatementsAndFinalExpression(noComment) {
+        const body = this.ast.body;
+        const last = body[body.length - 1];
+        if (!last ||
+            last.type !== "ReturnStatement" ||
+            last.arguments.length !== 1) {
+            return undefined;
+        }
+        const statements = this.formatStatementList(body.slice(0, -1));
+        if (!noComment && this.ast.comments) {
+            this.ast.comments
+                .slice()
+                .reverse()
+                .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
+                .forEach((comment) => {
+                statements.prepend([
+                    this.sourceNodeHelper(comment, comment.raw),
+                    "\n",
+                ]);
+            });
+        }
+        const finalExpression = this.formatExpression(last.arguments[0]);
+        return { statements, finalExpression };
+    }
     sourceNodeHelper(node, chuncks, name) {
         const line = node?.loc?.start.line;
         const column = node?.loc?.start.column;
-        return new source_map_1.SourceNode(line == undefined ? null : line, column == undefined ? null : column, this.fileName, // 本当に自分のファイル名でよいかは要検討
-        chuncks, name);
+        // this.fileNameは常にこの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, []);
@@ -241,7 +319,66 @@ class MinifyFile {
         });
         return result;
     }
+    /**
+     * SLモード限定: `local x = require("m")` / `x = require("m")` の形（変数1個・
+     * 初期化式1個）を、requireを式（IIFE）として埋め込むのではなく、モジュール本体の
+     * 文をそのまま展開し最後にターゲットへ代入する「文」の並びとして出力する
+     * （#29のレビュー対応。無オプション実行時の挙動互換性のため）。
+     *
+     * モジュール本体が「単一の式を返すreturn文」で終わっていない場合や、変数・
+     * 初期化式が複数ある場合、-mモードの場合は対象外とし、undefinedを返す
+     * （呼び出し側は従来のIIFE方式にフォールバックする）。
+     */
+    trySpliceRequireStatement(statement) {
+        if (this.mode.moduleLikeLua) {
+            return undefined;
+        }
+        if (statement.variables.length !== 1 || statement.init.length !== 1) {
+            return undefined;
+        }
+        const moduleRef = this.matchModuleCallExpression(statement.init[0]);
+        if (!moduleRef || moduleRef.kind !== "require") {
+            return undefined;
+        }
+        const spliced = this.minifier.splitModuleForStatementSplice(moduleRef.moduleName);
+        if (!spliced) {
+            return undefined;
+        }
+        const isLocal = statement.type === "LocalStatement";
+        const target = statement.variables[0];
+        const targetNode = isLocal
+            ? this.generateIdentifier(target)
+            : this.formatExpression(target);
+        const result = this.sourceNodeHelper(statement, []);
+        addWithSeparator(result, spliced.statements);
+        addWithSeparator(result, isLocal ? ["local ", targetNode] : [targetNode]);
+        addWithSeparator(result, "=");
+        addWithSeparator(result, spliced.finalExpression);
+        return result;
+    }
+    /**
+     * SLモード限定: `require("m")` を戻り値を使わない単独の文として書いた場合、
+     * dofileと同じくfunctionで包まずそのまま展開する（Cプリプロセッサのincludeに
+     * 近い、LifeBoat Modeでの一般的な使い方に合わせるための対応。#29のレビュー対応）。
+     */
+    tryInlineBareRequireStatement(expr) {
+        if (this.mode.moduleLikeLua) {
+            return undefined;
+        }
+        const moduleRef = this.matchModuleCallExpression(expr);
+        if (!moduleRef || moduleRef.kind !== "require") {
+            return undefined;
+        }
+        return this.minifier.printModuleInline(moduleRef.moduleName);
+    }
     formatStatement(statement) {
+        if (statement.type == "AssignmentStatement" ||
+            statement.type == "LocalStatement") {
+            const spliced = this.trySpliceRequireStatement(statement);
+            if (spliced) {
+                return spliced;
+            }
+        }
         if (statement.type == "AssignmentStatement") {
             // left-hand side
             const variables = statement.variables
@@ -273,6 +410,10 @@ class MinifyFile {
             return result;
         }
         else if (statement.type == "CallStatement") {
+            const bareRequire = this.tryInlineBareRequireStatement(statement.expression);
+            if (bareRequire) {
+                return bareRequire;
+            }
             return this.formatExpression(statement.expression); // NOTE: もう一度囲んでもいい
         }
         else if (statement.type == "IfStatement") {
@@ -282,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");
@@ -295,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") {
@@ -328,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;
         }
@@ -353,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") {
@@ -368,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") {
@@ -385,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") {
@@ -414,13 +561,7 @@ class MinifyFile {
   }*/
     formatExpression(expression, argOptions) {
         if (expression.type == "Identifier") {
-            return this.sourceNodeHelper(expression, 
-            // eslint-disable-next-line @typescript-eslint/ban-ts-comment, @typescript-eslint/prefer-ts-expect-error
-            //@ts-ignore
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            expression.isLocal
-                ? this.generateIdentifier(expression, true)
-                : expression.name, expression.name);
+            return this.generateIdentifier(expression);
         }
         else if (expression.type == "StringLiteral" ||
             expression.type == "NumericLiteral" ||
@@ -500,22 +641,11 @@ class MinifyFile {
             return result;
         }
         else if (expression.type == "CallExpression") {
-            // requireの展開モードは2種類: SLモード-その場に読み込み, FLモード-require相当の関数で呼び出し
-            const callExpr = this.formatBase(expression.base).toString();
-            if ((callExpr === "require" || callExpr === "dofile") &&
-                expression?.arguments[0].type === "StringLiteral") {
-                const moduleName = expression.arguments[0].raw
-                    .replaceAll('"', "")
-                    .replaceAll("'", "");
-                const res = this.minifier.parseModule(moduleName);
-                if (this.mode.moduleLikeLua) {
-                    if (callExpr === "dofile") {
-                        return (res || this.sourceNodeHelper(undefined, ""));
-                    }
-                    // requireならスキップ
-                }
-                else {
-                    return (res || this.sourceNodeHelper(undefined, ""));
+            const moduleRef = this.matchModuleCallExpression(expression);
+            if (moduleRef) {
+                const replacement = this.formatModuleReference(expression, moduleRef);
+                if (replacement) {
+                    return replacement;
                 }
             }
             const args = expression.arguments
@@ -535,6 +665,13 @@ class MinifyFile {
             ]);
         }
         else if (expression.type == "StringCallExpression") {
+            const moduleRef = this.matchModuleCallExpression(expression);
+            if (moduleRef) {
+                const replacement = this.formatModuleReference(expression, moduleRef);
+                if (replacement) {
+                    return replacement;
+                }
+            }
             return this.sourceNodeHelper(expression, [
                 this.formatExpression(expression.base),
                 this.formatExpression(expression.argument),
@@ -575,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") {
@@ -637,43 +774,62 @@ class MinifyFile {
         }
         return result;
     }
-    currentIdentifier = "";
-    generateIdentifier(nameItem, nested = false) {
-        if (nameItem.name === "self") {
-            return this.sourceNodeHelper(nameItem, "self", "self");
-        }
-        const defined = this.minifier.identifierMap.get(nameItem.name);
-        if (defined) {
-            return this.sourceNodeHelper(nameItem, defined, nameItem.name); // 第3引数は要調査
-        }
-        const length = this.currentIdentifier.length;
-        let position = length - 1;
-        let character;
-        let index;
-        while (position >= 0) {
-            character = this.currentIdentifier.charAt(position);
-            index = IDENTIFIER_PARTS.indexOf(character);
-            if (index != IDENTIFIER_PARTS.length - 1) {
-                this.currentIdentifier =
-                    this.currentIdentifier.substring(0, position) +
-                        IDENTIFIER_PARTS[index + 1] +
-                        generateZeroes(length - (position + 1));
-                if (isKeyword(this.currentIdentifier) ||
-                    this.minifier.identifiersInUse.has(this.currentIdentifier)) {
-                    return this.generateIdentifier(nameItem, nested);
-                }
-                this.minifier.identifierMap.set(nameItem.name, this.currentIdentifier);
-                return this.generateIdentifier(nameItem, nested);
-            }
-            --position;
+    // require/dofileへの静的な呼び出しを検出する。実際のモジュール解決はLinkパス
+    // （Minifier.link）が事前に済ませているため、ここでは呼び出し形が
+    // require/dofile への静的文字列呼び出しかどうかを判定するだけでよい（#18）。
+    matchModuleCall(base, argument) {
+        if (base.type !== "Identifier") {
+            return undefined;
         }
-        this.currentIdentifier = "a" + generateZeroes(length);
-        if (this.minifier.identifiersInUse.has(this.currentIdentifier)) {
-            return this.generateIdentifier(nameItem, nested);
+        if (base.name !== "require" && base.name !== "dofile") {
+            return undefined;
         }
-        this.minifier.identifierMap.set(nameItem.name, this.currentIdentifier);
-        return this.generateIdentifier(nameItem, nested);
-        //    return this.sourceNodeHelper(nameItem, nameItem.name, nested ? nameItem.name : undefined);
+        const moduleName = (0, linker_1.staticStringArgument)(argument);
+        if (moduleName === undefined) {
+            return undefined;
+        }
+        return { kind: base.name, moduleName };
+    }
+    // CallExpression / StringCallExpression のどちらの構文でも呼べるmatchModuleCall
+    matchModuleCallExpression(expr) {
+        if (expr.type === "CallExpression") {
+            return this.matchModuleCall(expr.base, expr.arguments[0]);
+        }
+        if (expr.type === "StringCallExpression") {
+            return this.matchModuleCall(expr.base, expr.argument);
+        }
+        return undefined;
+    }
+    formatModuleReference(expression, ref) {
+        if (ref.kind === "dofile") {
+            // dofileは呼び出しごとに毎回展開しなおす（キャッシュしない）
+            return this.minifier.printModuleInline(ref.moduleName);
+        }
+        if (!this.mode.moduleLikeLua) {
+            // SLモード（無オプション）: requireもキャッシュせずその場展開する
+            // （挙動互換性のため、ホイストした共有ローカルへの参照にはしない）。
+            // 式の位置に置けるようにIIFEで包む。
+            const body = this.minifier.printModuleInline(ref.moduleName);
+            return this.sourceNodeHelper(expression, [
+                "(function() ",
+                body,
+                " end)()",
+            ]);
+        }
+        // -mモードのrequireはそのまま呼び出しとして出力し、実行時のrequire関数に委ねる
+        return undefined;
+    }
+    // Renameパス（#20）が解決済みシンボルテーブルをもとに割り当てた短縮名を参照する。
+    // 対応するローカルシンボルが無い場合（グローバル参照や"self"）は元の名前のまま出力する。
+    generateIdentifier(nameItem) {
+        const renamed = this.minifier
+            .getRenameResult(this.moduleName)
+            .nameOf(nameItem);
+        // #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

@@ -8,11 +8,19 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const commander_1 = require("commander");
 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("-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);
 const luaFiles = program.args;
 const luaparseSetting = {
@@ -21,7 +29,36 @@ const luaparseSetting = {
     ranges: true,
     scope: true,
 };
-const 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
+    ? "strict"
+    : singleLineSourceMappingUrl
+        ? "line"
+        : "legacy";
 luaFiles.forEach((fileName) => {
     const parsedFileName = path_1.default.parse(fileName);
     if (fs_1.default.existsSync(fileName)) {
@@ -36,10 +73,9 @@ luaFiles.forEach((fileName) => {
             name: parsedFileName.name,
             ext: parsedFileName.ext + ".map",
         });
-        map.add("\n--[[\n//# sourceMappingURL=" + path_1.default.basename(mapFileName) + "\n]]");
-        const sourceAndMap = map.toStringWithSourceMap();
-        fs_1.default.writeFileSync(minFileName, sourceAndMap.code);
-        fs_1.default.writeFileSync(mapFileName, JSON.stringify(sourceAndMap.map));
+        const { code, map: mapJson } = (0, output_1.buildMinifiedOutput)(map, minFileName, mapFileName, { sourceMappingUrlStyle });
+        fs_1.default.writeFileSync(minFileName, code);
+        fs_1.default.writeFileSync(mapFileName, mapJson);
     }
     else {
         console.error("No such file: " + fileName);