storm-lua-minify 0.1.3 → 0.3.0

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/index.js

@@ -4,38 +4,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const luaparse_1 = __importDefault(require("luaparse"));
 const node_process_1 = require("node:process");
 const ast2lua_1 = require("./ast2lua");
 const luaparseSetting = {
     locations: true,
-    luaVersion: "5.3",
+    luaVersion: '5.3',
     ranges: true,
     scope: true,
 };
 const argPath = node_process_1.argv[2];
-const includes = new Set();
-function requireHelper(fileName) {
-    const resolvePath = path_1.default.join(path_1.default.dirname(argPath), fileName.replaceAll(".", path_1.default.sep) + ".lua");
-    if (!includes.has(resolvePath) && fs_1.default.existsSync(resolvePath)) {
-        const code = fs_1.default.readFileSync(resolvePath).toString();
-        const ast = luaparse_1.default.parse(code, luaparseSetting);
-        if ("globals" in ast) {
-            return new ast2lua_1.Minifier(resolvePath, ast, requireHelper).parse();
-        }
-    }
-    else {
-        return undefined;
-    }
-    includes.add(resolvePath);
-}
 if (fs_1.default.existsSync(argPath)) {
     const code = fs_1.default.readFileSync(argPath).toString();
     const ast = luaparse_1.default.parse(code, luaparseSetting);
     if ("globals" in ast) {
-        const map = new ast2lua_1.Minifier(argPath, ast, requireHelper).parse();
-        map.add("\n--[[\n//# sourceMappingURL=" + argPath + ".map\n]]");
+        const map = (0, ast2lua_1.minify)(ast);
+        map.add("\n--[[\n//# sourceMappingURL=test.lua.map\n]]");
         console.log(map.toStringWithSourceMap().code);
         // toStringWithSourceMap().map の file に書き出したのちのファイル名を入れないとVSCode Extでは検索失敗する
         //console.log(JSON.stringify(map.toStringWithSourceMap().map));

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

@@ -0,0 +1,109 @@
+"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）。
+ */
+function walk(node, visit) {
+    if (node === null || typeof node !== "object") {
+        return;
+    }
+    if (Array.isArray(node)) {
+        node.forEach((child) => {
+            walk(child, visit);
+        });
+        return;
+    }
+    const obj = node;
+    if (typeof obj.type === "string") {
+        visit(obj);
+    }
+    for (const key of Object.keys(obj)) {
+        if (key === "loc" || key === "range") {
+            continue;
+        }
+        walk(obj[key], visit);
+    }
+}
+// luaparseはデフォルト設定（encodingMode: "none"）ではStringLiteral.valueを
+// 常にnullにする（discardStrings）ため、rawから引用符を取り除いて文字列値を得る。
+// require/dofileのモジュール名として使う簡単な文字列リテラルのみを想定しており、
+// エスケープシーケンスの解釈までは行わない。
+function unquoteRaw(raw) {
+    if (raw.length >= 2) {
+        const first = raw.charAt(0);
+        const last = raw.charAt(raw.length - 1);
+        if ((first === '"' || first === "'") && first === last) {
+            return raw.slice(1, -1);
+        }
+    }
+    return raw;
+}
+function staticStringArgument(node) {
+    if (node !== null &&
+        typeof node === "object" &&
+        node.type === "StringLiteral" &&
+        typeof node.raw === "string") {
+        return unquoteRaw(node.raw);
+    }
+    return undefined;
+}
+function calleeName(node) {
+    if (node !== null &&
+        typeof node === "object" &&
+        node.type === "Identifier" &&
+        typeof node.name === "string") {
+        return node.name;
+    }
+    return undefined;
+}
+/**
+ * ASTを走査してrequire/dofile呼び出し（CallExpression / StringCallExpression の両構文）を
+ * 静的な文字列引数付きのものに限って列挙する。同一モジュールへの参照は重複したまま返す
+ * （呼び出し側で重複排除する）。
+ */
+function findModuleReferences(ast) {
+    const refs = [];
+    walk(ast, (node) => {
+        if (node.type === "CallExpression") {
+            const name = calleeName(node.base);
+            if (name !== "require" && name !== "dofile") {
+                return;
+            }
+            const args = node.arguments;
+            if (!Array.isArray(args) || args.length === 0) {
+                return;
+            }
+            const moduleName = staticStringArgument(args[0]);
+            if (moduleName !== undefined) {
+                refs.push({ kind: name, moduleName });
+            }
+        }
+        else if (node.type === "StringCallExpression") {
+            const name = calleeName(node.base);
+            if (name !== "require" && name !== "dofile") {
+                return;
+            }
+            const moduleName = staticStringArgument(node.argument);
+            if (moduleName !== undefined) {
+                refs.push({ kind: name, moduleName });
+            }
+        }
+    });
+    return refs;
+}

package/dist/minifier.js

@@ -9,22 +9,35 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const source_map_1 = require("source-map");
 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(),
+};
 class Minifier {
-    identifierMap;
     identifiersInUse;
     moduleSourceText;
-    moduleSourceNode;
     moduleAST;
     moduleNameAndFileName;
     dir;
     entryModule;
     mode;
     luaParseSettings;
+    // Linkパスで解決されたモジュール名を、依存されている側が先に来る順序で並べたもの
+    linkOrder = [];
+    // モジュールごとのResolveパスの結果（Linkパスで一度だけ計算し使い回す）
+    moduleResolve = new Map();
+    // モジュールごとのRenameパスの結果（初回アクセス時に計算しキャッシュする）
+    renameCache = new Map();
+    // #8a: プログラム全体を横断して決定された「内部グローバル名 -> 短縮名」の対応
+    globalRenames = new Map();
     constructor(entryFilePath, luaParseSettings, mode) {
-        this.identifierMap = new Map();
         this.identifiersInUse = new Set();
         this.moduleSourceText = new Map();
-        this.moduleSourceNode = new Map();
         this.moduleAST = new Map();
         this.moduleNameAndFileName = new Map();
         this.luaParseSettings = luaParseSettings;
@@ -34,65 +47,247 @@ class Minifier {
         this.entryModule = pn.name;
     }
     parse() {
-        const sn = this.parseModule(this.entryModule);
-        if (this.mode.moduleLikeLua) {
-            // require関数を作成し、流し込む
-            /*
-            function require(m,r)
-              package=package or {loaded={}}
-              if package.loaded[m] then return package.loaded[m] end
-              if m=="<MODULE_NAME>" then r=(function()[[MODULE]]end)() end
-              package.loaded[m]=package.loaded[m] or r or true;return package.loaded[m]
-            end
-            */
-            sn.prepend("package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end\n");
-            this.moduleSourceNode.forEach((v, k) => {
-                if (k !== this.entryModule) {
-                    sn.prepend(["if m==\"", k, "\"then r=(function() ", v, " end)()end\n"]);
-                }
-            });
-            sn.prepend("function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end\n");
-        }
-        // コメントの流し込み
-        const comments = this.moduleAST.get(this.entryModule)?.comments;
-        if (comments) {
-            comments
-                .reverse()
+        this.link();
+        this.computeGlobalRenames();
+        this.transformAll();
+        this.renameAll();
+        const parts = [];
+        const entryComments = this.moduleAST.get(this.entryModule)?.comments;
+        if (entryComments) {
+            entryComments
                 .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
                 .forEach((comment) => {
-                sn.prepend([
-                    new source_map_1.SourceNode(comment.loc?.start.line || null, comment.loc?.start.column || null, this.entryModule, // 本当に自分のファイル名でよいかは要検討
-                    comment.raw),
-                    "\n"
-                ]);
+                parts.push(new source_map_1.SourceNode(comment.loc?.start.line ?? null, comment.loc?.start.column ?? null, this.moduleNameAndFileName.get(this.entryModule) ?? null, comment.raw), "\n");
             });
         }
-        this.moduleSourceText.forEach((v, k) => { const fileName = this.moduleNameAndFileName.get(k); fileName && sn.setSourceContent(fileName, v); });
-        return sn;
+        if (this.mode.moduleLikeLua) {
+            parts.push(this.buildRequireWrapper());
+        }
+        parts.push(this.printModule(this.entryModule));
+        const result = new source_map_1.SourceNode(null, null, null, parts);
+        this.moduleSourceText.forEach((v, k) => {
+            const fileName = this.moduleNameAndFileName.get(k);
+            if (fileName) {
+                result.setSourceContent(fileName, v);
+            }
+        });
+        return result;
+    }
+    /**
+     * dofileの呼び出し箇所ごとに、キャッシュ済みASTから新規にSourceNodeを作り直す。
+     * 同じSourceNodeインスタンスを複数箇所へ挿入すると壊れるため、常に作り直す（#18）。
+     */
+    printModuleInline(moduleName) {
+        return this.printModule(moduleName);
+    }
+    /**
+     * requireを式（IIFE）ではなく文として展開できる場合に使う。モジュール本体が
+     * 「単一の式を返すreturn文」で終わっている場合のみ結果を返す。それ以外は
+     * undefinedを返すので、呼び出し側は従来のIIFE方式にフォールバックする（#29）。
+     */
+    splitModuleForStatementSplice(moduleName) {
+        const ast = this.moduleAST.get(moduleName);
+        const fileName = this.moduleNameAndFileName.get(moduleName);
+        if (!ast || !fileName) {
+            throw new Error(moduleName + " is not found");
+        }
+        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parseAsStatementsAndFinalExpression(moduleName === this.entryModule);
+    }
+    /**
+     * 指定モジュールのRenameパス結果を返す。`renameAll`で事前に計算済みの
+     * ものをそのまま返すだけの参照用アクセサ。
+     */
+    getRenameResult(moduleName) {
+        if (this.mode.rename === false) {
+            return NO_RENAME;
+        }
+        const cached = this.renameCache.get(moduleName);
+        if (!cached) {
+            throw new Error(moduleName + " is not found");
+        }
+        return cached;
+    }
+    /**
+     * Renameパス（#20）: linkOrder（依存されている側が先）の順にモジュールごとの
+     * 短縮名を割り当てる。
+     *
+     * dofileやSLモードのrequireその場展開は、呼び出し元と同じLuaスコープに
+     * 関数で包まずに直接展開されるため、モジュールをまたいで同じ短縮名を
+     * 再利用すると本来無関係な変数同士が衝突しうる（#12）。これを安全に防ぐため、
+     * あるモジュールが実際に使った短縮名は、後続モジュールを処理する前に
+     * `identifiersInUse`（予約名の集合）へ積み増す。これにより短縮名は
+     * プログラム全体で重複しなくなる（モジュール間での再利用による圧縮は
+     * 犠牲になるが、モジュール内でのスコープに基づく再利用は維持される）。
+     */
+    renameAll() {
+        if (this.mode.rename === false) {
+            return;
+        }
+        this.linkOrder.forEach((moduleName) => {
+            const resolved = this.moduleResolve.get(moduleName);
+            if (!resolved) {
+                throw new Error(moduleName + " is not found");
+            }
+            const result = (0, renamer_1.assignRenames)(resolved, this.identifiersInUse, this.globalRenames);
+            this.renameCache.set(moduleName, result);
+            result.usedNames.forEach((name) => this.identifiersInUse.add(name));
+        });
     }
-    parseModule(moduleName) {
-        const resolvePath = moduleName.replaceAll(".", path_1.default.sep) + ".lua";
-        const fullResolvePath = path_1.default.join(this.dir, resolvePath);
-        if (this.moduleSourceNode.has(moduleName)) {
-            const res = this.moduleSourceNode.get(moduleName);
-            if (res) {
-                return res;
+    /**
+     * 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);
+        if (!ast || !fileName) {
+            throw new Error(moduleName + " is not found");
         }
-        else if (fs_1.default.existsSync(fullResolvePath)) {
+        return new ast2lua_1.MinifyFile(fileName, moduleName, ast, this, this.mode).parse(moduleName === this.entryModule);
+    }
+    /**
+     * エントリファイルから到達可能な全モジュールをASTレベルで解決するLinkパス（#18）。
+     * - ファイルごとのパースは一度だけ行う（同一モジュールの多重require/dofileの重複排除）
+     * - require/dofileの参照グラフに循環があればエラーを投げる
+     * - 出力（Print）を開始する前に、必要なモジュール解決をすべて完了させる
+     */
+    link() {
+        const visiting = new Set();
+        const stack = [];
+        const visit = (moduleName) => {
+            if (visiting.has(moduleName)) {
+                const cycleStart = stack.indexOf(moduleName);
+                const cycle = [...stack.slice(cycleStart), moduleName];
+                throw new Error("Circular require/dofile detected: " + cycle.join(" -> "));
+            }
+            if (this.moduleAST.has(moduleName)) {
+                // 解決済み（このモジュールは複数箇所から参照されていても一度しかパースしない）
+                return;
+            }
+            visiting.add(moduleName);
+            stack.push(moduleName);
+            const fullResolvePath = path_1.default.join(this.dir, ...moduleName.split(".")) + ".lua";
+            if (!fs_1.default.existsSync(fullResolvePath)) {
+                throw new Error(moduleName + " is not found");
+            }
             const code = fs_1.default.readFileSync(fullResolvePath).toString();
             const ast = luaparse_1.default.parse(code, this.luaParseSettings);
-            if ("globals" in ast) {
-                ast.globals?.map((v) => this.identifiersInUse.add(v.name));
-                const sourceNode = new ast2lua_1.MinifyFile(resolvePath, ast, this, this.mode).parse(moduleName === this.entryModule);
-                this.moduleSourceText.set(moduleName, code);
-                this.moduleAST.set(moduleName, ast);
-                this.moduleSourceNode.set(moduleName, sourceNode);
-                this.moduleNameAndFileName.set(moduleName, resolvePath);
-                return sourceNode;
+            // Resolveパス（#19）: このモジュールのスコープ/シンボルを解析し、Renameパスの
+            // 入力として使い回せるようキャッシュする。グローバル参照はプログラム全体で
+            // 予約すべき名前（identifiersInUse）としてここで集計する。
+            const resolved = (0, resolver_1.resolveScopes)(ast);
+            this.moduleResolve.set(moduleName, resolved);
+            resolved.globals.forEach((binding) => this.identifiersInUse.add(binding.name));
+            this.moduleSourceText.set(moduleName, code);
+            this.moduleAST.set(moduleName, ast);
+            // Source Mapの`sources`はURLとして解釈されるため、OS依存のpath.sepではなく
+            // 常に"/"区切りで保持する（Windows上でのビルドでも壊れないように）。
+            this.moduleNameAndFileName.set(moduleName, moduleName.replaceAll(".", "/") + ".lua");
+            (0, linker_1.findModuleReferences)(ast).forEach((ref) => {
+                visit(ref.moduleName);
+            });
+            visiting.delete(moduleName);
+            stack.pop();
+            this.linkOrder.push(moduleName);
+        };
+        visit(this.entryModule);
+    }
+    /**
+     * require()（dofileは除く）で参照されているモジュール名の集合を求める。
+     * dofileは呼び出しごとに毎回展開しなおすため、キャッシュ／ホイストの対象にしない。
+     */
+    collectRequireTargets() {
+        const targets = new Set();
+        this.linkOrder.forEach((moduleName) => {
+            const ast = this.moduleAST.get(moduleName);
+            if (!ast) {
+                return;
             }
-        }
-        throw new Error(moduleName + " is not found");
+            (0, linker_1.findModuleReferences)(ast).forEach((ref) => {
+                if (ref.kind === "require") {
+                    targets.add(ref.moduleName);
+                }
+            });
+        });
+        return targets;
+    }
+    buildRequireWrapper() {
+        const targets = this.collectRequireTargets();
+        const parts = [
+            "function require(m,r)package=package or{loaded={}};if package.loaded[m]then return package.loaded[m]end\n",
+        ];
+        this.linkOrder.forEach((moduleName) => {
+            if (moduleName === this.entryModule || !targets.has(moduleName)) {
+                return;
+            }
+            parts.push('if m=="', moduleName, '"then r=(function() ', this.printModule(moduleName), " end)()end\n");
+        });
+        parts.push("package.loaded[m]=package.loaded[m]or r or true;return package.loaded[m]end\n");
+        return new source_map_1.SourceNode(null, null, null, parts);
     }
 }
 exports.Minifier = Minifier;

package/dist/output.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMinifiedOutput = buildMinifiedOutput;
+const path_1 = __importDefault(require("path"));
+/**
+ * ミニファイ済みSourceNodeに、sourceMappingURLアノテーションとSource Mapを
+ * 付加した最終的な出力を組み立てる。アノテーションの出力形式は
+ * `BuildMinifiedOutputOptions.sourceMappingUrlStyle`で選択する。
+ */
+function buildMinifiedOutput(sourceNode, minFileName, mapFileName, options = {}) {
+    const style = options.sourceMappingUrlStyle ?? "legacy";
+    const marker = "//# sourceMappingURL=" + path_1.default.basename(mapFileName);
+    if (style === "legacy") {
+        // 旧storm-lua-minifyと完全に同じ出力（末尾に改行は付加しない）。
+        sourceNode.add("\n--[[\n" + marker + "\n]]");
+    }
+    else if (style === "line") {
+        sourceNode.add("\n-- " + marker + "\n");
+    }
+    else {
+        sourceNode.add("\n" + marker + "\n");
+    }
+    const sourceAndMap = sourceNode.toStringWithSourceMap({
+        file: path_1.default.basename(minFileName),
+    });
+    return {
+        code: sourceAndMap.code,
+        map: JSON.stringify(sourceAndMap.map),
+    };
+}