mm_os 4.3.6 → 5.0.0

package/lib/loader.js

@@ -0,0 +1,787 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+const { Base } = require('mm_corejs');
+const { appAdmin } = require('mm_app');
+
+/**
+ * 应用加载器类
+ *
+ * 扫描应用根目录下的各个应用，读取每个应用的配置文件（app.json），
+ * 通过 mm_app 的应用管理器（AppManager / App 驱动）加载应用并驱动其生命周期，
+ * 同时把应用下的资源清单（event.json / socket.json / mqtt.json / pendant.json /
+ * static.json）注册到 OS 对应的资源管理器。
+ *
+ * 应用与插件均由驱动对象承载：
+ *   App 驱动    由 this.apps（AppManager）管理，暴露 config / dir / file /
+ *               methods / resources，并通过 this.plugins（PluginManager）承载插件
+ *   Plugin 驱动 由 App 的 this.plugins 管理，结构与应用驱动类似
+ *
+ * 插件位于应用目录下的 plugin 目录中，结构为：
+ *   plugin/{插件名}/plugin.json   插件配置（可选，缺失时以目录名作为插件名）
+ *   plugin/{插件名}/index.js      插件入口（可选）
+ *   plugin/{插件名}/api_*\/...    插件级 api.json
+ *   plugin/{插件名}/event_api/... 插件级 event.json
+ *   plugin/{插件名}/static/...    插件级 static.json
+ */
+class Loader extends Base {
+  /**
+   * 加载器默认配置
+   * @type {object}
+   */
+  static config = {
+    // 名称
+    name: 'loader',
+    // 标题
+    title: '应用加载器',
+    // 描述
+    description: '扫描应用目录，加载应用配置、生命周期与资源清单',
+    // 应用根目录，为空时取 mm_os/example/app
+    dir: '',
+    // 应用与资源管理器作用域
+    scope: 'sys',
+    // 应用入口文件名
+    main: 'index.js',
+    // 应用配置文件名
+    config_file: 'app.json',
+    // 资源目录名 -> 管理器名称 / 模块名 / 清单文件名
+    resources: {
+      event_api: { admin: 'event', module: 'mm_event', file: 'event.json' },
+      socket: { admin: 'socket', module: 'mm_socket', file: 'socket.json' },
+      mqtt: { admin: 'mqtt', module: 'mm_mqtt', file: 'mqtt.json' },
+      pendant: { admin: 'pendant', module: 'mm_pendant', file: 'pendant.json' },
+      static: { admin: 'statics', module: 'mm_statics', file: 'static.json' }
+    },
+    // 生命周期阶段 -> 应用方法名（应用未自定义时的回落值）
+    lifecycle: {
+      load: ['install', 'init'],
+      start: ['start'],
+      stop: ['stop', 'uninstall']
+    },
+    // 插件配置
+    plugin: {
+      // 插件目录名
+      dir: 'plugin',
+      // 插件配置文件名，可缺失
+      config_file: 'plugin.json',
+      // 插件入口文件名，可缺失
+      main: 'index.js',
+      // 资源目录名 -> 管理器名称 / 模块名 / 清单文件名 / 子目录名（空串表示以插件目录为根）
+      resources: {
+        api: { admin: 'api', module: 'mm_api', file: 'api.json', sub_dir: '' },
+        event_api: { admin: 'event', module: 'mm_event', file: 'event.json' },
+        static: { admin: 'statics', module: 'mm_statics', file: 'static.json' }
+      },
+      // 生命周期阶段 -> 插件方法名（插件未自定义时的回落值）
+      lifecycle: {
+        load: ['install', '_init'],
+        start: ['start'],
+        stop: ['stop', 'uninstall']
+      }
+    }
+  };
+
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {object} server 框架实例
+   */
+  constructor(config, server) {
+    super(config, server);
+
+    /**
+     * 应用管理器，按作用域创建并托管应用驱动
+     * @type {object}
+     */
+    this.apps = appAdmin(this.config.scope);
+    this.apps.setServer(this.getServer());
+
+    /**
+     * 资源管理器缓存，键为资源目录名
+     * @type {Map}
+     */
+    this._managers = new Map();
+
+    /**
+     * 已输出过警告的资源目录名集合
+     * @type {Set}
+     */
+    this._warned = new Set();
+  }
+
+  // ---------- 生命周期钩子 ----------
+  /**
+   * 初始化钩子：加载全部应用
+   * @returns {Promise<void>} 无返回值
+   */
+  async onInit() {
+    await this.load();
+  }
+
+  /**
+   * 启动钩子：启动全部应用
+   * @returns {Promise<void>} 无返回值
+   */
+  async onStart() {
+    await this.startAll();
+  }
+
+  /**
+   * 停止钩子：停止全部应用
+   * @returns {Promise<void>} 无返回值
+   */
+  async onStop() {
+    await this.stopAll();
+  }
+
+  /**
+   * 释放钩子：清空应用与资源管理器缓存
+   * @returns {Promise<void>} 无返回值
+   */
+  async onDispose() {
+    await this.clear();
+  }
+
+  // ---------- 公开方法 ----------
+  /**
+   * 加载应用根目录下的全部应用
+   * @returns {Promise<void>} 无返回值
+   */
+  async load() {
+    if (this.getLogger()) {
+      this.apps.setLogger(this.getLogger());
+    }
+    const app_dir = this._getAppDir();
+    const dirs = this._listAppDirs(app_dir);
+    await this._loadApps(dirs);
+    this.log('info', `应用加载完成，共 ${this.apps.size()} 个`);
+  }
+
+  /**
+   * 启动全部应用
+   * @returns {Promise<void>} 无返回值
+   */
+  async startAll() {
+    for (const app of this.apps.values()) {
+      await this._startApp(app);
+    }
+  }
+
+  /**
+   * 停止全部应用
+   * @returns {Promise<void>} 无返回值
+   */
+  async stopAll() {
+    for (const app of this.apps.values()) {
+      await this._stopApp(app);
+    }
+  }
+
+  /**
+   * 获取应用
+   * @param {string} name 应用名称
+   * @returns {object} 应用驱动，不存在时返回 undefined
+   */
+  get(name) {
+    return this.apps.get(name);
+  }
+
+  /**
+   * 判断应用是否存在
+   * @param {string} name 应用名称
+   * @returns {boolean} 是否存在
+   */
+  has(name) {
+    return this.apps.has(name);
+  }
+
+  /**
+   * 获取应用列表
+   * @returns {Array} 应用驱动列表
+   */
+  list() {
+    return this.apps.values();
+  }
+
+  /**
+   * 重启应用：删除后重新加载，曾运行则再次启动
+   * @param {string} name 应用名称
+   * @returns {Promise<boolean>} 是否执行成功
+   */
+  async reload(name) {
+    const app = this.get(name);
+    if (!app) {
+      this.log('warn', `应用 ${name} 不存在，无法重启`);
+      return false;
+    }
+    const app_dir = app.dir;
+    const was_running = app.isRunning();
+    await this.apps.del(name);
+    const next = await this._loadApp(app_dir);
+    if (!next) return false;
+    if (was_running) {
+      await this._startApp(next);
+    }
+    return true;
+  }
+
+  /**
+   * 删除应用：停止并释放后从应用管理器移除
+   * @param {string} name 应用名称
+   * @returns {Promise<boolean>} 是否删除成功
+   */
+  async del(name) {
+    if (!this.has(name)) return false;
+    await this.apps.del(name);
+    return true;
+  }
+
+  /**
+   * 清空应用列表与资源管理器缓存
+   * @returns {Promise<void>} 无返回值
+   */
+  async clear() {
+    await this.apps.clear();
+    this._managers.clear();
+    this._warned.clear();
+  }
+
+  // ---------- 应用加载 ----------
+  /**
+   * 获取应用根目录，未配置时回落到 mm_os/example/app
+   * @returns {string} 应用根目录绝对路径
+   */
+  _getAppDir() {
+    if (this.config.dir) {
+      return path.resolve(this.config.dir);
+    }
+    return path.join(__dirname, '..', 'example', 'app');
+  }
+
+  /**
+   * 列出目录下的全部子目录，目录不存在时静默返回空列表
+   * @param {string} dir 目录绝对路径
+   * @returns {Array<string>} 子目录绝对路径列表
+   */
+  _listSubDirs(dir) {
+    if (!fs.existsSync(dir)) return [];
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+    return items.filter(item => item.isDirectory()).map(item => path.join(dir, item.name));
+  }
+
+  /**
+   * 列出应用根目录下的全部应用目录
+   * @param {string} dir 应用根目录绝对路径
+   * @returns {Array<string>} 应用目录绝对路径列表
+   */
+  _listAppDirs(dir) {
+    if (!fs.existsSync(dir)) {
+      this.log('warn', `应用根目录不存在: ${dir}`);
+      return [];
+    }
+    return this._listSubDirs(dir);
+  }
+
+  /**
+   * 批量加载应用目录
+   * @param {Array<string>} dirs 应用目录列表
+   * @returns {Promise<void>} 无返回值
+   */
+  async _loadApps(dirs) {
+    for (const app_dir of dirs) {
+      await this._loadApp(app_dir);
+    }
+  }
+
+  /**
+   * 加载单个应用：创建驱动、注册资源、加载插件并初始化
+   * @param {string} app_dir 应用目录绝对路径
+   * @returns {Promise<object>} 应用驱动，跳过或失败时返回 null
+   */
+  async _loadApp(app_dir) {
+    const config_file = path.join(app_dir, this.config.config_file);
+    if (!fs.existsSync(config_file)) return null;
+
+    const app_config = this._resolveFileTemplates(this._readJson(config_file), config_file);
+    if (!app_config) return null;
+
+    const app_name = app_config.name || path.basename(app_dir);
+    if (this.has(app_name)) {
+      this.log('warn', `应用 ${app_name} 已存在，跳过: ${app_dir}`);
+      return null;
+    }
+
+    const app = this.apps.add(this._buildAppConfig(app_dir, app_config, app_name));
+    if (this.getLogger()) {
+      app.setLogger(this.getLogger());
+    }
+    this._registerResources(app, app.dir, this.config.resources);
+    this._loadPlugins(app, app_dir);
+
+    try {
+      await app.init();
+    } catch (err) {
+      this.log('error', `应用 ${app_name} 初始化失败: ${err.message}`);
+    }
+    return app;
+  }
+
+  /**
+   * 构建应用驱动配置：补齐名称、目录、入口与生命周期
+   * @param {string} app_dir 应用目录绝对路径
+   * @param {object} app_config 应用配置（app.json 内容）
+   * @param {string} app_name 应用名称
+   * @returns {object} 应用驱动配置
+   */
+  _buildAppConfig(app_dir, app_config, app_name) {
+    return {
+      ...app_config,
+      name: app_name,
+      dir: app_dir,
+      main: app_config.main || this.config.main,
+      lifecycle: app_config.lifecycle || this.config.lifecycle
+    };
+  }
+
+  /**
+   * 启动单个应用，失败时记录日志
+   * @param {object} app 应用驱动
+   * @returns {Promise<void>} 无返回值
+   */
+  async _startApp(app) {
+    try {
+      await app.start();
+    } catch (err) {
+      this.log('error', `启动应用 ${app.config.name} 失败: ${err.message}`);
+    }
+  }
+
+  /**
+   * 停止单个应用，失败时记录日志
+   * @param {object} app 应用驱动
+   * @returns {Promise<void>} 无返回值
+   */
+  async _stopApp(app) {
+    try {
+      await app.stop();
+    } catch (err) {
+      this.log('error', `停止应用 ${app.config.name} 失败: ${err.message}`);
+    }
+  }
+
+  // ---------- 插件加载 ----------
+  /**
+   * 加载应用下的全部插件
+   * @param {object} app 应用驱动
+   * @param {string} app_dir 应用目录绝对路径
+   */
+  _loadPlugins(app, app_dir) {
+    const plugin_config = this.config.plugin;
+    if (!plugin_config) return;
+
+    const plugin_root = path.join(app_dir, plugin_config.dir);
+    const dirs = this._listSubDirs(plugin_root);
+    for (const plugin_dir of dirs) {
+      this._loadPlugin(app, plugin_dir);
+    }
+  }
+
+  /**
+   * 加载单个插件：创建驱动并注册资源
+   * @param {object} app 应用驱动
+   * @param {string} plugin_dir 插件目录绝对路径
+   * @returns {object} 插件驱动，跳过时返回 null
+   */
+  _loadPlugin(app, plugin_dir) {
+    const plugin_config = this.config.plugin;
+    const config_file = path.join(plugin_dir, plugin_config.config_file);
+    const raw = fs.existsSync(config_file) ? this._readJson(config_file) : null;
+    const config = raw ? this._resolveFileTemplates(raw, config_file) : null;
+
+    const plugin_name = config && config.name ? config.name : path.basename(plugin_dir);
+    if (config && config.state === 0) {
+      this.log('info', `插件 ${app.config.name}.${plugin_name} 已禁用，跳过`);
+      return null;
+    }
+    if (app.plugins.has(plugin_name)) {
+      this.log('warn', `插件 ${app.config.name}.${plugin_name} 已存在，跳过`);
+      return null;
+    }
+
+    const plugin = app.plugins.add(this._buildPluginConfig(app, plugin_dir, config, plugin_name));
+    if (this.getLogger()) {
+      plugin.setLogger(this.getLogger());
+    }
+    this._registerResources(plugin, plugin_dir, plugin_config.resources);
+    return plugin;
+  }
+
+  /**
+   * 构建插件驱动配置：补齐名称、所属应用、目录、入口与生命周期
+   * @param {object} app 应用驱动
+   * @param {string} plugin_dir 插件目录绝对路径
+   * @param {object} config 插件配置，可为空
+   * @param {string} plugin_name 插件名称
+   * @returns {object} 插件驱动配置
+   */
+  _buildPluginConfig(app, plugin_dir, config, plugin_name) {
+    const cfg = config || {};
+    return {
+      ...cfg,
+      name: plugin_name,
+      app: cfg.app || app.config.name,
+      dir: plugin_dir,
+      main: cfg.main || this.config.plugin.main,
+      lifecycle: cfg.lifecycle || this.config.plugin.lifecycle
+    };
+  }
+
+  // ---------- 资源注册 ----------
+  /**
+   * 注册归属对象下的全部资源
+   * @param {object} owner 归属对象（应用或插件驱动）
+   * @param {string} base_dir 基础目录绝对路径
+   * @param {object} resources 资源目录名 -> 资源配置
+   */
+  _registerResources(owner, base_dir, resources) {
+    const map = resources || {};
+    for (const res_name of Object.keys(map)) {
+      const res = map[res_name];
+      // 未声明子目录时以资源目录名为子目录，空串时以基础目录为根
+      const sub_dir = res.sub_dir === undefined ? res_name : res.sub_dir;
+      const root = sub_dir ? path.join(base_dir, sub_dir) : base_dir;
+      this._registerResource(owner, res_name, res, root);
+    }
+  }
+
+  /**
+   * 注册某一类资源
+   * @param {object} owner 归属对象（应用或插件驱动）
+   * @param {string} res_name 资源目录名
+   * @param {object} res 资源配置
+   * @param {string} root 资源搜索根目录绝对路径
+   */
+  _registerResource(owner, res_name, res, root) {
+    if (!fs.existsSync(root)) return;
+
+    const manager = this._getManager(owner, res_name, res);
+    if (!manager) return;
+
+    const files = this._listConfigFiles(root, res.file);
+    for (const file of files) {
+      this._addResource(owner, res_name, manager, file);
+    }
+  }
+
+  /**
+   * 注册单个资源清单
+   * @param {object} owner 归属对象（应用或插件驱动）
+   * @param {string} res_name 资源目录名
+   * @param {object} manager 资源管理器
+   * @param {string} file 资源清单绝对路径
+   */
+  _addResource(owner, res_name, manager, file) {
+    const config = this._resolveFileTemplates(this._readJson(file), file);
+    if (!config) return;
+    // 驱动依赖 dir 解析 app 名与入口脚本
+    config.dir = path.dirname(file);
+    const name = config.name;
+    if (name && typeof manager.has === 'function' && manager.has(name)) {
+      this.log('warn', `资源 ${res_name} 已存在，跳过 ${file}: ${name}`);
+      return;
+    }
+    try {
+      const drive = manager.add(config);
+      owner.resources.push({ type: res_name, name: drive.config.name, file, drive });
+    } catch (err) {
+      this.log('error', `注册资源 ${res_name} 失败 ${file}: ${err.message}`);
+    }
+  }
+
+  /**
+   * 递归列出目录下指定名称的清单文件
+   * @param {string} dir 目录绝对路径
+   * @param {string} filename 清单文件名
+   * @returns {Array<string>} 清单文件绝对路径列表
+   */
+  _listConfigFiles(dir, filename) {
+    const files = [];
+    const items = fs.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+      const full = path.join(dir, item.name);
+      if (item.isDirectory()) {
+        files.push(...this._listConfigFiles(full, filename));
+      } else if (item.name === filename) {
+        files.push(full);
+      }
+    }
+    return files;
+  }
+
+  /**
+   * 获取归属对象所在作用域下的资源管理器：按 owner 作用域惰性加载
+   * @param {object} owner 归属对象（应用或插件驱动）
+   * @param {string} res_name 资源目录名
+   * @param {object} res 资源配置
+   * @returns {object} 资源管理器，不可用时返回 null
+   */
+  _getManager(owner, res_name, res) {
+    const scope = this._getOwnerScope(owner);
+    const key = `${scope}:${res_name}`;
+    if (this._managers.has(key)) {
+      return this._managers.get(key);
+    }
+
+    const manager = this._getModuleManager(res, scope);
+    if (!manager) {
+      this._warnOnce(key, `未找到资源管理器 ${res.admin}(${res.module})，跳过 ${res_name} 资源`);
+      return null;
+    }
+    if (typeof manager.add !== 'function') {
+      this._warnOnce(key, `资源管理器 ${res.admin} 不支持 add 方法，跳过 ${res_name} 资源`);
+      return null;
+    }
+
+    this._managers.set(key, manager);
+    return manager;
+  }
+
+  /**
+   * 获取归属对象的作用域名：插件取所属应用名，应用取自身名称
+   * @param {object} owner 归属对象（应用或插件驱动）
+   * @returns {string} 作用域名
+   */
+  _getOwnerScope(owner) {
+    const config = owner && owner.config ? owner.config : {};
+    return config.app || config.name || this.config.scope;
+  }
+
+  /**
+   * 按模块名惰性加载，并在指定作用域创建资源管理器
+   * @param {object} res 资源配置
+   * @param {string} scope 作用域名
+   * @returns {object} 资源管理器，加载失败时返回 null
+   */
+  _getModuleManager(res, scope) {
+    if (!res.module) return null;
+
+    let mod;
+    try {
+      const server = this.getServer();
+      mod = server && typeof server.require === 'function'
+        ? server.require(res.module)
+        : require(res.module);
+    } catch (err) {
+      return null;
+    }
+
+    const admin = mod && mod.admin;
+    if (!admin || typeof admin.get !== 'function') return null;
+
+    if (typeof admin.setServer === 'function') {
+      try {
+        admin.setServer(this.getServer());
+      } catch (err) {
+        // 服务器实例已设置，忽略
+      }
+    }
+    return admin.get(scope, { name: scope });
+  }
+
+  /**
+   * 输出一次性警告
+   * @param {string} key 去重键
+   * @param {string} message 警告内容
+   */
+  _warnOnce(key, message) {
+    if (this._warned.has(key)) return;
+    this._warned.add(key);
+    this.log('warn', message);
+  }
+
+  // ---------- 配置读取 ----------
+  /**
+   * 对配置中的模板字段求值（如 `{name || 'api'}`），以上下文求值后返回新配置
+   * @param {object} config 原始配置对象
+   * @param {string} file 配置文件绝对路径
+   * @returns {object} 求值后的配置对象
+   */
+  _resolveFileTemplates(config, file) {
+    if (!config) return config;
+    const ctx = this._buildTemplateContext(path.dirname(file));
+    return this._resolveTemplates(config, ctx);
+  }
+
+  /**
+   * 由资源目录推导模板上下文（名称、应用名、插件名、接口路径）
+   * @param {string} dir 资源目录绝对路径
+   * @returns {object} 模板上下文
+   */
+  _buildTemplateContext(dir) {
+    const name = path.basename(dir);
+    const app_name = this._extractPathSegment(dir, 'app');
+    const plugin_name = this._extractPathSegment(dir, 'plugin');
+    return {
+      name,
+      app: app_name,
+      plugin: plugin_name,
+      path: app_name ? `/${app_name}/${name}` : `/${name}`
+    };
+  }
+
+  /**
+   * 提取路径中指定目录名之后的段落值
+   * @param {string} dir 目录绝对路径
+   * @param {string} key 段落名（如 app / plugin）
+   * @returns {string} 段落值，未找到时返回空串
+   */
+  _extractPathSegment(dir, key) {
+    const parts = dir.split(path.sep);
+    const index = parts.indexOf(key);
+    if (index !== -1 && index + 1 < parts.length) {
+      return parts[index + 1];
+    }
+    return '';
+  }
+
+  /**
+   * 递归求值配置对象中的模板字段
+   * @param {*} config 配置对象、数组或基础值
+   * @param {object} ctx 模板上下文
+   * @returns {*} 求值后的配置
+   */
+  _resolveTemplates(config, ctx) {
+    if (Array.isArray(config)) {
+      return config.map(item => this._resolveTemplates(item, ctx));
+    }
+    if (config && typeof config === 'object') {
+      const result = {};
+      for (const key of Object.keys(config)) {
+        result[key] = this._resolveTemplates(config[key], ctx);
+      }
+      return result;
+    }
+    return this._renderTemplateValue(config, ctx);
+  }
+
+  /**
+   * 求值单个字符串模板，非模板或纯数字占位（如 `{0}`）时原样返回
+   * @param {*} value 待求值内容
+   * @param {object} ctx 模板上下文
+   * @returns {*} 求值结果
+   */
+  _renderTemplateValue(value, ctx) {
+    if (typeof value !== 'string') return value;
+    const matched = value.match(/^\{\s*([^{}]+?)\s*\}$/);
+    if (!matched) return value;
+    const expr = matched[1];
+    if (/^[+-]?\d+(\.\d+)?$/.test(expr)) return value;
+    try {
+      return vm.runInNewContext(`(${expr})`, this._buildSandbox(ctx));
+    } catch (err) {
+      this.log('warn', `模板字段求值失败 ${value}: ${err.message}`);
+      return value;
+    }
+  }
+
+  /**
+   * 构建模板求值沙箱，未定义的标识符解析为 undefined，便于 `||` 取默认值
+   * @param {object} ctx 模板上下文
+   * @returns {Proxy} 沙箱对象
+   */
+  _buildSandbox(ctx) {
+    return new Proxy(ctx, {
+      has: () => true,
+      get: (target, key) => (key in target ? target[key] : undefined)
+    });
+  }
+
+  /**
+   * 读取并解析 JSON 配置文件，失败时记录日志
+   * @param {string} file 配置文件绝对路径
+   * @returns {object} 解析结果，失败时返回 null
+   */
+  _readJson(file) {
+    try {
+      const text = fs.readFileSync(file, 'utf8');
+      return JSON.parse(this._stripComments(this._stripBom(text)));
+    } catch (err) {
+      this.log('error', `解析配置失败 ${file}: ${err.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * 去除文本开头的字节顺序标记（BOM）
+   * @param {string} text 原始文本
+   * @returns {string} 去除 BOM 后的文本
+   */
+  _stripBom(text) {
+    return text.charCodeAt(0) === 0xFEFF ? text.slice(1) : text;
+  }
+
+  /**
+   * 去除 JSON 文本中的注释（支持 // 与 /* *\/，不处理字符串内部）
+   * @param {string} text 原始文本
+   * @returns {string} 去除注释后的文本
+   */
+  _stripComments(text) {
+    let out = '';
+    let in_string = false;
+    let in_line = false;
+    let in_block = false;
+    let quote = '';
+
+    for (let i = 0; i < text.length; i++) {
+      const char = text[i];
+      const next = text[i + 1];
+
+      if (in_line) {
+        if (char === '\n') {
+          in_line = false;
+          out += char;
+        }
+        continue;
+      }
+      if (in_block) {
+        if (char === '*' && next === '/') {
+          in_block = false;
+          i++;
+        }
+        continue;
+      }
+      if (in_string) {
+        out += char;
+        if (char === '\\') {
+          out += next || '';
+          i++;
+        } else if (char === quote) {
+          in_string = false;
+        }
+        continue;
+      }
+      if (char === '"' || char === "'") {
+        in_string = true;
+        quote = char;
+        out += char;
+        continue;
+      }
+      if (char === '/' && next === '/') {
+        in_line = true;
+        i++;
+        continue;
+      }
+      if (char === '/' && next === '*') {
+        in_block = true;
+        i++;
+        continue;
+      }
+      out += char;
+    }
+    return out;
+  }
+}
+
+module.exports = Loader;