nadesiko3 3.7.21 → 3.7.22

package/core/src/nako3.mts

@@ -1,6 +1,6 @@
- 
- 
- 
+
+
+
 // deno-lint-ignore-file no-explicit-any
 /**
  * nadesiko v3
@@ -11,57 +11,28 @@ import { Ast, AstBlocks } from './nako_ast.mjs'
 // parser / lexer
 import { NakoParser } from './nako_parser3.mjs'
 import { NakoLexer } from './nako_lexer.mjs'
-import { NakoPrepare } from './nako_prepare.mjs'
 import { NakoGen, generateJS, NakoGenOptions, NakoGenResult } from './nako_gen.mjs'
-import { convertInlineIndent, convertIndentSyntax } from './nako_indent_inline.mjs'
-import { convertDNCL } from './nako_from_dncl.mjs'
-import { convertDNCL2 } from './nako_from_dncl2.mjs'
-import { SourceMappingOfTokenization, SourceMappingOfIndentSyntax, OffsetToLineColumn, subtractSourceMapByPreCodeLength } from './nako_source_mapping.mjs'
-import { NakoLexerError, NakoImportError, NakoSyntaxError, InternalLexerError } from './nako_errors.mjs'
+import { NakoSyntaxError } from './nako_errors.mjs'
 import { NakoLogger } from './nako_logger.mjs'
 import { NakoGlobal } from './nako_global.mjs'
+// 取り込み文(require)の処理 / プラグイン管理 (#2360)
+import { Dependencies, LoaderTool, listRequireStatements, NakoRequireHost, NakoRequireLoader, NakoRequireScanner } from './nako_require.mjs'
+import { NakoPluginHost, NakoPluginManager } from './nako_plugin_manager.mjs'
+// 字句解析 / 実行 / イベント / 基本プラグイン (#2360)
+import { LexResult, NakoTokenizer } from './nako_tokenizer.mjs'
+import { NakoRunner, NakoRunnerHost, newCompilerOptions } from './nako_runner.mjs'
+import { NakoEventEmitter } from './nako_event.mjs'
+import { registerBasicPlugins } from './nako_basic_plugins.mjs'
 // version info
 import coreVersion from './nako_core_version.mjs'
-// basic plugins
-import PluginSystem from './plugin_system.mjs'
-import PluginMath from './plugin_math.mjs'
-import PluginCSV from './plugin_csv.mjs'
-import PluginPromise from './plugin_promise.mjs'
-import PluginTOML from './plugin_toml.mjs'
-import PluginTest from './plugin_test.mjs'
-
-const cloneAsJSON = (x: any): any => JSON.parse(JSON.stringify(x))
-const PLUGIN_MIN_VERSION_INT = 600 // = minor * 100 + patch
 
 export interface NakoCompilerOption {
   useBasicPlugin: boolean;
 }
 
-/** インタプリタに「取り込み」文を追加するために用意するオブジェクト */
-export interface LoaderToolTask<T> {
-  task: Promise<T>;
-}
-export interface LoaderTool {
-  // type: 'nako3' | 'js' | 'invalid' | 'mjs'
-  resolvePath: (name: string, token: Token, fromFile: string) => { type: string, filePath: string };
-  readNako3: (filePath: string, token: Token) => LoaderToolTask<string>;
-  readJs: (filePath: string, token: Token) => LoaderToolTask<any>;
-}
-
-interface DependenciesItem {
-  tokens: Token[];
-  alias: Set<string>;
-  addPluginFile: () => void;
-  funclist: any;
-  moduleExport: any;
-}
-type Dependencies = { [key:string]:DependenciesItem }
-
-interface LexResult {
-  commentTokens: Token[];
-  tokens: Token[];
-  requireTokens: Token[];
-}
+// 分離したモジュールの型・関数は、外部から `nako3.mjs` 経由で参照されているため再エクスポートする (#2360)
+export type { LoaderTool, LoaderToolTask, Dependencies, DependenciesItem } from './nako_require.mjs'
+export { newCompilerOptions } from './nako_runner.mjs'
 
 type NakoVars = Map<string, any>
 
@@ -69,43 +40,33 @@ export interface NakoResetOption {
   needToClearPlugin: boolean
 }
 
-/** コンパイラ実行オプションを生成 */
-export function newCompilerOptions(initObj: Partial<CompilerOptions> = {}): CompilerOptions {
-  if (typeof initObj !== 'object') { initObj = {} }
-  initObj.testOnly = initObj.testOnly || false
-  initObj.resetEnv = initObj.resetEnv || false
-  initObj.resetAll = initObj.resetAll || false
-  initObj.preCode = initObj.preCode || ''
-  initObj.nakoGlobal = initObj.nakoGlobal || null
-  return initObj as CompilerOptions
-}
-
 /** なでしこコンパイラ */
 export class NakoCompiler {
   private nakoFuncList: FuncList
   private funclist: FuncList
   private moduleExport: ExportMap
-  private pluginFunclist: Record<string, FuncListItem>
-  private pluginfiles: Record<string, any>
-  private commandlist: Set<string>
-  private prepare: NakoPrepare
   private parser: NakoParser
-  private lexer: NakoLexer
-  private dependencies: Dependencies
+  /** プラグイン管理 (#2360) */
+  private pluginManager: NakoPluginManager
+  /** 取り込み文の処理 (#2360) */
+  private requireLoader: NakoRequireLoader
+  /** 字句解析 (#2360) */
+  private tokenizer: NakoTokenizer
+  /** プログラムの実行 (#2360) */
+  private runner: NakoRunner
+  /** イベント管理 (#2360) */
+  protected events: NakoEventEmitter
   private usedFuncs: Set<string>
   private codeGenerateor: {[key: string]: any}
   protected logger: NakoLogger
-  protected eventList: NakoEvent[]
   // global objects
   __varslist: NakoVars[]
   __locals: NakoVars
-   
+
   __self: NakoCompiler
   __vars: NakoVars
   __v0: NakoVars
   __v1: NakoVars
-  __globals: NakoGlobal[]
-  __globalObj: NakoGlobal|null // 現在のNakoGlobalオブジェクト
   __module: Record<string, Record<string, FuncListItem>>
   numFailures: number // エラーレポートの数を記録
   public version: string
@@ -131,37 +92,60 @@ export class NakoCompiler {
     // バージョンを設定
     this.version = coreVersion.version
     this.coreVersion = coreVersion.version
-    this.__globals = [] // 生成した NakoGlobal のインスタンスを保持
-    this.__globalObj = null
-    this.__module = {} // requireなどで取り込んだモジュールの一覧
-    this.pluginFunclist = {} // プラグインで定義された関数
     this.funclist = this.newVaiables() // プラグインで定義された関数 + ユーザーが定義した関数
     this.moduleExport = this.newVaiables()
-    this.pluginfiles = {} // 取り込んだファイル一覧
-    this.commandlist = new Set() // プラグインで定義された定数・変数・関数の名前
     this.nakoFuncList = this.newVaiables() // __v1に配置するJavaScriptのコードで定義された関数
-    this.eventList = [] // 実行前に環境を変更するためのイベント
     this.codeGenerateor = {} // コードジェネレータ
     this.debugOption = { useDebug: false, waitTime: 0 }
 
     this.logger = new NakoLogger()
     this.filename = 'main.nako3'
 
-    /**
-     * 取り込み文を置換するためのオブジェクト。
-     * 正規化されたファイル名がキーになり、取り込み文の引数に指定された正規化されていないファイル名はaliasに入れられる。
-     * JavaScriptファイルによるプラグインの場合、contentは空文字列。
-     * funclistはシンタックスハイライトの高速化のために事前に取り出した、ファイルが定義する関数名のリスト。
-     */
-    this.dependencies = {}
+    // 実行前に環境を変更するためのイベント (#2360)
+    this.events = new NakoEventEmitter()
+
+    // プラグイン管理を生成する (#2360)
+    const pluginHost: NakoPluginHost = {
+      getFuncList: () => this.funclist, // reset() で差し替わるため、その都度参照する
+      getSysVars: () => this.__varslist[0],
+      getLogger: () => this.logger
+    }
+    this.pluginManager = new NakoPluginManager(pluginHost)
+    // requireなどで取り込んだモジュールの一覧(プラグイン管理と同じオブジェクトを共有する)
+    this.__module = this.pluginManager.modules
+
+    // 取り込み文の処理を生成する (#2360)
+    const requireHost: NakoRequireHost = {
+      rawtokenize: (code, line, filename, preCode) => this.rawtokenize(code, line, filename, preCode),
+      addPluginFromFile: (fpath, po, persistent) => this.addPluginFromFile(fpath, po, persistent),
+      getLogger: () => this.logger,
+      // 名前空間(modList)を汚さないように、取り込み文の検出には別のコンパイラを使う
+      createScanner: (): NakoRequireScanner => new NakoCompiler({ useBasicPlugin: true }),
+      countFailure: () => { this.numFailures++ }
+    }
+    this.requireLoader = new NakoRequireLoader(requireHost)
+
+    // 実行部を生成する (#2360)
+    const runnerHost: NakoRunnerHost = {
+      compileFromCode: (code, filename, opts) => this.compileFromCode(code, filename, opts),
+      createNakoGlobal: (gen: NakoGen, guid: number) => new NakoGlobal(this, gen, guid),
+      getLogger: () => this.logger,
+      fireEvent: (eventName, event) => { this.events.fire(eventName, event) }
+    }
+    this.runner = new NakoRunner(runnerHost)
+
     this.usedFuncs = new Set()
     this.numFailures = 0
 
     if (options.useBasicPlugin) { this.addBasicPlugins() }
     // 必要なオブジェクトを覚えておく
-    this.prepare = NakoPrepare.getInstance()
     this.parser = new NakoParser(this.logger)
-    this.lexer = new NakoLexer(this.logger)
+    // 字句解析を生成する (#2360)
+    this.tokenizer = new NakoTokenizer({
+      getLogger: () => this.logger,
+      replaceRequireStatements: (tokens, includeGuard) => this.replaceRequireStatements(tokens, includeGuard),
+      removeRequireStatements: (tokens) => this.removeRequireStatements(tokens)
+    })
     // 関数一覧を設定
     this.lexer.setFuncList(this.funclist)
     this.lexer.setModuleExport(this.moduleExport)
@@ -171,9 +155,37 @@ export class NakoCompiler {
     this.josiList = JSON.parse(JSON.stringify(this.lexer.josiList))
   }
 
+  /** 字句解析器(実体は NakoTokenizer が所有する) */
+  private get lexer (): NakoLexer {
+    return this.tokenizer.lexer
+  }
+
+  /** 実行前に環境を変更するためのイベント一覧 */
+  protected get eventList (): NakoEvent[] {
+    return this.events.getEventList()
+  }
+
+  /** 生成した NakoGlobal のインスタンスを保持 */
+  get __globals (): NakoGlobal[] {
+    return this.runner.globals
+  }
+
+  set __globals (values: NakoGlobal[]) {
+    this.runner.globals = values
+  }
+
+  /** 現在のNakoGlobalオブジェクト */
+  get __globalObj (): NakoGlobal|null {
+    return this.runner.currentGlobal
+  }
+
+  set __globalObj (value: NakoGlobal|null) {
+    this.runner.currentGlobal = value
+  }
+
   /** モジュール(名前空間)の一覧を取得する */
   getModList(): string[] {
-    return this.lexer.modList
+    return this.tokenizer.getModList()
   }
 
   getLogger(): NakoLogger {
@@ -189,19 +201,26 @@ export class NakoCompiler {
   }
 
   getPluginfiles(): Record<string, any> {
-    return this.pluginfiles
+    return this.pluginManager.pluginfiles
+  }
+
+  /**
+   * 取り込み文を置換するためのオブジェクト。
+   * 正規化されたファイル名がキーになり、取り込み文の引数に指定された正規化されていないファイル名はaliasに入れられる。
+   * JavaScriptファイルによるプラグインの場合、contentは空文字列。
+   * funclistはシンタックスハイライトの高速化のために事前に取り出した、ファイルが定義する関数名のリスト。
+   * (エディタのシンタックスハイライトから参照される)
+   */
+  get dependencies (): Dependencies {
+    return this.requireLoader.dependencies
   }
 
   /**
    * 基本的なプラグインを追加する
+   * (プラグインの一覧は nako_basic_plugins.mts にある)
    */
   addBasicPlugins() {
-    this.addPlugin(PluginSystem)
-    this.addPlugin(PluginMath)
-    this.addPlugin(PluginPromise)
-    this.addPlugin(PluginTest)
-    this.addPlugin(PluginCSV)
-    this.addPlugin(PluginTOML)
+    registerBasicPlugins(this)
   }
 
   /**
@@ -214,175 +233,31 @@ export class NakoCompiler {
 
   /**
    * ファイル内のrequire文の位置を列挙する。出力の配列はstartでソートされている。
+   * (実体は nako_require.mts の listRequireStatements)
    * @param {Token[]} tokens rawtokenizeの出力
    */
-  static listRequireStatements(tokens: Token[]): Token[] {
-    const requireStatements: Token[] = []
-    for (let i = 0; i + 2 < tokens.length; i++) {
-      // not (string|string_ex) '取り込み'
-      if (!(tokens[i].type === 'not' &&
-        (tokens[i + 1].type === 'string' || tokens[i + 1].type === 'string_ex') &&
-        tokens[i + 2].value === '取込')) {
-        continue
-      }
-      // 取り込むライブラリ
-      let filename = String(tokens[i + 1].value) + ''
-      // 全角コロン「：」を半角コロン「:」に正規化する（「貯蔵庫：」「拡張プラグイン：」の記法に対応 #2282）
-      filename = filename.replace(/^(貯蔵庫|拡張プラグイン)：/, '$1:')
-      // 『取り込む』文で「拡張プラグイン:」機構を追加する #139
-      // (ex) !『貯蔵庫:ojyo-sama.nako3』を取り込む → https://n3s.nadesi.com/plain/ojyo-sama.nako3
-      if (filename.startsWith('貯蔵庫:') || filename.startsWith('貯蔵庫：')) {
-        filename = `https://n3s.nadesi.com/plain/${filename.substring(4)}`
-      }
-      // (ex) !『拡張プラグイン:music.js@1.0.2』を取り込む → https://cdn.jsdelivr.net/npm/nadesiko3-music@1.0.2/nadesiko3-music.js
-      if (filename.startsWith('拡張プラグイン:') || filename.startsWith('拡張プラグイン：')) {
-        const name = filename.substring('拡張プラグイン:'.length)
-        const m = name.match(/^([a-zA-Z0-9_-]+)\.(js|mjs|nako3)(@[0-9.]+)?$/)
-        if (m) {
-          let basename = m[1]
-          const ext = m[2]
-          const version = m[3] || '@latest'
-          if (ext === 'js' || ext === 'mjs') {
-            // JSプラグイン
-            if (!basename.startsWith('nadesiko3-')) {
-              basename = `nadesiko3-${basename}`
-            }
-            filename = `https://cdn.jsdelivr.net/npm/${basename}${version}/${basename}.${ext}`
-          } else {
-            // なでしこ3プラグイン
-            filename = `https://n3s.nadesi.com/plain/${basename}.${ext}`
-          }
-        } else {
-          throw new NakoImportError('『取込』の指定エラー。『拡張プラグイン:(ファイル名).(js|nako3)(@ver)』の書式で指定してください。', tokens[i].file, tokens[i].line)
-        }
-      }
-      // push
-      requireStatements.push({
-        ...tokens[i],
-        start: i,
-        end: i + 3,
-        value: filename,
-        firstToken: tokens[i],
-        lastToken: tokens[i + 2]
-      })
-      i += 2
-    }
-    return requireStatements
+  static listRequireStatements (tokens: Token[]): Token[] {
+    return listRequireStatements(tokens)
   }
 
   /**
    * プログラムが依存するファイルを再帰的に取得する。
-   * - 依存するファイルがJavaScriptファイルの場合、そのファイルを実行して評価結果をthis.addPluginFileに渡す。
-   * - 依存するファイルがなでしこ言語の場合、ファイルの中身を取得して変数に保存し、再帰する。
+   * (実体は nako_require.mts の NakoRequireLoader.load)
    *
    * @param {string} code
    * @param {string} filename
    * @param {string} preCode
    * @param {LoaderTool} tools 実行環境 (ブラウザ or Node.js) によって外部ファイルの取得・実行方法は異なるため、引数でそれらを行う関数を受け取る。
-   *  - resolvePath は指定した名前をもつファイルを検索し、正規化されたファイル名を返す関数。返されたファイル名はreadNako3かreadJsの引数になる。
-   *  - readNako3は指定されたファイルの中身を返す関数。
-   *  - readJsは指定したファイルをJavaScriptのプログラムとして実行し、`export default` でエクスポートされた値を返す関数。
    * @returns {Promise<unknown> | void}
    * @protected
    */
-  _loadDependencies(code: string, filename: string, preCode: string, tools: LoaderTool) {
-    const dependencies: Dependencies = {}
-    const compiler = new NakoCompiler({ useBasicPlugin: true })
-    /**
-     * @param {any} item
-     * @param {any} tasks
-     */
-    const loadJS = (item: any, tasks: any) => {
-      // jsならプラグインとして読み込む。(ESMでは必ず動的に読む)
-      const obj = tools.readJs(item.filePath, item.firstToken)
-      tasks.push(obj.task.then((res: any) => {
-        const pluginFuncs = res()
-        this.addPluginFromFile(item.filePath, pluginFuncs)
-        dependencies[item.filePath].funclist = pluginFuncs
-        dependencies[item.filePath].moduleExport = {}
-        dependencies[item.filePath].addPluginFile = () => { this.addPluginFromFile(item.filePath, pluginFuncs) }
-      }))
-    }
-    const loadNako3 = (item: any, tasks: any) => {
-      // nako3ならファイルを読んでdependenciesに保存する。
-      const content = tools.readNako3(item.filePath, item.firstToken)
-      const registerFile = (code: string) => {
-        // シンタックスハイライトの高速化のために、事前にファイルが定義する関数名のリストを取り出しておく。
-        // preDefineFuncはトークン列に変更を加えるため、事前にクローンしておく。
-        // 「プラグイン名設定」を行う (#956)
-        const modName = NakoLexer.filenameToModName(item.filePath)
-        code = `『${modName}』に名前空間設定;『${modName}』にプラグイン名設定;` + code + ';名前空間ポップ;'
-        const tokens = this.rawtokenize(code, 0, item.filePath)
-        dependencies[item.filePath].tokens = tokens
-        const funclist = new Map()
-        const moduleexport = new Map()
-        NakoLexer.preDefineFunc(cloneAsJSON(tokens), this.logger, funclist, moduleexport)
-        dependencies[item.filePath].funclist = funclist
-        dependencies[item.filePath].moduleExport = moduleexport
-        // 再帰
-        return loadRec(code, item.filePath, '')
-      }
-      // 取り込み構文における問題を減らすため、必ず非同期でプログラムを読み込む仕様とした #1219
-      tasks.push(content.task.then((res) => registerFile(res)))
-    }
-    const loadRec = (code: string, filename: string, preCode: string): Promise<unknown>|void => {
-      const tasks: Promise<unknown>[] = []
-      // 取り込みが必要な情報一覧を調べる(トークン分割して、取り込みタグを得る)
-      const tags = NakoCompiler.listRequireStatements(compiler.rawtokenize(code, 0, filename, preCode))
-      // パスを解決する
-      const tagsResolvePath = tags.map((v) => ({ ...v, ...tools.resolvePath(v.value, v.firstToken as Token, filename) }))
-      // 取り込み開始
-      for (const item of tagsResolvePath) {
-        // 2回目以降の読み込み
-        // eslint-disable-next-line no-prototype-builtins
-        if (dependencies.hasOwnProperty(item.filePath)) {
-          dependencies[item.filePath].alias.add(item.value)
-          continue
-        }
-
-        // 初回の読み込み
-         
-        dependencies[item.filePath] = { tokens: [], alias: new Set([item.value]), addPluginFile: ():void => {}, funclist: {}, moduleExport: {} }
-        if (item.type === 'js' || item.type === 'mjs') {
-          loadJS(item, tasks)
-        } else if (item.type === 'nako3') {
-          loadNako3(item, tasks)
-        } else {
-          throw new NakoImportError(`ファイル『${String(item.value)}』を読み込めません。ファイルが存在しないか未対応の拡張子です。`,
-            (item.firstToken as Token).file, (item.firstToken as Token).line)
-        }
-      }
-      if (tasks.length > 0) {
-        return Promise.all(tasks)
-      }
-      return undefined
-    }
-
-    try {
-      const result = loadRec(code, filename, preCode)
-
-      // 非同期な場合のエラーハンドリング
-      if (result !== undefined) {
-        result.catch((err) => {
-          // 読み込みに失敗したら処理を中断する
-          this.logger.error(err.msg)
-          this.numFailures++
-        })
-      }
-
-      // すべてが終わってからthis.dependenciesに代入する。そうしないと、「実行」ボタンを連打した場合など、
-      // loadDependencies() が並列実行されるときに正しく動作しない。
-      this.dependencies = dependencies
-      return result
-    } catch (err) {
-      // 同期処理では素直に例外を投げる
-      this.logger.error(String(err))
-      throw err
-    }
+  _loadDependencies (code: string, filename: string, preCode: string, tools: LoaderTool): Promise<unknown>|void {
+    return this.requireLoader.load(code, filename, preCode, tools)
   }
 
   /**
    * コードを単語に分割する
+   * (実体は nako_tokenizer.mts の NakoTokenizer.rawtokenize)
    * @param code なでしこのプログラム
    * @param line なでしこのプログラムの行番号
    * @param filename
@@ -390,79 +265,19 @@ export class NakoCompiler {
    * @returns トークンのリスト
    */
   rawtokenize(code: string, line: number, filename: string, preCode = ''): Token[] {
-    if (!code.startsWith(preCode)) {
-      throw new Error('codeの先頭にはpreCodeを含める必要があります。')
-    }
-    // 名前空間のモジュールリストに自身を追加
-    const modName = NakoLexer.filenameToModName(filename)
-    const modList = this.getModList()
-    if (modList.indexOf(modName) < 0) { modList.unshift(modName) }
-    // 全角半角の統一処理
-    const preprocessed = this.prepare.convert(code)
-    const tokenizationSourceMapping = new SourceMappingOfTokenization(code.length, preprocessed)
-    const indentationSyntaxSourceMapping = new SourceMappingOfIndentSyntax(code, [], [])
-    const offsetToLineColumn = new OffsetToLineColumn(code)
-    // トークン分割
-    let tokens: Token[]
-    try {
-      tokens = this.lexer.tokenize(preprocessed.map((v) => v.text).join(''), line, filename)
-    } catch (err) {
-      if (!(err instanceof InternalLexerError)) {
-        throw err
-      }
-      // エラー位置をソースコード上の位置に変換して返す
-      const dest = indentationSyntaxSourceMapping.map(tokenizationSourceMapping.map(err.preprocessedCodeStartOffset), tokenizationSourceMapping.map(err.preprocessedCodeEndOffset))
-      const line: number|undefined = dest.startOffset === null ? err.line : offsetToLineColumn.map(dest.startOffset, false).line
-      const map = subtractSourceMapByPreCodeLength({ ...dest, line }, preCode)
-      throw new NakoLexerError(err.msg, map.startOffset, map.endOffset, map.line, filename)
-    }
-    // DNCL ver2 (core #41)
-    tokens = convertDNCL2(tokens)
-    // DNCL ver1 (#1140)
-    tokens = convertDNCL(tokens)
-    // インデント構文を変換 #596
-    tokens = convertIndentSyntax(tokens)
-    // インラインインデントを変換 #1215
-    tokens = convertInlineIndent(tokens)
-
-    // ソースコード上の位置に変換
-    tokens = tokens.map((token) => {
-      const dest = indentationSyntaxSourceMapping.map(
-        tokenizationSourceMapping.map(token.preprocessedCodeOffset || 0),
-        tokenizationSourceMapping.map((token.preprocessedCodeOffset || 0) + (token.preprocessedCodeLength || 0))
-      )
-      let line = token.line
-      let column = 0
-      if (token.type === 'eol' && dest.endOffset !== null) {
-        // eolはnako_genで `line = ${eolToken.line};` に変換されるため、
-        // 行末のeolのlineは次の行の行数を表す必要がある。
-        const out = offsetToLineColumn.map(dest.endOffset, false)
-        line = out.line
-        column = out.column
-      } else if (dest.startOffset !== null) {
-        const out = offsetToLineColumn.map(dest.startOffset, false)
-        line = out.line
-        column = out.column
-      }
-      return {
-        ...token,
-        ...subtractSourceMapByPreCodeLength({ line, column, startOffset: dest.startOffset, endOffset: dest.endOffset }, preCode),
-        rawJosi: token.josi
-      }
-    })
-    return tokens
+    return this.tokenizer.rawtokenize(code, line, filename, preCode)
   }
 
   /**
    * 単語の属性を構文解析に先立ち補正する
+   * (実体は nako_tokenizer.mts の NakoTokenizer.converttoken)
    * @param {Token[]} tokens トークンのリスト
    * @param {boolean} isFirst 最初の呼び出しかどうか
    * @param {string} filename
    * @returns コード (なでしこ)
    */
   converttoken(tokens: Token[], isFirst: boolean, filename: string): Token[] {
-    const tok = this.lexer.replaceTokens(tokens, isFirst, filename)
-    return tok
+    return this.tokenizer.converttoken(tokens, isFirst, filename)
   }
 
   /**
@@ -477,7 +292,7 @@ export class NakoCompiler {
       // そのため、例外的にオプションを指定すると、プラグインのクリアイベントを呼ばない
       try {
         this.clearPlugins()
-      } catch (_) {
+      } catch {
         // pass
       }
     }
@@ -494,14 +309,7 @@ export class NakoCompiler {
     this.__locals = this.newVaiables()
 
     // プラグイン命令以外を削除する。
-    this.funclist = new Map()
-    for (const name of this.__v0.keys()) {
-      const original = this.pluginFunclist[name] // record
-      if (!original) {
-        continue
-      }
-      this.funclist.set(name, JSON.parse(JSON.stringify(original)))
-    }
+    this.funclist = this.pluginManager.createFuncListFromPlugins(this.__v0)
 
     this.lexer.setFuncList(this.funclist)
 
@@ -513,6 +321,7 @@ export class NakoCompiler {
 
   /**
    * typeがcodeのトークンを単語に分割するための処理
+   * (実体は nako_tokenizer.mts の NakoTokenizer.lexCodeToken)
    * @param {string} code
    * @param {number} line
    * @param {string} filename
@@ -521,131 +330,37 @@ export class NakoCompiler {
    * @private
    */
   lexCodeToken(code: string, line: number, filename: string, startOffset: number|null): {commentTokens: Token[], tokens: Token[]} {
-    // 単語に分割
-    let tokens = this.rawtokenize(code, line, filename, '')
-
-    // 文字列内位置からファイル内位置へ変換
-    if (startOffset === null) {
-      for (const token of tokens) {
-        token.startOffset = undefined
-        token.endOffset = undefined
-      }
-    } else {
-      for (const token of tokens) {
-        if (token.startOffset !== undefined) {
-          token.startOffset += startOffset
-        }
-        if (token.endOffset !== undefined) {
-          token.endOffset += startOffset
-        }
-      }
-    }
-
-    // convertTokenで消されるコメントのトークンを残す
-    const commentTokens = tokens.filter((t) => t.type === 'line_comment' || t.type === 'range_comment')
-      .map((v) => ({ ...v })) // clone
-
-    tokens = this.converttoken(tokens, false, filename)
-
-    return { tokens, commentTokens }
+    return this.tokenizer.lexCodeToken(code, line, filename, startOffset)
   }
 
   /**
    * 再帰的にrequire文を置換する。
    * .jsであれば削除し、.nako3であればそのファイルのトークン列で置換する。
-   * @param {TokenWithSourceMap[]} tokens
+   * (実体は nako_require.mts の NakoRequireLoader.replaceRequireStatements)
+   * @param {Token[]} tokens
    * @param {Set<string>} [includeGuard]
    * @returns {Token[]} 削除された取り込み文のトークン
    */
-  replaceRequireStatements(tokens: Token[], includeGuard:Set<string> = new Set()): Token[] {
-    /** @type {TokenWithSourceMap[]} */
-    const deletedTokens = []
-    for (const r of NakoCompiler.listRequireStatements(tokens).reverse()) {
-      // C言語のinclude guardと同じ仕組みで無限ループを防ぐ。
-      if (includeGuard.has(r.value)) {
-        deletedTokens.push(...tokens.splice((r.start || 0), (r.end || 0) - (r.start || 0)))
-        continue
-      }
-      const filePath = Object.keys(this.dependencies).find((key) => this.dependencies[key].alias.has(r.value))
-      if (filePath === undefined) {
-        if (!r.firstToken) { throw new Error(`ファイル『${String(r.value)}』が読み込まれていません。`) }
-        throw new NakoLexerError(`ファイル『${String(r.value)}』が読み込まれていません。`,
-          (r.firstToken).startOffset || 0,
-          (r.firstToken).endOffset || 0,
-          (r.firstToken).line, (r.firstToken).file)
-      }
-      this.dependencies[filePath].addPluginFile()
-      const children = cloneAsJSON(this.dependencies[filePath].tokens)
-      includeGuard.add(r.value)
-      deletedTokens.push(...this.replaceRequireStatements(children, includeGuard))
-      deletedTokens.push(...tokens.splice(r.start || 0, (r.end || 0) - (r.start || 0), ...children))
-    }
-    return deletedTokens
+  replaceRequireStatements (tokens: Token[], includeGuard: Set<string> = new Set()): Token[] {
+    return this.requireLoader.replaceRequireStatements(tokens, includeGuard)
   }
 
   /**
    * replaceRequireStatementsのシンタックスハイライト用の実装。
-   * @param {TokenWithSourceMap[]} tokens
-   * @returns {TokenWithSourceMap[]} 削除された取り込み文のトークン
+   * (実体は nako_require.mts の NakoRequireLoader.removeRequireStatements)
+   * @param {Token[]} tokens
+   * @returns {Token[]} 削除された取り込み文のトークン
    */
-  removeRequireStatements(tokens: Token[]): Token[] {
-    /** @type {TokenWithSourceMap[]} */
-    const deletedTokens = []
-    for (const r of NakoCompiler.listRequireStatements(tokens).reverse()) {
-      // プラグイン命令のシンタックスハイライトのために、addPluginFileを呼んで関数のリストをthis.dependencies[filePath].funclistに保存させる。
-      const filePath = Object.keys(this.dependencies).find((key) => this.dependencies[key].alias.has(r.value))
-      if (filePath !== undefined) {
-        this.dependencies[filePath].addPluginFile()
-      }
-
-      // 全ての取り込み文を削除する。そうしないとトークン化に時間がかかりすぎる。
-      deletedTokens.push(...tokens.splice(r.start || 0, (r.end || 0) - (r.start || 0)))
-    }
-    return deletedTokens
+  removeRequireStatements (tokens: Token[]): Token[] {
+    return this.requireLoader.removeRequireStatements(tokens)
   }
 
-  /** 字句解析を行う */
+  /**
+   * 字句解析を行う
+   * (実体は nako_tokenizer.mts の NakoTokenizer.lex)
+   */
   lex(code: string, filename = 'main.nako3', preCode = '', syntaxHighlighting = false): LexResult {
-    // 単語に分割
-    let tokens = this.rawtokenize(code, 0, filename, preCode)
-
-    // require文を再帰的に置換する
-    const requireStatementTokens = syntaxHighlighting ? this.removeRequireStatements(tokens) : this.replaceRequireStatements(tokens, undefined)
-    for (const t of requireStatementTokens) {
-      if (t.type === 'word' || t.type === 'not') {
-        t.type = 'require'
-      }
-    }
-    if (requireStatementTokens.length >= 3) {
-      // modList を更新
-      for (let i = 0; i < requireStatementTokens.length; i += 3) {
-        let modName = requireStatementTokens[i + 1].value
-        modName = NakoLexer.filenameToModName(modName)
-        if (this.lexer.modList.indexOf(modName) < 0) {
-          this.lexer.modList.push(modName)
-        }
-      }
-    }
-
-    // convertTokenで消されるコメントのトークンを残す
-    const commentTokens: Token[] = tokens.filter((t) => t.type === 'line_comment' || t.type === 'range_comment')
-      .map((v) => ({ ...v })) // clone
-
-    tokens = this.converttoken(tokens, true, filename)
-
-    // 'string_ex'トークンから変換された'code'トークンを字句解析する
-    for (let i = 0; i < tokens.length; i++) {
-      if (tokens[i] && tokens[i].type === 'code') {
-        const children = this.lexCodeToken(tokens[i].value, tokens[i].line, filename, tokens[i].startOffset || 0)
-        commentTokens.push(...children.commentTokens)
-        tokens.splice(i, 1, ...children.tokens)
-        i--
-      }
-    }
-
-    this.logger.trace('--- lex ---\n' + JSON.stringify(tokens, null, 2))
-
-    return { commentTokens, tokens, requireTokens: requireStatementTokens }
+    return this.tokenizer.lex(code, filename, preCode, syntaxHighlighting)
   }
 
   /**
@@ -698,7 +413,7 @@ export class NakoCompiler {
 
   deleteUnNakoFuncs(): Set<string> {
     for (const func of this.usedFuncs) {
-      if (!this.commandlist.has(func)) {
+      if (!this.pluginManager.hasCommand(func)) {
         this.usedFuncs.delete(func)
       }
     }
@@ -728,16 +443,16 @@ export class NakoCompiler {
       if (options.resetEnv) { this.reset() }
       if (options.resetAll) { this.clearPlugins() }
       // onBeforeParse
-      this.eventList.filter(o => o.eventName === 'beforeParse').map(e => e.callback(code))
+      this.events.fire('beforeParse', code)
       // parse
       const ast = this.parse(code, filename, options.preCode)
       // onBeforeGenerate
-      this.eventList.filter(o => o.eventName === 'beforeGenerate').map(e => e.callback(ast))
+      this.events.fire('beforeGenerate', ast)
       // generate
       const genOptions = new NakoGenOptions(options.testOnly)
       const outCode = this.generateCode(ast, genOptions)
       // onAfterGenerate
-      this.eventList.filter(o => o.eventName === 'afterGenerate').map(e => e.callback(outCode))
+      this.events.fire('afterGenerate', outCode)
       return outCode
     } catch (e: any) {
       this.logger.error(e)
@@ -782,55 +497,32 @@ export class NakoCompiler {
    * @param [preCode]
    * @deprecated 代わりにrunAsyncメソッドを使ってください。(core #52)
    */
-   
+
   async _run(code: string, fname: string, isReset: boolean, isTest: boolean, preCode = ''): Promise<NakoGlobal> {
-    const opts: CompilerOptions = newCompilerOptions({
-      resetEnv: isReset,
-      resetAll: isReset,
-      testOnly: isTest,
-      preCode
-    })
-    return this._runEx(code, fname, opts)
+    return this.runner.run(code, fname, isReset, isTest, preCode)
   }
 
-  /** 各プラグインをリセットする */
+  /**
+   * 各プラグインをリセットする
+   * (実体は nako_runner.mts の NakoRunner.clearPlugins)
+   */
   clearPlugins() {
-    // 他に実行している「なでしこ」があればクリアする
-    this.__globals.forEach((sys: NakoGlobal) => {
-      if (!sys) { return }
-      // core #56
-      sys.__setSysVar('__forceClose', true)
-      sys.reset()
-    })
-    this.__globals = [] // clear
+    this.runner.clearPlugins()
   }
 
   /**
    * 環境を指定してJavaScriptのコードを実行する
+   * (実体は nako_runner.mts の NakoRunner.evalJS)
    * @param code JavaScriptのコード
    * @param nakoGlobal 実行環境
    */
   private evalJS(code: string, nakoGlobal: NakoGlobal): void {
-    this.__globalObj = nakoGlobal // 現在のnakoGlobalを記録
-    this.__globalObj.lastJSCode = code
-    // 実行前に環境を初期化するイベントを実行(beforeRun)
-    this.eventList.filter(o => o.eventName === 'beforeRun').map(e => e.callback(nakoGlobal))
-    try {
-       
-      const f = new Function(nakoGlobal.lastJSCode)
-      f.apply(nakoGlobal)
-    } catch (err: any) {
-      // なでしこコードのエラーは抑止してログにのみ記録
-      nakoGlobal.numFailures++
-      this.getLogger().error(err)
-      throw err
-    }
-    // 実行後に終了イベントを実行(finish)
-    this.eventList.filter(o => o.eventName === 'finish').map(e => e.callback(nakoGlobal))
+    this.runner.evalJS(code, nakoGlobal)
   }
 
   /**
    * (非推奨) 同期的になでしこのプログラムcodeを実行する
+   * (実体は nako_runner.mts の NakoRunner.runSync)
    * @param code なでしこのプログラム
    * @param filename ファイル名
    * @param options オプション
@@ -838,50 +530,24 @@ export class NakoCompiler {
    * @deprecated 代わりにrunAsyncメソッドを使ってください。(core #52)
    */
   public runSync(code: string, filename: string, options: CompilerOptions|undefined = undefined): NakoGlobal {
-    // コンパイル
-    options = newCompilerOptions(options)
-    const out = this.compileFromCode(code, filename, options)
-    // 実行前に環境を生成
-    const nakoGlobal = this.getNakoGlobal(options, out.gen, filename)
-    // 実行
-    this.evalJS(out.runtimeEnv, nakoGlobal)
-    return nakoGlobal
+    return this.runner.runSync(code, filename, options)
   }
 
   /**
    * 非同期になでしこのプログラムcodeを実行する
+   * (実体は nako_runner.mts の NakoRunner.runAsync)
    * @param code なでしこのプログラム
    * @param filename ファイル名
    * @param options オプション
    * @returns 実行に利用したグローバルオブジェクト
    */
-   
+
   public async runAsync(code: string, filename: string, options: CompilerOptions|undefined = undefined): Promise<NakoGlobal> {
-    // コンパイル
-    options = newCompilerOptions(options)
-    const compiledCode = this.compileFromCode(code, filename, options)
-    // 実行前に環境を生成
-    const nakoGlobal = this.getNakoGlobal(options, compiledCode.gen, filename)
-    // 実行
-    this.evalJS(compiledCode.runtimeEnv, nakoGlobal)
-    return nakoGlobal
+    return this.runner.runAsync(code, filename, options)
   }
 
   private getNakoGlobal(options: CompilerOptions, gen: NakoGen, filename: string): NakoGlobal {
-    // オプションを参照
-    let g: NakoGlobal|null = options.nakoGlobal
-    if (!g) {
-      // 空ならば前回の値を参照(リセットするなら新規で作成する)
-      if (this.__globals.length > 0 && options.resetAll === false && options.resetEnv === false) {
-        g = this.__globals[this.__globals.length - 1]
-      } else {
-        g = new NakoGlobal(this, gen, (this.__globals.length + 1))
-      }
-      // 名前空間を設定
-      g.__varslist[0].set('名前空間', NakoLexer.filenameToModName(filename))
-    }
-    if (this.__globals.indexOf(g) < 0) { this.__globals.push(g) }
-    return g
+    return this.runner.getNakoGlobal(options, gen, filename)
   }
 
   /**
@@ -890,7 +556,7 @@ export class NakoCompiler {
    * @param callback コールバック関数
    */
   addListener(eventName: NakoComEventName, callback: (event:any) => void) {
-    this.eventList.push({ eventName, callback })
+    this.events.on(eventName, callback)
   }
 
   /**
@@ -901,10 +567,7 @@ export class NakoCompiler {
    * @param testOnly
    */
   test(code: string, fname: string, preCode = '', testOnly = false) {
-    const options = newCompilerOptions()
-    options.preCode = preCode
-    options.testOnly = testOnly
-    return this.runSync(code, fname, options)
+    return this.runner.test(code, fname, preCode, testOnly)
   }
 
   /**
@@ -934,102 +597,13 @@ export class NakoCompiler {
 
   /**
    * プラグイン・オブジェクトを追加
+   * (実体は nako_plugin_manager.mts の NakoPluginManager.addPlugin)
    * @param po プラグイン・オブジェクト
    * @param persistent falseのとき、次以降の実行では使えない
    * @param fpath ファイルパス
    */
-  addPlugin(po: {[key: string]: any}, persistent = true, fpath = ''): void {
-    // __v0を取得
-    const __v0 = this.__varslist[0]
-    // プラグインのメタ情報をチェック (#1034) (#1647)
-    let __pluginInfo = __v0.get('__pluginInfo')
-    if (!__pluginInfo) {
-      __pluginInfo = {}
-      __v0.set('__pluginInfo', __pluginInfo)
-    }
-    // バージョンチェック
-    let intVersion = 0
-    let pluginName = 'unknown'
-    let metaValue = { pluginName: 'unknown', nakoVersionResult: true, nakoVersion: '0.0.0', path: '' }
-    if (po.meta) {
-      if (po.meta.value && typeof (po.meta) === 'object') {
-        const meta = po.meta
-        metaValue = meta.value || { pluginName: 'unknown', nakoVersion: '0.0.0' }
-        pluginName = metaValue.pluginName || 'unknown'
-        // version check
-        const nakoVersion = (metaValue.nakoVersion || '0.0.0') + '.0.0'
-        const versions = nakoVersion.split('.').map((v) => parseInt(v))
-        intVersion = versions[1] * 100 + versions[2]
-        // fpath
-        metaValue.path = fpath
-      }
-    }
-    // unknown の場合は、関数名からプラグイン名を自動生成する
-    if (pluginName === 'unknown') {
-      pluginName = Object.keys(po).join('-')
-    }
-    // プラグイン名の重複を確認
-    if (__pluginInfo[pluginName] !== undefined) {
-      // プラグイン名が重複した場合はプラグインとして登録しない
-      return
-    }
-    // Windowsのパスやファイル名に使えない文字列があると、JSファイル書き出しでエラーになるので置換
-    const removeInvalidFilenameChars = (str: string): string => {
-      return str.replace(/[^a-zA-z0-9\-_\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF\u3400-\u4DBF\uF900-\uFAFF]/g, '_')
-    }
-    pluginName = removeInvalidFilenameChars(pluginName)
-    // プラグイン情報を記録
-    __pluginInfo[pluginName] = metaValue
-    // バージョンチェック
-    if (PLUGIN_MIN_VERSION_INT > intVersion) {
-      const keyStr: string = Object.keys(po).join(',')
-      if (pluginName === 'unknown') {
-        pluginName = keyStr.substring(0, 30) + '...'
-      }
-      if (pluginName !== '') {
-        const errMsg = `なでしこプラグイン『${pluginName}』は古い形式なので正しく動作しない可能性があります。` +
-          `(ランタイムの要求: ${PLUGIN_MIN_VERSION_INT}/プラグイン: ${intVersion})`
-        console.warn(errMsg, 'see', 'https://github.com/kujirahand/nadesiko3/issues/1647')
-        this.logger.warn(errMsg)
-        metaValue.nakoVersionResult = false
-      }
-    }
-    // 初期化とクリアを変換する
-    this.__module[pluginName] = po
-    this.pluginfiles[pluginName] = '*'
-    // `初期化`と`クリア`をチェック
-    if (typeof (po['初期化']) === 'object') {
-      const def = po['初期化']
-      delete po['初期化']
-      const initKey = `!${pluginName}:初期化`
-      po[initKey] = def
-    }
-    // プラグインの値を、なでしこシステム変数(Map)にコピー
-    for (const key in po) {
-      const v = po[key]
-      this.funclist.set(key, v)
-      if (persistent) {
-        this.pluginFunclist[key] = JSON.parse(JSON.stringify(v))
-      }
-      if (v.type === 'func') {
-        __v0.set(key, v.fn)
-        if (v.asyncFn) { // asyncFn を正しく実行するために pure に変更する (core#142)
-          v.pure = true
-        }
-      } else if (v.type === 'const' || v.type === 'var') {
-        // メタ情報としての const | var は現在利用していない
-        // meta[key] = { readonly: v.type === 'const' }
-        __v0.set(key, v.value)
-      } else {
-        console.error('[プラグイン追加エラー]', v)
-        throw new Error('プラグインの追加でエラー。')
-      }
-      // コマンドを登録するか?
-      if (key === '初期化' || key.substring(0, 1) === '!') { // 登録しない関数名
-        continue
-      }
-      this.commandlist.add(key)
-    }
+  addPlugin (po: {[key: string]: any}, persistent = true, fpath = ''): void {
+    this.pluginManager.addPlugin(po, persistent, fpath)
   }
 
   /**
@@ -1038,12 +612,8 @@ export class NakoCompiler {
    * @param po 関数リスト
    * @param persistent falseのとき、次以降の実行では使えない
    */
-  addPluginObject(objName: string, po: {[key: string]: any}, persistent = true): void {
-    // metaプロパティがなければ互換性のため適当に追加
-    if (po.meta === undefined) {
-      po.meta = { type: 'const', value: { pluginName: objName, nakoVersion: '0.0.0' } }
-    }
-    this.addPlugin(po, persistent)
+  addPluginObject (objName: string, po: {[key: string]: any}, persistent = true): void {
+    this.pluginManager.addPluginObject(objName, po, persistent)
   }
 
   /**
@@ -1054,18 +624,18 @@ export class NakoCompiler {
    * @param persistent falseのとき、次以降の実行では使えない
    * @deprecated 利用は非推奨
    */
-  addPluginFile(_objName: string, fpath: string, po: {[key: string]: any}, persistent = true): void {
+  addPluginFile (_objName: string, fpath: string, po: {[key: string]: any}, persistent = true): void {
     this.addPluginFromFile(fpath, po, persistent)
   }
 
   /**
- * プラグイン・ファイルを追加(Node.js向け)
- * @param fpath ファイルパス
- * @param po 登録するオブジェクト
- * @param persistent falseのとき、次以降の実行では使えない
- */
-  addPluginFromFile(fpath: string, po: { [key: string]: any }, persistent = true): void {
-    this.addPlugin(po, persistent, fpath)
+   * プラグイン・ファイルを追加(Node.js向け)
+   * @param fpath ファイルパス
+   * @param po 登録するオブジェクト
+   * @param persistent falseのとき、次以降の実行では使えない
+   */
+  addPluginFromFile (fpath: string, po: { [key: string]: any }, persistent = true): void {
+    this.pluginManager.addPluginFromFile(fpath, po, persistent)
   }
 
   /**
@@ -1076,17 +646,14 @@ export class NakoCompiler {
    * @param {boolean} returnNone 値を返す関数の場合はfalseを指定
    * @param {boolean} asyncFn Promiseを返す関数かを指定
    */
-  addFunc(key: string, josi: FuncArgs, fn: any, returnNone = true, asyncFn = false): void {
-    const funcObj: FuncListItem = { josi, fn, type: 'func', return_none: returnNone, asyncFn, pure: true }
-    this.funclist.set(key, funcObj)
-    this.pluginFunclist[key] = cloneAsJSON(funcObj)
-    this.__varslist[0].set(key, fn)
+  addFunc (key: string, josi: FuncArgs, fn: any, returnNone = true, asyncFn = false): void {
+    this.pluginManager.addFunc(key, josi, fn, returnNone, asyncFn)
   }
 
   /** (非推奨) 互換性のため ... 関数を追加する
    * @deprecated 代わりにaddFuncを使ってください
   */
-  public setFunc(key: string, josi: FuncArgs, fn: any, returnNone = true, asyncFn = false): void {
+  public setFunc (key: string, josi: FuncArgs, fn: any, returnNone = true, asyncFn = false): void {
     this.addFunc(key, josi, fn, returnNone, asyncFn)
   }
 
@@ -1095,18 +662,16 @@ export class NakoCompiler {
    * @param key プラグイン関数の関数名
    * @returns プラグイン・オブジェクト
    */
-  getFunc(key: string): FuncListItem|undefined {
-    return this.funclist.get(key)
+  getFunc (key: string): FuncListItem|undefined {
+    return this.pluginManager.getFunc(key)
   }
 
   /** 同期的になでしこのプログラムcodeを実行する
+   * (実体は nako_runner.mts の NakoRunner.runEx)
    * @deprecated 代わりにrunAsyncメソッドを使ってください。(core #52)
    */
   private _runEx(code: string, filename: string, opts: CompilerOptions, preCode = '', nakoGlobal: NakoGlobal|undefined = undefined): NakoGlobal {
-    // コンパイル
-    opts.preCode = preCode
-    if (nakoGlobal) { opts.nakoGlobal = nakoGlobal }
-    return this.runSync(code, filename, opts)
+    return this.runner.runEx(code, filename, opts, preCode, nakoGlobal)
   }
 
   /** (非推奨) 同期的になでしこのプログラムcodeを実行する
@@ -1127,8 +692,7 @@ export class NakoCompiler {
    * @param [preCode]
    */
   async runReset(code: string, fname = 'main.nako3', preCode = ''): Promise<NakoGlobal> {
-    const opts = newCompilerOptions({ resetAll: true, resetEnv: true, preCode })
-    return this.runAsync(code, fname, opts)
+    return this.runner.runReset(code, fname, preCode)
   }
 
   /**