storm-lua-minify 0.1.0 → 0.1.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) Mathias Bynens, 2024 Nona Takahara
+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

package/README.md

@@ -3,3 +3,13 @@
 このプログラムは [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の実際の挙動に近づけます

package/dist/ast2lua.js

@@ -2,7 +2,7 @@
 // based on "luamin": Copyright Mathias Bynens <https://mathiasbynens.be/>
 // SPDX-License-Identifier: MIT
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Minifier = void 0;
+exports.MinifyFile = void 0;
 const source_map_1 = require("source-map");
 const PRECEDENCE = {
     or: 1,
@@ -89,8 +89,6 @@ const IDENTIFIER_PARTS = [
     "Z",
     "_",
 ];
-const identifierMap = new Map();
-const identifiersInUse = new Set();
 function wrapArray(obj) {
     if (Array.isArray(obj)) {
         return obj;
@@ -206,25 +204,27 @@ function prependWithSeparator(val, prepending, separator = " ") {
 function insertSeparator(a, b, separator = " ") {
     return isNeedSeparator(a.toString(), b.toString()) ? separator : undefined;
 }
-class Minifier {
+class MinifyFile {
     fileName;
     ast;
-    requireHelper;
-    constructor(fileName, ast, requireHelper) {
+    minifier;
+    mode;
+    constructor(fileName, ast, minifier, mode) {
         this.fileName = fileName;
         this.ast = ast;
-        this.requireHelper = requireHelper;
-        ast.globals?.map((v) => identifiersInUse.add(v.name));
+        this.minifier = minifier;
+        this.mode = mode;
     }
-    parse() {
+    parse(noComment) {
         const body = this.formatStatementList(this.ast.body);
-        /*if (this.ast.comments) {
-          const comments = this.ast.comments as Comment[];
-          comments.reverse().filter(v => v.raw.includes("--#") || v.raw.includes("[[#")).forEach(comment => {
-            body.prepend(this.sourceNodeHelper(comment, comment.raw));
-          })
-          return body;
-        } else*/ {
+        if (!noComment && this.ast.comments) {
+            const comments = this.ast.comments;
+            comments.reverse().filter(v => v.raw.includes("--#") || v.raw.includes("[[#")).forEach(comment => {
+                body.prepend([this.sourceNodeHelper(comment, comment.raw), "\n"]);
+            });
+            return body;
+        }
+        else {
             return body;
         }
     }
@@ -501,11 +501,21 @@ class Minifier {
         }
         else if (expression.type == "CallExpression") {
             // requireの展開モードは2種類: SLモード-その場に読み込み, FLモード-require相当の関数で呼び出し
-            if (this.formatBase(expression.base).toString() == "require" &&
+            const callExpr = this.formatBase(expression.base).toString();
+            if ((callExpr === "require" || callExpr === "dofile") &&
                 expression?.arguments[0].type === "StringLiteral") {
-                const res = this.requireHelper(expression.arguments[0].raw.replaceAll('"', ""));
-                if (res != undefined) {
-                    return res;
+                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 args = expression.arguments
@@ -632,7 +642,7 @@ class Minifier {
         if (nameItem.name === "self") {
             return this.sourceNodeHelper(nameItem, "self", "self");
         }
-        const defined = identifierMap.get(nameItem.name);
+        const defined = this.minifier.identifierMap.get(nameItem.name);
         if (defined) {
             return this.sourceNodeHelper(nameItem, defined, nameItem.name); // 第3引数は要調査
         }
@@ -649,21 +659,21 @@ class Minifier {
                         IDENTIFIER_PARTS[index + 1] +
                         generateZeroes(length - (position + 1));
                 if (isKeyword(this.currentIdentifier) ||
-                    identifiersInUse.has(this.currentIdentifier)) {
+                    this.minifier.identifiersInUse.has(this.currentIdentifier)) {
                     return this.generateIdentifier(nameItem, nested);
                 }
-                identifierMap.set(nameItem.name, this.currentIdentifier);
+                this.minifier.identifierMap.set(nameItem.name, this.currentIdentifier);
                 return this.generateIdentifier(nameItem, nested);
             }
             --position;
         }
         this.currentIdentifier = "a" + generateZeroes(length);
-        if (identifiersInUse.has(this.currentIdentifier)) {
+        if (this.minifier.identifiersInUse.has(this.currentIdentifier)) {
             return this.generateIdentifier(nameItem, nested);
         }
-        identifierMap.set(nameItem.name, this.currentIdentifier);
+        this.minifier.identifierMap.set(nameItem.name, this.currentIdentifier);
         return this.generateIdentifier(nameItem, nested);
         //    return this.sourceNodeHelper(nameItem, nameItem.name, nested ? nameItem.name : undefined);
     }
 }
-exports.Minifier = Minifier;
+exports.MinifyFile = MinifyFile;

package/dist/cli.js

@@ -7,10 +7,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const commander_1 = require("commander");
-const luaparse_1 = __importDefault(require("luaparse"));
-const ast2lua_1 = require("./ast2lua");
+const minifier_1 = require("./minifier");
 const program = new commander_1.Command();
-program.version("0.1.0").description("A Lua minifier also outputs source map");
+program
+    .version("0.1.2")
+    .description("A Lua minifier also outputs source map")
+    .option("-m, --module-like-lua", "require・dofileの動作を実際のLuaに近づけます");
 program.parse(process.argv);
 const luaFiles = program.args;
 const luaparseSetting = {
@@ -19,48 +21,25 @@ const luaparseSetting = {
     ranges: true,
     scope: true,
 };
+const mode = program.opts();
 luaFiles.forEach((fileName) => {
-    const includes = new Map();
     const parsedFileName = path_1.default.parse(fileName);
-    function requireHelper(recursiveFilePath) {
-        const resolvePath = path_1.default.relative(parsedFileName.dir, path_1.default.join(parsedFileName.dir, recursiveFilePath.replaceAll(".", path_1.default.sep) + ".lua"));
-        const fullResolvePath = path_1.default.join(parsedFileName.dir, resolvePath);
-        if (!includes.has(resolvePath) && fs_1.default.existsSync(fullResolvePath)) {
-            const code = fs_1.default.readFileSync(fullResolvePath).toString();
-            const ast = luaparse_1.default.parse(code, luaparseSetting);
-            if ("globals" in ast) {
-                includes.set(resolvePath, code);
-                return new ast2lua_1.Minifier(resolvePath, ast, requireHelper).parse();
-            }
-            includes.set(resolvePath, "");
-            return undefined;
-        }
-    }
     if (fs_1.default.existsSync(fileName)) {
-        const code = fs_1.default.readFileSync(fileName).toString();
-        const ast = luaparse_1.default.parse(code, luaparseSetting);
-        if ("globals" in ast) {
-            includes.set(parsedFileName.base, code);
-            const map = new ast2lua_1.Minifier(parsedFileName.base, ast, requireHelper).parse();
-            includes.forEach((v, k) => {
-                console.log(k);
-                map.setSourceContent(k, v);
-            });
-            const minFileName = path_1.default.format({
-                dir: parsedFileName.dir,
-                name: parsedFileName.name + ".min",
-                ext: ".lua",
-            });
-            const mapFileName = path_1.default.format({
-                dir: parsedFileName.dir,
-                name: parsedFileName.name,
-                ext: parsedFileName.ext + ".map",
-            });
-            map.add("\n--[[\n//# sourceMappingURL=" + mapFileName + "\n]]");
-            const sourceAndMap = map.toStringWithSourceMap();
-            fs_1.default.writeFileSync(minFileName, sourceAndMap.code);
-            fs_1.default.writeFileSync(mapFileName, JSON.stringify(sourceAndMap.map));
-        }
+        const map = new minifier_1.Minifier(fileName, luaparseSetting, mode).parse();
+        const minFileName = path_1.default.format({
+            dir: parsedFileName.dir,
+            name: parsedFileName.name + ".min",
+            ext: ".lua",
+        });
+        const mapFileName = path_1.default.format({
+            dir: parsedFileName.dir,
+            name: parsedFileName.name,
+            ext: parsedFileName.ext + ".map",
+        });
+        map.add("\n--[[\n//# sourceMappingURL=" + mapFileName + "\n]]");
+        const sourceAndMap = map.toStringWithSourceMap();
+        fs_1.default.writeFileSync(minFileName, sourceAndMap.code);
+        fs_1.default.writeFileSync(mapFileName, JSON.stringify(sourceAndMap.map));
     }
     else {
         console.error("No such file: " + fileName);

package/dist/minifier.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Minifier = void 0;
+const luaparse_1 = __importDefault(require("luaparse"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const source_map_1 = require("source-map");
+const ast2lua_1 = require("./ast2lua");
+class Minifier {
+    identifierMap;
+    identifiersInUse;
+    moduleSourceText;
+    moduleSourceNode;
+    moduleAST;
+    dir;
+    entryModule;
+    mode;
+    luaParseSettings;
+    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.luaParseSettings = luaParseSettings;
+        this.mode = mode;
+        const pn = path_1.default.parse(entryFilePath);
+        this.dir = pn.dir;
+        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()
+                .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"
+                ]);
+            });
+        }
+        return sn;
+    }
+    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;
+            }
+        }
+        else if (fs_1.default.existsSync(fullResolvePath)) {
+            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(resolvePath === this.entryModule);
+                this.moduleSourceText.set(moduleName, code);
+                this.moduleAST.set(moduleName, ast);
+                this.moduleSourceNode.set(moduleName, sourceNode);
+                return sourceNode;
+            }
+        }
+        throw new Error(moduleName + " is not found");
+    }
+}
+exports.Minifier = Minifier;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "storm-lua-minify",
   "description": "A Lua minifier also outputs source map",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "dependencies": {
     "commander": "^12.1.0",
     "luamin": "^1.0.4",

package/src/ast2lua.ts

@@ -4,6 +4,7 @@
 /* eslint-disable @typescript-eslint/no-unnecessary-condition */
 import Parser, { Comment } from "luaparse";
 import { SourceNode } from "source-map";
+import { Minifier, MinifierMode } from "./minifier";
 
 export type Chunk = Parser.Chunk & {
   globals?: (Parser.Base<"Identifer"> & {
@@ -100,9 +101,6 @@ const IDENTIFIER_PARTS = [
   "_",
 ];
 
-const identifierMap = new Map<string, string>();
-const identifiersInUse = new Set<string>();
-
 function wrapArray<T>(obj: T | T[]): T[] {
   if (Array.isArray(obj)) {
     return obj;
@@ -262,31 +260,33 @@ function insertSeparator(
   return isNeedSeparator(a.toString(), b.toString()) ? separator : undefined;
 }
 
-export class Minifier {
+export class MinifyFile {
   private fileName: string;
   private ast: Chunk;
-  private requireHelper: (fileName: string) => SourceNode | undefined;
+  private minifier: Minifier;
+  private mode: MinifierMode;
 
   constructor(
     fileName: string,
     ast: Chunk,
-    requireHelper: (fileName: string) => SourceNode | undefined
+    minifier: Minifier,
+    mode: MinifierMode
   ) {
     this.fileName = fileName;
     this.ast = ast;
-    this.requireHelper = requireHelper;
-    ast.globals?.map((v) => identifiersInUse.add(v.name));
+    this.minifier = minifier;
+    this.mode = mode;
   }
 
-  parse() {
+  parse(noComment: boolean) {
     const body = this.formatStatementList(this.ast.body);
-    /*if (this.ast.comments) {
+    if (!noComment && this.ast.comments) {
       const comments = this.ast.comments as Comment[];
       comments.reverse().filter(v => v.raw.includes("--#") || v.raw.includes("[[#")).forEach(comment => {
-        body.prepend(this.sourceNodeHelper(comment, comment.raw));
+        body.prepend([this.sourceNodeHelper(comment, comment.raw), "\n"]);
       })
       return body;
-    } else*/ {
+    } else {
       return body;
     }
   }
@@ -605,15 +605,28 @@ export class Minifier {
       return result;
     } else if (expression.type == "CallExpression") {
       // requireの展開モードは2種類: SLモード-その場に読み込み, FLモード-require相当の関数で呼び出し
+      const callExpr = this.formatBase(expression.base).toString();
       if (
-        this.formatBase(expression.base).toString() == "require" &&
+        (callExpr === "require" || callExpr === "dofile") &&
         expression?.arguments[0].type === "StringLiteral"
       ) {
-        const res = this.requireHelper(
-          expression.arguments[0].raw.replaceAll('"', "")
-        );
-        if (res != undefined) {
-          return res;
+        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 args = expression.arguments
@@ -759,7 +772,7 @@ export class Minifier {
       return this.sourceNodeHelper(nameItem, "self", "self");
     }
 
-    const defined = identifierMap.get(nameItem.name);
+    const defined = this.minifier.identifierMap.get(nameItem.name);
     if (defined) {
       return this.sourceNodeHelper(nameItem, defined, nameItem.name); // 第3引数は要調査
     }
@@ -778,20 +791,20 @@ export class Minifier {
           generateZeroes(length - (position + 1));
         if (
           isKeyword(this.currentIdentifier) ||
-          identifiersInUse.has(this.currentIdentifier)
+          this.minifier.identifiersInUse.has(this.currentIdentifier)
         ) {
           return this.generateIdentifier(nameItem, nested);
         }
-        identifierMap.set(nameItem.name, this.currentIdentifier);
+        this.minifier.identifierMap.set(nameItem.name, this.currentIdentifier);
         return this.generateIdentifier(nameItem, nested);
       }
       --position;
     }
     this.currentIdentifier = "a" + generateZeroes(length);
-    if (identifiersInUse.has(this.currentIdentifier)) {
+    if (this.minifier.identifiersInUse.has(this.currentIdentifier)) {
       return this.generateIdentifier(nameItem, nested);
     }
-    identifierMap.set(nameItem.name, this.currentIdentifier);
+    this.minifier.identifierMap.set(nameItem.name, this.currentIdentifier);
     return this.generateIdentifier(nameItem, nested);
 
     //    return this.sourceNodeHelper(nameItem, nameItem.name, nested ? nameItem.name : undefined);

package/src/cli.ts

@@ -3,12 +3,18 @@
 import fs from "fs";
 import path from "path";
 import { Command } from "commander";
-import Parser, { Options } from "luaparse";
-import { Chunk, Minifier } from "./ast2lua";
+import { Options } from "luaparse";
+import { Minifier, MinifierMode } from "./minifier";
 
 const program = new Command();
 
-program.version("0.1.0").description("A Lua minifier also outputs source map");
+program
+  .version("0.1.2")
+  .description("A Lua minifier also outputs source map")
+  .option(
+    "-m, --module-like-lua",
+    "require・dofileの動作を実際のLuaに近づけます"
+  );
 
 program.parse(process.argv);
 
@@ -21,61 +27,29 @@ const luaparseSetting: Partial<Options> = {
   scope: true,
 };
 
+const mode: MinifierMode = program.opts();
+
 luaFiles.forEach((fileName) => {
-  const includes = new Map<string, string>();
   const parsedFileName = path.parse(fileName);
 
-  function requireHelper(recursiveFilePath: string) {
-    const resolvePath = path.relative(
-      parsedFileName.dir,
-      path.join(
-        parsedFileName.dir,
-        recursiveFilePath.replaceAll(".", path.sep) + ".lua"
-      )
-    );
-    const fullResolvePath = path.join(parsedFileName.dir, resolvePath);
-
-    if (!includes.has(resolvePath) && fs.existsSync(fullResolvePath)) {
-      const code = fs.readFileSync(fullResolvePath).toString();
-      const ast = Parser.parse(code, luaparseSetting) as Chunk;
-      if ("globals" in ast) {
-        includes.set(resolvePath, code);
-        return new Minifier(resolvePath, ast, requireHelper).parse();
-      }
-      includes.set(resolvePath, "");
-      return undefined;
-    }
-  }
-
   if (fs.existsSync(fileName)) {
-    const code = fs.readFileSync(fileName).toString();
-    const ast = Parser.parse(code, luaparseSetting) as Chunk;
-    if ("globals" in ast) {
-      includes.set(parsedFileName.base, code);
-      const map = new Minifier(parsedFileName.base, ast, requireHelper).parse();
-
-      includes.forEach((v, k) => {
-        console.log(k);
-        map.setSourceContent(k, v);
-      });
-
-      const minFileName = path.format({
-        dir: parsedFileName.dir,
-        name: parsedFileName.name + ".min",
-        ext: ".lua",
-      });
-      const mapFileName = path.format({
-        dir: parsedFileName.dir,
-        name: parsedFileName.name,
-        ext: parsedFileName.ext + ".map",
-      });
-      map.add("\n--[[\n//# sourceMappingURL=" + mapFileName + "\n]]");
-
-      const sourceAndMap = map.toStringWithSourceMap();
-
-      fs.writeFileSync(minFileName, sourceAndMap.code);
-      fs.writeFileSync(mapFileName, JSON.stringify(sourceAndMap.map));
-    }
+    const map = new Minifier(fileName, luaparseSetting, mode).parse();
+    const minFileName = path.format({
+      dir: parsedFileName.dir,
+      name: parsedFileName.name + ".min",
+      ext: ".lua",
+    });
+    const mapFileName = path.format({
+      dir: parsedFileName.dir,
+      name: parsedFileName.name,
+      ext: parsedFileName.ext + ".map",
+    });
+    map.add("\n--[[\n//# sourceMappingURL=" + mapFileName + "\n]]");
+
+    const sourceAndMap = map.toStringWithSourceMap();
+
+    fs.writeFileSync(minFileName, sourceAndMap.code);
+    fs.writeFileSync(mapFileName, JSON.stringify(sourceAndMap.map));
   } else {
     console.error("No such file: " + fileName);
   }

package/src/minifier.ts

@@ -0,0 +1,114 @@
+import Parser, { Comment, Options } from "luaparse";
+import path from "path";
+import fs from "fs";
+import { SourceNode } from "source-map";
+import { Chunk, MinifyFile } from "./ast2lua";
+
+export interface MinifierMode {
+  moduleLikeLua: boolean;
+}
+
+export class Minifier {
+  readonly identifierMap: Map<string, string>;
+  readonly identifiersInUse: Set<string>;
+  readonly moduleSourceText: Map<string, string>;
+  readonly moduleSourceNode: Map<string, SourceNode>;
+  readonly moduleAST: Map<string, Chunk>;
+  readonly dir: string;
+  readonly entryModule: string;
+  readonly mode: MinifierMode;
+  readonly luaParseSettings: Partial<Options>;
+
+  constructor(
+    entryFilePath: string,
+    luaParseSettings: Partial<Options>,
+    mode: MinifierMode
+  ) {
+    this.identifierMap = new Map<string, string>();
+    this.identifiersInUse = new Set<string>();
+    this.moduleSourceText = new Map<string, string>();
+    this.moduleSourceNode = new Map<string, SourceNode>();
+    this.moduleAST = new Map<string, Chunk>();
+    this.luaParseSettings = luaParseSettings;
+    this.mode = mode;
+    const pn = path.parse(entryFilePath);
+    this.dir = pn.dir;
+    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 as
+      | Comment[]
+      | undefined;
+    if (comments) {
+      comments
+        .reverse()
+        .filter((v) => v.raw.includes("--#") || v.raw.includes("[[#"))
+        .forEach((comment) => {
+          sn.prepend([
+            new SourceNode(
+              comment.loc?.start.line || null,
+              comment.loc?.start.column || null,
+              this.entryModule, // 本当に自分のファイル名でよいかは要検討
+              comment.raw
+            )
+          ,"\n"]);
+        });
+    }
+
+    return sn;
+  }
+
+  parseModule(moduleName: string): SourceNode {
+    const resolvePath = moduleName.replaceAll(".", path.sep) + ".lua";
+    const fullResolvePath = path.join(this.dir, resolvePath);
+
+    if (this.moduleSourceNode.has(moduleName)) {
+      const res = this.moduleSourceNode.get(moduleName);
+      if (res) {
+        return res;
+      }
+    } else if (fs.existsSync(fullResolvePath)) {
+      const code = fs.readFileSync(fullResolvePath).toString();
+      const ast = Parser.parse(code, this.luaParseSettings) as Chunk;
+      if ("globals" in ast) {
+        ast.globals?.map((v) => this.identifiersInUse.add(v.name));
+
+        const sourceNode = new MinifyFile(
+          resolvePath,
+          ast,
+          this,
+          this.mode
+        ).parse(resolvePath === this.entryModule);
+
+        this.moduleSourceText.set(moduleName, code);
+        this.moduleAST.set(moduleName, ast);
+        this.moduleSourceNode.set(moduleName, sourceNode);
+        return sourceNode;
+      }
+    }
+    throw new Error(moduleName + " is not found");
+  }
+}