fast-cocos 1.0.8 → 1.1.0

package/dist/ttf/py/modify_fonts1.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+from fontTools.ttLib import TTFont
+import argparse
+import os
+import re
+import shutil
+import sys
+
+# 字体选择标志常量
+FS_SELECTION_BOLD = 0x20
+FS_SELECTION_REGULAR = 0x40
+
+# macStyle标志常量
+MAC_STYLE_BOLD = 0x01
+
+def get_font_info(font_path):
+    """获取字体的原始信息"""
+    try:
+        font = TTFont(font_path)
+        name_table = font['name']
+
+        info = {
+            'family': None,
+            'subfamily': None,
+            'fullname': None,
+            'postscript': None,
+            'weight': 400
+        }
+
+        # 获取字体信息
+        for record in name_table.names:
+            if record.nameID == 1:  # Family name
+                info['family'] = record.toUnicode()
+            elif record.nameID == 2:  # Subfamily
+                info['subfamily'] = record.toUnicode()
+            elif record.nameID == 4:  # Full name
+                info['fullname'] = record.toUnicode()
+            elif record.nameID == 6:  # PostScript name
+                info['postscript'] = record.toUnicode()
+
+        # 获取字重
+        if 'OS/2' in font:
+            info['weight'] = font['OS/2'].usWeightClass
+
+        font.close()
+        return info
+    except Exception as e:
+        print(f"获取字体信息失败: {e}")
+        return {
+            'family': 'Unknown',
+            'subfamily': 'Regular',
+            'fullname': 'Unknown Regular',
+            'postscript': 'Unknown-Regular',
+            'weight': 400
+        }
+
+def detect_weight_from_font(font_path):
+    """从字体文件的OS/2表获取实际字重"""
+    try:
+        font = TTFont(font_path)
+        weight = 400  # 默认
+
+        if 'OS/2' in font:
+            weight = font['OS/2'].usWeightClass
+
+        font.close()
+    except Exception as e:
+        print(f"读取字体文件失败: {e}")
+        weight = 400
+        raise
+
+    # 根据字重值返回对应的样式名
+    if weight <= 100:
+        return weight, 'Thin'
+    elif weight <= 200:
+        return weight, 'ExtraLight'
+    elif weight <= 300:
+        return weight, 'Light'
+    elif weight <= 450:
+        return weight, 'Regular'
+    elif weight <= 550:
+        return weight, 'Medium'
+    elif weight <= 650:
+        return weight, 'SemiBold'
+    elif weight <= 750:
+        return weight, 'Bold'
+    elif weight <= 850:
+        return weight, 'ExtraBold'
+    else:
+        return weight, 'Black'
+
+def generate_unique_family_name(original_family, weight_style, index):
+    """基于索引生成唯一的字体家族名"""
+    # 移除原始家族名中的非ASCII字符和特殊字符
+    clean_name = re.sub(r'[^\w]', '', original_family)
+    clean_name = ''.join(c for c in clean_name if ord(c) < 128)  # 只保留ASCII字符
+
+    # 如果清理后为空，使用默认名称
+    if not clean_name:
+        clean_name = "Font"
+
+    # 生成简短的唯一标识
+    if len(clean_name) > 8:
+        clean_name = clean_name[:8]
+
+    # 基于索引和字重生成唯一名称
+    return f"{clean_name}{weight_style}{index}"
+
+def sanitize_postscript_name(name):
+    """清理PostScript名称，确保符合命名规范"""
+    # PostScript名称只能包含ASCII字母、数字和连字符
+    # 不能有空格，必须以字母开头
+    sanitized = re.sub(r'[^a-zA-Z0-9-]', '', name.replace(' ', ''))
+
+    # 确保以字母开头
+    if sanitized and not sanitized[0].isalpha():
+        sanitized = 'Font' + sanitized
+
+    # 如果完全为空，返回默认值
+    if not sanitized:
+        sanitized = 'Font-Regular'
+
+    return sanitized
+
+def modify_font_complete(font_path, new_family_name=None, weight_value=None, style_name=None, index=1):
+    """完全修改字体的所有相关元数据"""
+    # 验证字体文件
+    if not os.path.exists(font_path):
+        raise FileNotFoundError(f"字体文件不存在: {font_path}")
+
+    if not font_path.lower().endswith(('.ttf')):
+        raise ValueError(f"不支持的字体格式: {font_path}")
+
+    # 如果没有提供参数，自动检测
+    if not all([new_family_name, weight_value, style_name]):
+        font_info = get_font_info(font_path)
+
+        # 从字体文件获取实际字重
+        detected_weight, detected_style = detect_weight_from_font(font_path)
+
+        # 如果没有提供参数，使用检测到的值
+        if not new_family_name:
+            new_family_name = generate_unique_family_name(font_info['family'], detected_style, index)
+        if not weight_value:
+            weight_value = detected_weight
+        if not style_name:
+            style_name = "Regular"  # iOS推荐所有独立字体都使用Regular
+
+    # 验证字重值
+    if not isinstance(weight_value, int) or weight_value < 1 or weight_value > 1000:
+        raise ValueError(f"无效的字重值: {weight_value}，必须在1-1000之间")
+
+    print(f"\n处理字体: {os.path.basename(font_path)}")
+    print(f"新家族名: {new_family_name}")
+    print(f"字重: {weight_value}")
+    print(f"样式: {style_name}")
+
+    try:
+        font = TTFont(font_path)
+    except Exception as e:
+        raise ValueError(f"无法打开字体文件: {e}")
+
+    # 获取name表
+    name_table = font['name']
+
+    # 需要修改的所有nameID
+    # 1 = Family name
+    # 2 = Subfamily name
+    # 3 = Unique identifier
+    # 4 = Full name
+    # 6 = PostScript name
+    # 16 = Typographic Family name (Preferred family)
+    # 17 = Typographic Subfamily name (Preferred subfamily)
+
+    # 使用清理函数生成符合规范的PostScript名称
+    postscript_name = sanitize_postscript_name(f"{new_family_name}-{style_name}")
+    full_name = f"{new_family_name} {style_name}"
+
+    # 创建新的name记录
+    name_updates = {
+        1: new_family_name,  # Family
+        2: style_name,       # Subfamily
+        3: f"{new_family_name} {style_name}",  # Unique ID
+        4: full_name,        # Full name
+        6: postscript_name,  # PostScript name
+        16: new_family_name, # Preferred Family
+        17: style_name,      # Preferred Subfamily
+    }
+
+    # 更新所有相关的name记录
+    for record in name_table.names:
+        if record.nameID in name_updates:
+            old_value = record.toUnicode()
+            new_value = name_updates[record.nameID]
+            try:
+                # 使用UTF-16-BE编码，这是字体行业的通用标准
+                record.string = new_value.encode('utf-16-be')
+                print(f"NameID {record.nameID}: {old_value} -> {new_value}")
+            except Exception as e:
+                print(f"编码失败 (NameID {record.nameID}): {e}")
+                # 保持原值不变
+                continue
+
+    # 修改OS/2表
+    if 'OS/2' in font:
+        os2_table = font['OS/2']
+        old_weight = os2_table.usWeightClass
+        os2_table.usWeightClass = weight_value
+        print(f"OS/2 Weight: {old_weight} -> {weight_value}")
+
+        # 设置字体选择标志
+        os2_table.fsSelection = 0
+        if weight_value >= 700:  # Bold
+            os2_table.fsSelection |= FS_SELECTION_BOLD
+        elif weight_value == 400:  # Regular
+            os2_table.fsSelection |= FS_SELECTION_REGULAR
+
+    # 修改head表中的macStyle
+    if 'head' in font:
+        head_table = font['head']
+        head_table.macStyle = 0
+        if weight_value >= 700:
+            head_table.macStyle |= MAC_STYLE_BOLD
+
+    # 保存修改后的字体
+    base_name = os.path.splitext(font_path)[0]
+    output_path = f"{base_name}.ttf"
+
+    try:
+        font.save(output_path)
+        print(f"Saved to: {output_path}\n")
+        font.close()
+        return output_path
+    except Exception as e:
+        font.close()
+        print(f"保存字体失败: {e}")
+        raise
+
+def copy_files(src_folder, dst_folder):
+    """
+    将源文件夹所有文件复制到目标文件夹
+    :param src_folder: 源文件夹路径
+    :param dst_folder: 目标文件夹路径
+    """
+    try:
+        # 确保目标文件夹存在
+        os.makedirs(dst_folder, exist_ok=True)
+        
+        # 遍历源文件夹
+        for item in os.listdir(src_folder):
+            src_path = os.path.join(src_folder, item)
+            dst_path = os.path.join(dst_folder, item)
+            
+            # 如果是文件则复制
+            if os.path.isfile(src_path):
+                shutil.copy2(src_path, dst_path)
+                print(f"已复制: {src_path} -> {dst_path}")
+            # 如果是子文件夹则递归处理（可选）
+            # else:
+            #     copy_files(src_path, dst_path)
+                
+        print(f"操作完成！共复制了{len(os.listdir(src_folder))}个文件")
+    except Exception as e:
+        print(f"发生错误: {e}")
+
+
+
+def main():
+    parser = argparse.ArgumentParser(description="修改 TTF 字体元数据（name / OS/2 / head）")
+    parser.add_argument(
+        "font_path",
+        help="要处理的 TTF 字体文件路径（通常为瘦身后的输出文件）",
+    )
+    args = parser.parse_args()
+    font_path = os.path.abspath(args.font_path)
+    if not os.path.isfile(font_path):
+        raise SystemExit(f"字体文件不存在: {font_path}")
+    modify_font_complete(font_path)
+
+
+if __name__ == "__main__":
+    # main()
+    modify_font_complete(sys.argv[1])
+

package/dist/ttf/src/TTF.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ttf = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = __importDefault(require("../../logger"));
+const utils_1 = require("../../utils");
+class TTF {
+    /**
+     * 字体瘦身：抽取字符、合并 JSON 与自定义字表，再用 sfnttool 生成子集 TTF。
+     * 流程对齐参考脚本 `ttf.js`。
+     * @param options 选项
+     */
+    parse(options) {
+        // 获取所有指定目录下所有后缀文件
+        const outFiles = utils_1.utils.findFiles(options.output, [".ttf"]);
+        const srcFiles = utils_1.utils.findFiles(options.source, [".ttf"]);
+        // 需要处理的文件名
+        const needProcessFileNames = outFiles.map((file) => path_1.default.basename(file));
+        // 需要处理的文件信息
+        const processFiles = [];
+        for (const file of srcFiles) {
+            const fileName = path_1.default.basename(file);
+            if (needProcessFileNames.includes(fileName)) {
+                processFiles.push({ src: file, dst: path_1.default.join(options.output, fileName) });
+            }
+        }
+        // 处理
+        const pyPath = path_1.default.join(__dirname, "..", "py", "modify_fonts.py");
+        // 处理字符集
+        const fontPath = this.handleTxt(options);
+        // 构建后 __dirname 为 dist/ttf/src，与 copy-assets 中 dist/ttf/jar 对齐
+        const jarDir = path_1.default.join(__dirname, "..", "jar");
+        const sfnttoolJar = path_1.default.join(jarDir, "sfnttool.jar");
+        logger_1.default.info(`[${new Date().toLocaleString()}] 开始字体瘦身`);
+        for (const { src, dst } of processFiles) {
+            (0, child_process_1.execFileSync)("java", ["-jar", sfnttoolJar, "-c", fontPath, src, dst], { stdio: "inherit" });
+            logger_1.default.info(`字体瘦身完成: ${dst}`);
+            if (fs_1.default.existsSync(pyPath)) {
+                const python = process.platform === "win32" ? "python" : "python3";
+                (0, child_process_1.execFileSync)(python, [pyPath, dst], { stdio: "inherit" });
+            }
+            else {
+                logger_1.default.warn(`未找到脚本，跳过元数据修改: ${pyPath}`);
+            }
+        }
+        // 删除临时文件
+        utils_1.utils.rmSync(path_1.default.join(options.output, "font.txt"));
+        // utils.rmSync(fontPath);
+    }
+    /**
+     * 处理字符集
+     * @param options
+     * @returns 字符集文本路径
+     */
+    handleTxt(options) {
+        // 抽取输出目录中的字符集
+        const jarDir = path_1.default.join(__dirname, "..", "jar");
+        const fontJar = path_1.default.join(jarDir, "font.jar");
+        (0, child_process_1.execFileSync)("java", ["-jar", fontJar, options.output], { stdio: "inherit" });
+        let fontStr = fs_1.default.readFileSync(path_1.default.join(options.output, "font.txt"), "utf-8");
+        const fontSet = new Set([...fontStr]);
+        // 自定义字符集
+        const txtFiles = utils_1.utils.findFiles(options.source, [".txt"]);
+        for (const txtFile of txtFiles) {
+            const str = fs_1.default.readFileSync(txtFile, "utf-8");
+            [...str].forEach((s) => fontSet.add(s));
+        }
+        // 将新的字符集写入临时文件
+        const tmpTxtPath = path_1.default.join(options.source, "tmp.txt");
+        if (fs_1.default.existsSync(tmpTxtPath)) {
+            fs_1.default.unlinkSync(tmpTxtPath);
+        }
+        fs_1.default.writeFileSync(tmpTxtPath, [...fontSet].join(""), "utf-8");
+        console.info("\x1b[32m%s\x1b[0m", `临时字符集文件路径: ${tmpTxtPath}`);
+        return tmpTxtPath;
+    }
+}
+exports.ttf = new TTF();

package/dist/ttf/src/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const TTF_1 = require("./TTF");
+/**
+ * 解析机器人消息命令参数，并按类型发送到对应平台。
+ */
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        commander_1.program
+            .name("ttf")
+            .description("ttf parser")
+            .version("1.0.0")
+            .requiredOption("-s, --source <directory>", "source directory")
+            .requiredOption("-o, --output <directory>", "output directory")
+            .parse(process.argv);
+        const options = commander_1.program.opts();
+        TTF_1.ttf.parse(options);
+    });
+}
+// 捕获入口异步异常并以非零状态码退出。
+void main().catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/utils.js

@@ -36,6 +36,7 @@ var utils;
     function getSubDirsSync(dir) {
         const subDirs = [];
         const files = fs_1.default.readdirSync(dir);
+        // 将目录项过滤成完整路径形式的子目录列表。
         files.forEach((file) => {
             const filePath = path_1.default.join(dir, file);
             const fileStat = fs_1.default.statSync(filePath);
@@ -55,6 +56,7 @@ var utils;
         if (!fs_1.default.existsSync(dir)) {
             return false;
         }
+        // 只要存在一个目标扩展名文件，即认为目录满足条件。
         return fs_1.default.readdirSync(dir).some((file) => path_1.default.extname(file) === ext);
     }
     utils.containsFileExt = containsFileExt;
@@ -96,6 +98,7 @@ var utils;
             exts = [exts];
         }
         const fileList = fs_1.default.readdirSync(dir);
+        // 递归收集匹配扩展名的文件路径。
         fileList.forEach((file) => {
             const filePath = path_1.default.join(dir, file);
             const fileStat = fs_1.default.statSync(filePath);
@@ -202,6 +205,7 @@ var utils;
                 return;
             }
             const files = fs_1.default.readdirSync(dir); // 同步读取目录内容
+            // 仅删除当前目录中符合扩展名且未被排除的文件。
             files.forEach((file) => {
                 const filePath = path_1.default.join(dir, file);
                 // 获取文件的状态

package/dist/xlsx/src/XlsxParser.js

@@ -20,6 +20,10 @@ var SheetType;
  * Xlsx解析器
  */
 class XlsxParser {
+    /**
+     * 初始化解析器配置，并清理上一次导出的临时目录。
+     * @param options xlsx 解析与输出路径配置
+     */
     constructor(options) {
         /** 数组分隔符类 */
         this.separators = ["|", ";", ",", "-", "_"];
@@ -40,10 +44,12 @@ class XlsxParser {
      */
     parse() {
         const xlsxFiles = this.findFilesWithExtensions(this.options.xlsxDir, [".xlsx", ".xls"]);
+        // 逐个解析源目录下的 Excel 文件。
         xlsxFiles.forEach((filePath) => {
             console.info("\x1b[35m%s\x1b[0m", "解析文件: " + filePath);
             const xlsxName = path_1.default.basename(filePath, path_1.default.extname(filePath));
             const workSheetsFromFile = node_xlsx_1.default.parse(filePath);
+            // 将同一个工作簿中的每个工作表分别按表类型导出。
             workSheetsFromFile.forEach((workSheet) => {
                 this.parseWorkSheet(xlsxName, workSheet);
             });
@@ -63,6 +69,7 @@ class XlsxParser {
         // 解析表名、类型、版本
         const [basename, sheetType, version] = arr;
         // 去除空数组
+        // 丢弃完全为空的行，避免表头或数据解析被空行干扰。
         data = data.filter((item) => item.length > 0);
         /** 介绍（第一行） */
         let intros = data[0];
@@ -82,7 +89,11 @@ class XlsxParser {
             data.shift();
             data.shift();
         }
-        data.forEach((row) => row.forEach((v, i) => (row[i] = String(v || "").trim())));
+        // 统一清洗每行中的单元格文本。
+        data.forEach((row) => {
+            // 将单元格转成字符串并去掉首尾空白。
+            row.forEach((v, i) => (row[i] = String(v || "").trim()));
+        });
         let fileName = `${basename}${sheetType}`;
         let typeName = fileName;
         // 带版本号
@@ -143,6 +154,7 @@ class XlsxParser {
             for (let i = 0; i < row.length; ++i) {
                 const field = fields[i];
                 if (field) {
+                    // 提供整列值，供数组类型自动推断真实分隔符。
                     const columns = data.map((v) => v[i]);
                     rowInfo[field] = this.parseValue(types[i], row[i], columns);
                 }
@@ -172,6 +184,7 @@ class XlsxParser {
             for (let j = 0; j < col.length; ++j) {
                 const field = fields[j];
                 if (field) {
+                    // 提供整列值，供数组类型自动推断真实分隔符。
                     const columns = data.map((v) => v[j]);
                     info[field] = this.parseValue(types[j], col[j], columns);
                 }
@@ -197,6 +210,7 @@ class XlsxParser {
         for (let i = 0; i < data.length; ++i) {
             const col = data[i];
             if (col[0]) {
+                // 新的首列值表示一个新的合并行分组。
                 const columns = data.map((v) => v[0]);
                 group = {
                     [fields[0]]: this.parseValue(types[0], col[0], columns),
@@ -223,6 +237,7 @@ class XlsxParser {
         for (let i = 0; i < row.length; ++i) {
             const field = fields[i];
             if (field) {
+                // 提供整列值，供数组类型自动推断真实分隔符。
                 const columns = data.map((v) => v[i]);
                 info[field] = this.parseValue(types[i], row[i], columns);
             }
@@ -237,6 +252,7 @@ class XlsxParser {
         if (data.length <= 0 || !data[0][0]) {
             return false;
         }
+        // 首列后续行为空但同一行仍有值时，视为首列合并行数组。
         return data.some((row, index) => index > 0 && !row[0] && row.some((value) => value));
     }
     /**
@@ -260,7 +276,7 @@ class XlsxParser {
         this.writeSheetSync(sheetInfo.outPath, content);
     }
     /**
-     * 解析键值表
+     * 解析三列表结构的变量映射表
      * @param sheetInfo 工作表信息
      */
     parseVMap(sheetInfo) {
@@ -353,6 +369,7 @@ class XlsxParser {
         // 分隔符数量
         let separatorCount = separators.length;
         // 逆序分隔符
+        // 去掉空分隔符声明，并反向应用以匹配递归拆分顺序。
         let realSeparators = separators.filter((item) => item !== "").reverse();
         // 从列中抽取分隔符
         if (realSeparators.length <= 0 && separatorCount > 0) {
@@ -397,6 +414,7 @@ class XlsxParser {
             return [this.splitStringToNestedArray(baseType, valueStr, remainingDelimiters)];
         }
         // 分割当前层级并递归处理每个部分
+        // 当前层拆分后的每一段继续使用剩余分隔符递归解析。
         return valueStr.split(currentDelimiter).map((part) => this.splitStringToNestedArray(baseType, part, remainingDelimiters));
     }
     /**
@@ -411,6 +429,7 @@ class XlsxParser {
             extensions = [extensions];
         }
         const fileList = fs_1.default.readdirSync(dir);
+        // 递归收集匹配扩展名的文件路径。
         fileList.forEach((file) => {
             const filePath = path_1.default.join(dir, file);
             const fileStat = fs_1.default.statSync(filePath);
@@ -531,7 +550,7 @@ class XlsxParser {
     }
     /**
      * 去除多余类型字符
-     * @param str
+     * @param str 原始类型字符串
      */
     removeExtraType(str) {
         // 使用正则表达式匹配所有方括号中的内容
@@ -552,7 +571,7 @@ class XlsxParser {
     }
     /**
      * 处理字符串，确保它不以数字开头，并且移除所有空格、制表符和换行符
-     * @param input
+     * @param input 原始字符串
      */
     processString(input) {
         // Remove leading digits
@@ -569,6 +588,7 @@ class XlsxParser {
         const jsonDir = path_1.default.join(this.options.tmpDir);
         const files = this.findFilesWithExtensions(jsonDir, [".json"]);
         const json = {};
+        // 将每个临时表 JSON 合并到最终 xlsx.json 的表名键下。
         files.forEach((filePath) => {
             const basename = path_1.default.basename(filePath);
             const arr = this.processString(basename).split(".");
@@ -618,10 +638,12 @@ class XlsxParser {
         declareStr += `\n    /** 整数 */`;
         declareStr += `\n    type int = number;`;
         // 遍历声明表
+        // 拼接每张表解析过程中收集到的 TypeScript 类型声明。
         this.declareMap.forEach((value) => {
             if (value.length <= 0) {
                 return;
             }
+            // 为 namespace 内部声明增加统一缩进。
             value = value.map((v) => " ".repeat(4) + v);
             declareStr += "\n\n";
             declareStr += value.join("\n");

package/dist/xlsx/src/index.js

@@ -15,6 +15,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const path_1 = __importDefault(require("path"));
 const XlsxParser_1 = __importDefault(require("./XlsxParser"));
+/**
+ * 解析 xlsx 导出命令参数，并初始化表格解析器。
+ */
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         commander_1.program
@@ -43,6 +46,7 @@ function main() {
         xlsxParser.parse();
     });
 }
+// 捕获入口异步异常并以非零状态码退出。
 void main().catch((err) => {
     console.error(err);
     process.exit(1);

package/dist/xxteakey/src/index.js

@@ -27,6 +27,9 @@ function generateKey() {
     // 组合成 8-4-2 格式
     return `${part1}-${part2}-${part3}`;
 }
+/**
+ * 读取指定 JSON 文件，生成并写入新的 xxteaKey 字段。
+ */
 function main() {
     return __awaiter(this, void 0, void 0, function* () {
         commander_1.program
@@ -50,6 +53,7 @@ function main() {
         console.log(`xxteaKey: ${xxteaKey}`);
     });
 }
+// 捕获入口异步异常并以非零状态码退出。
 void main().catch((err) => {
     console.error(err);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fast-cocos",
-  "version": "1.0.8",
+  "version": "1.1.0",
   "scripts": {
     "clean": "rm -rf dist",
     "start": "node ./dist/index.js",