@zzclub/z-cli 0.4.5

package/src/command/translate.js

@@ -0,0 +1,334 @@
+import path from "node:path";
+import fs from "node:fs";
+import chalk from "chalk";
+import { translate } from "../translate-api/index.js";
+import { readJsonFile } from "../utils/file.js";
+import { writeFileContent, getLocalConfig } from "../utils/common.js";
+import ora from "ora";
+// const { log } = require("../utils/common");
+
+// let config: { translate: any } = await getLocalConfig();
+// const translateConfig = config.translate;
+const translateCmd = {
+  name: "translate",
+  description: "中译英功能,支持批量和单个文件翻译",
+  // options: ['-l, --language <language>', '转换为什么语言, 支持[zh]和[en]', 'en'],
+  options: [
+    {
+      flags: "-l, --language <language>",
+      description: "目前只支持从中文到英文",
+      defaultValue: "en",
+    },
+    {
+      flags: "-f, --file <file>",
+      description: "转换文件的路径",
+      defaultValue: null,
+    },
+    {
+      flags: "-d, --dir <dirpath>",
+      description: "转换文件夹的路径",
+      defaultValue: null,
+    },
+  ],
+  action: async (option) => {
+    let filePath = option.file;
+    let dirPath = option.dir;
+
+    if (!filePath && !dirPath) {
+      process.exit(1);
+    }
+    let file_spinner = ora();
+    let config = await getLocalConfig();
+    const translateConfig = config.translate;
+    if (!translateConfig.account.appId || !translateConfig.account.key) {
+      file_spinner.fail("请先设置appId和key后再使用翻译功能");
+      process.exit(1);
+    }
+    // 有文件夹路径时忽略文件
+    if (dirPath) {
+      dirPath = path.resolve(process.cwd(), dirPath);
+      let stat;
+      try {
+        stat = fs.statSync(dirPath);
+      } catch (err) {
+        file_spinner.fail(`${chalk.red(dirPath)}不存在!`);
+        return;
+      }
+
+      if (!stat.isDirectory()) {
+        file_spinner.fail(`${chalk.red(dirPath)}不是一个文件夹!`);
+        return;
+      } else {
+        let filePaths = [];
+        file_spinner.succeed(`开始检索${chalk.red(dirPath)}`);
+
+        getAllFilePaths(translateConfig, dirPath, filePaths);
+
+        // log.success(`共找到${chalk.red(filePaths.length)}个要翻译的文件`);
+        if (filePaths.length) {
+          file_spinner.succeed(
+            `共找到${chalk.red(filePaths.length)}个要翻译的文件`
+          );
+          file_spinner.start();
+          await execWorkerSync(filePaths, 0);
+          file_spinner.stop();
+        } else {
+          //   log.success(`Exit`);
+          file_spinner.warn(
+            `共找到${chalk.red(filePaths.length)}个要翻译的文件`
+          );
+        }
+      }
+    } else {
+      file_spinner.succeed(`正在翻译${chalk.yellowBright(filePath)}`);
+      file_spinner.start();
+      let file_content = await readAndTranslateFileContent(filePath);
+      let fileName = path.basename(filePath);
+      let dirPath = path.dirname(filePath);
+      let newFileName =
+        fileName.split(".")[0] +
+        `-${option.language}.` +
+        fileName.split(".")[1];
+      let newFilePath = dirPath + "/" + newFileName;
+      writeFileContent(newFilePath, file_content, (spinner, isOk) => {
+        if (isOk) {
+          spinner.succeed("翻译结束");
+        } else {
+          spinner.fail("翻译失败!");
+        }
+
+        file_spinner.stop();
+      });
+    }
+  },
+};
+
+/**
+ * 递归处理i18n配置对象
+ * @param config i18n配置js 一般为langs文件下的js文件
+ * @description 把js对象处理成 [ { keys: ['common', 'title'], value: '要翻译的值'} ]  每个要翻译的中文为一个item keys表示他在对象里的位置
+ */
+function parseConfigs(config) {
+  let words = [];
+
+  parseConfig(config, null);
+  function parseConfig(config, curItem) {
+    let keys = Object.keys(config);
+    keys.forEach((key) => {
+      let item = {
+        keys: curItem ? curItem.keys.concat([key]) : [key],
+        value: config[key],
+      };
+      // 对象的value为string时则为要翻译的值
+      if (typeof item.value === "string") {
+        words.push(item);
+      } else {
+        parseConfig(item.value, item);
+      }
+    });
+  }
+  return words;
+}
+
+/**
+ * 把所有要翻译的词分组 每秒有查询次数限制
+ * @param words 处理好的数据
+ * @param limitLength 每秒查几个词
+ * @returns {*[]} 处理后的二维数组
+ */
+function limitWords(words, limitLength = 7) {
+  let wordsLimit = [];
+  if (words.length < limitLength) {
+    return [words];
+  } else {
+    for (let i = 0; i < words.length; i += limitLength) {
+      wordsLimit.push(words.slice(i, i + limitLength));
+    }
+    return wordsLimit;
+  }
+}
+
+/**
+ * 调用翻译功能
+ * @param limitedWords 分组后的word数据
+ * @param cb 全部翻译结束后的回调函数
+ */
+function startTranslate(limitedWords, cb) {
+  let curIndex = 0;
+  let timer = null;
+  timer = setInterval(() => {
+    if (curIndex >= limitedWords.length) {
+      clearInterval(timer);
+      cb && cb();
+    } else {
+      limitedWords[curIndex].forEach(async (word) => {
+        let res = await translate({
+          query: word.value,
+          from: "zh",
+          to: "en",
+        }).catch((err) => {
+          console.log(err);
+        });
+
+        let translate_result = res.trans_result
+          ? res.trans_result[0].dst
+          : word.value;
+        word.value = translate_result;
+      });
+      curIndex++;
+    }
+  }, 1000);
+}
+
+/**
+ * 组装翻译后的数据结构
+ * @param words
+ * @param obj
+ */
+function setTranslatedObj(words, obj) {
+  words.forEach((item) => {
+    item.keys.forEach((key, index) => {
+      if (index === 0 && item.keys.length > 1) {
+        if (!obj[key]) obj[key] = {};
+      } else if (index < item.keys.length - 1) {
+        // a.b.c
+        let _key = item.keys.slice(0, index + 1).join(".");
+        let flag = false;
+        eval(`flag = !!!obj.${_key}`);
+        if (flag) eval(`obj.${_key} = {}`);
+      } else {
+        let _key = item.keys.slice(0, index + 1).join(".");
+        eval(`obj.${_key} = "${item.value}"`);
+      }
+    });
+  });
+}
+function unquoteKeys(json) {
+  return json.replace(/"(\\[^]|[^\\"])*"\s*:?/g, function (match) {
+    if (/:$/.test(match)) {
+      return match.replace(/^"|"(?=\s*:$)/g, "");
+    } else {
+      return match;
+    }
+  });
+}
+/**
+ * 读取并翻译文本内容
+ * @param filePath 文件地址
+ * @param cb 翻译后的回调
+ * @return 翻译后的文本
+ */
+function readAndTranslateFileContent(filePath, cb = () => {}) {
+  return new Promise((resolve, reject) => {
+    fs.readFile(filePath, { encoding: "utf8" }, (err, data) => {
+      if (err) {
+        // log.error("读取文件失败");
+        reject();
+      } else {
+        let jsonObj;
+        let fileData = data.toString();
+        let startIndex = fileData.indexOf("{");
+        let endIndex = fileData.lastIndexOf("}");
+        let jsonStr = fileData.slice(
+          startIndex,
+          endIndex === fileData.length ? endIndex : endIndex + 1
+        );
+        try {
+          // 当成js执行
+          eval("jsonObj = " + jsonStr);
+        } catch (err) {
+          jsonObj = null;
+          //   log.error("文件解析失败");
+          reject();
+        }
+
+        if (jsonObj) {
+          let obj = {};
+          let words = parseConfigs(jsonObj);
+          let limitedWords = limitWords(words, 7);
+          //   log.on(`正在翻译${chalk.yellow(filePath)}`);
+          startTranslate(limitedWords, () => {
+            let words_result = limitedWords.flat(1);
+            setTranslatedObj(words_result, obj);
+            let file_result =
+              `export default ` + unquoteKeys(JSON.stringify(obj, null, 2));
+            resolve(file_result);
+          });
+        }
+      }
+    });
+  });
+}
+
+/**
+ * 获取所有需要处理的文件路径+目标路径
+ * @param dirPath 从指定的目录地址开始查找
+ * @param filePaths 一个空数组，用来接收结果
+ */
+function getAllFilePaths(translateConfig, dirPath, filePaths) {
+  let files = fs.readdirSync(dirPath);
+  files.forEach((file) => {
+    let filePath = path.join(dirPath, file);
+    let stats = fs.statSync(filePath);
+    // 是否是文件夹
+    let isDir = stats.isDirectory();
+    if (isDir) {
+      if (file === translateConfig.sourceDirName) {
+        // 找到目标文件夹, 获取所有文件
+        let files = fs.readdirSync(filePath);
+        files.forEach((file) => {
+          let jsPath = path.join(filePath, file);
+          let targetPath = path.join(dirPath, translateConfig.targetDirName);
+          filePaths.push({
+            sourcePath: jsPath,
+            targetPath,
+          });
+        });
+      } else if (!translateConfig.ignoreFiles.includes(file)) {
+        getAllFilePaths(translateConfig, filePath, filePaths);
+      }
+    }
+  });
+}
+
+/**
+ * 同步执行所有翻译操作
+ * 因为每秒请求数有限制, 异步请求会超过最大并发数
+ * @param files 所有要翻译的文件
+ * @param index 当前进行到的index
+ */
+async function execWorkerSync(files, index = 0) {
+  let fileItem = files[index];
+  let file_content = await readAndTranslateFileContent(fileItem.sourcePath);
+  let fileName = path.basename(fileItem.sourcePath);
+  let newFilePath = fileItem.targetPath + "/" + fileName;
+  let exist = fs.existsSync(fileItem.targetPath);
+  // 自动创建不存在的目录
+  if (!exist) {
+    try {
+      //   log.on(`创建文件夹${chalk.yellow(fileItem.targetPath)}`);
+      fs.mkdirSync(fileItem.targetPath);
+    } catch (error) {
+      //   log.error(`创建文件夹${chalk.red(fileItem.targetPath)}失败`);
+      process.exit(1);
+    }
+  }
+  writeFileContent(newFilePath, file_content, async (spinner, isOk) => {
+    if (isOk) {
+      spinner.succeed(`${newFilePath}已翻译`);
+    } else {
+      spinner.fail(`${newFilePath}翻译失败`);
+    }
+    index++;
+    if (index < files.length) {
+      spinner.start();
+      await execWorkerSync(files, index);
+      spinner.stop();
+    } else {
+      spinner.stop();
+      spinner.succeed("翻译完毕");
+    }
+  });
+}
+
+export { translateCmd };

package/src/config.json

@@ -0,0 +1,16 @@
+{
+  "translate": {
+    "sourceDirName": "zh-CN",
+    "targetDirName": "en-US",
+    "ignoreFiles": [
+      "node_modules"
+    ],
+    "account": {
+      "appId": "",
+      "key": ""
+    }
+  },
+  "editableConfig": [
+    "translate"
+  ]
+}

package/src/index.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+// const pkg = require("./package.json");
+import { registerCommand, initProgram } from "./command/index.js";
+import { translateCmd } from "./command/translate.js";
+import { configCmd } from "./command/config.js";
+import { setCmd } from "./command/set.js";
+import { tinyCmd } from "./command/tiny.js";
+import { picgoCmd } from "./command/picgo.js";
+import { checkUpdate } from './utils/common.js'
+
+const program = new Command();
+
+initProgram(program, async () => {
+  await checkUpdate()
+  registerCommand(program, translateCmd);
+
+  registerCommand(program, setCmd);
+
+  registerCommand(program, configCmd);
+
+  registerCommand(program, tinyCmd);
+  registerCommand(program, picgoCmd);
+
+  program.parse(process.argv);
+});

package/src/translate-api/index.js

@@ -0,0 +1,47 @@
+import { MD5 } from "./md5.js";
+import path from "path";
+import { readJsonFile } from "../utils/file.js";
+import axios from "axios";
+import { dirname } from "node:path"
+import { fileURLToPath } from "node:url"
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+let salt = new Date().getTime();
+let appid, key;
+async function genUser() {
+  let config = await readJsonFile(path.resolve(__dirname, "../config.json"));
+  let translateConfig = config.translate;
+  appid = translateConfig.account.appId; // appid
+  key = translateConfig.account.key; // 密钥
+}
+function genSign(options) {
+  let str1 = appid + options.query + salt + key;
+  let sign = MD5(str1);
+  return sign;
+}
+
+export async function translate(options) {
+  await genUser();
+  return new Promise((resolve, reject) => {
+    axios({
+      url: "http://api.fanyi.baidu.com/api/trans/vip/translate",
+      method: "get",
+      params: {
+        q: options.query,
+        appid: appid,
+        salt: salt,
+        from: options.from,
+        to: options.to,
+        sign: genSign(options),
+      },
+    })
+      .then((res) => {
+        resolve(res.data);
+      })
+      .catch((err) => {
+        reject("翻译失败");
+      })
+      .finally(() => {});
+  });
+}

package/src/translate-api/md5.js

@@ -0,0 +1,231 @@
+var MD5 = function (string) {
+  function RotateLeft(lValue, iShiftBits) {
+    return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits));
+  }
+
+  function AddUnsigned(lX, lY) {
+    var lX4, lY4, lX8, lY8, lResult;
+    lX8 = lX & 0x80000000;
+    lY8 = lY & 0x80000000;
+    lX4 = lX & 0x40000000;
+    lY4 = lY & 0x40000000;
+    lResult = (lX & 0x3fffffff) + (lY & 0x3fffffff);
+    if (lX4 & lY4) {
+      return lResult ^ 0x80000000 ^ lX8 ^ lY8;
+    }
+    if (lX4 | lY4) {
+      if (lResult & 0x40000000) {
+        return lResult ^ 0xc0000000 ^ lX8 ^ lY8;
+      } else {
+        return lResult ^ 0x40000000 ^ lX8 ^ lY8;
+      }
+    } else {
+      return lResult ^ lX8 ^ lY8;
+    }
+  }
+
+  function F(x, y, z) {
+    return (x & y) | (~x & z);
+  }
+  function G(x, y, z) {
+    return (x & z) | (y & ~z);
+  }
+  function H(x, y, z) {
+    return x ^ y ^ z;
+  }
+  function I(x, y, z) {
+    return y ^ (x | ~z);
+  }
+
+  function FF(a, b, c, d, x, s, ac) {
+    a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
+    return AddUnsigned(RotateLeft(a, s), b);
+  }
+
+  function GG(a, b, c, d, x, s, ac) {
+    a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
+    return AddUnsigned(RotateLeft(a, s), b);
+  }
+
+  function HH(a, b, c, d, x, s, ac) {
+    a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
+    return AddUnsigned(RotateLeft(a, s), b);
+  }
+
+  function II(a, b, c, d, x, s, ac) {
+    a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
+    return AddUnsigned(RotateLeft(a, s), b);
+  }
+
+  function ConvertToWordArray(string) {
+    var lWordCount;
+    var lMessageLength = string.length;
+    var lNumberOfWords_temp1 = lMessageLength + 8;
+    var lNumberOfWords_temp2 =
+      (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
+    var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
+    var lWordArray = Array(lNumberOfWords - 1);
+    var lBytePosition = 0;
+    var lByteCount = 0;
+    while (lByteCount < lMessageLength) {
+      lWordCount = (lByteCount - (lByteCount % 4)) / 4;
+      lBytePosition = (lByteCount % 4) * 8;
+      lWordArray[lWordCount] =
+        lWordArray[lWordCount] |
+        (string.charCodeAt(lByteCount) << lBytePosition);
+      lByteCount++;
+    }
+    lWordCount = (lByteCount - (lByteCount % 4)) / 4;
+    lBytePosition = (lByteCount % 4) * 8;
+    lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
+    lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
+    lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
+    return lWordArray;
+  }
+
+  function WordToHex(lValue) {
+    var WordToHexValue = "",
+      WordToHexValue_temp = "",
+      lByte,
+      lCount;
+    for (lCount = 0; lCount <= 3; lCount++) {
+      lByte = (lValue >>> (lCount * 8)) & 255;
+      WordToHexValue_temp = "0" + lByte.toString(16);
+      WordToHexValue =
+        WordToHexValue +
+        WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);
+    }
+    return WordToHexValue;
+  }
+
+  function Utf8Encode(string) {
+    string = string.replace(/\r\n/g, "\n");
+    var utftext = "";
+
+    for (var n = 0; n < string.length; n++) {
+      var c = string.charCodeAt(n);
+
+      if (c < 128) {
+        utftext += String.fromCharCode(c);
+      } else if (c > 127 && c < 2048) {
+        utftext += String.fromCharCode((c >> 6) | 192);
+        utftext += String.fromCharCode((c & 63) | 128);
+      } else {
+        utftext += String.fromCharCode((c >> 12) | 224);
+        utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+        utftext += String.fromCharCode((c & 63) | 128);
+      }
+    }
+
+    return utftext;
+  }
+
+  var x = Array();
+  var k, AA, BB, CC, DD, a, b, c, d;
+  var S11 = 7,
+    S12 = 12,
+    S13 = 17,
+    S14 = 22;
+  var S21 = 5,
+    S22 = 9,
+    S23 = 14,
+    S24 = 20;
+  var S31 = 4,
+    S32 = 11,
+    S33 = 16,
+    S34 = 23;
+  var S41 = 6,
+    S42 = 10,
+    S43 = 15,
+    S44 = 21;
+
+  string = Utf8Encode(string);
+
+  x = ConvertToWordArray(string);
+
+  a = 0x67452301;
+  b = 0xefcdab89;
+  c = 0x98badcfe;
+  d = 0x10325476;
+
+  for (k = 0; k < x.length; k += 16) {
+    AA = a;
+    BB = b;
+    CC = c;
+    DD = d;
+    a = FF(a, b, c, d, x[k + 0], S11, 0xd76aa478);
+    d = FF(d, a, b, c, x[k + 1], S12, 0xe8c7b756);
+    c = FF(c, d, a, b, x[k + 2], S13, 0x242070db);
+    b = FF(b, c, d, a, x[k + 3], S14, 0xc1bdceee);
+    a = FF(a, b, c, d, x[k + 4], S11, 0xf57c0faf);
+    d = FF(d, a, b, c, x[k + 5], S12, 0x4787c62a);
+    c = FF(c, d, a, b, x[k + 6], S13, 0xa8304613);
+    b = FF(b, c, d, a, x[k + 7], S14, 0xfd469501);
+    a = FF(a, b, c, d, x[k + 8], S11, 0x698098d8);
+    d = FF(d, a, b, c, x[k + 9], S12, 0x8b44f7af);
+    c = FF(c, d, a, b, x[k + 10], S13, 0xffff5bb1);
+    b = FF(b, c, d, a, x[k + 11], S14, 0x895cd7be);
+    a = FF(a, b, c, d, x[k + 12], S11, 0x6b901122);
+    d = FF(d, a, b, c, x[k + 13], S12, 0xfd987193);
+    c = FF(c, d, a, b, x[k + 14], S13, 0xa679438e);
+    b = FF(b, c, d, a, x[k + 15], S14, 0x49b40821);
+    a = GG(a, b, c, d, x[k + 1], S21, 0xf61e2562);
+    d = GG(d, a, b, c, x[k + 6], S22, 0xc040b340);
+    c = GG(c, d, a, b, x[k + 11], S23, 0x265e5a51);
+    b = GG(b, c, d, a, x[k + 0], S24, 0xe9b6c7aa);
+    a = GG(a, b, c, d, x[k + 5], S21, 0xd62f105d);
+    d = GG(d, a, b, c, x[k + 10], S22, 0x2441453);
+    c = GG(c, d, a, b, x[k + 15], S23, 0xd8a1e681);
+    b = GG(b, c, d, a, x[k + 4], S24, 0xe7d3fbc8);
+    a = GG(a, b, c, d, x[k + 9], S21, 0x21e1cde6);
+    d = GG(d, a, b, c, x[k + 14], S22, 0xc33707d6);
+    c = GG(c, d, a, b, x[k + 3], S23, 0xf4d50d87);
+    b = GG(b, c, d, a, x[k + 8], S24, 0x455a14ed);
+    a = GG(a, b, c, d, x[k + 13], S21, 0xa9e3e905);
+    d = GG(d, a, b, c, x[k + 2], S22, 0xfcefa3f8);
+    c = GG(c, d, a, b, x[k + 7], S23, 0x676f02d9);
+    b = GG(b, c, d, a, x[k + 12], S24, 0x8d2a4c8a);
+    a = HH(a, b, c, d, x[k + 5], S31, 0xfffa3942);
+    d = HH(d, a, b, c, x[k + 8], S32, 0x8771f681);
+    c = HH(c, d, a, b, x[k + 11], S33, 0x6d9d6122);
+    b = HH(b, c, d, a, x[k + 14], S34, 0xfde5380c);
+    a = HH(a, b, c, d, x[k + 1], S31, 0xa4beea44);
+    d = HH(d, a, b, c, x[k + 4], S32, 0x4bdecfa9);
+    c = HH(c, d, a, b, x[k + 7], S33, 0xf6bb4b60);
+    b = HH(b, c, d, a, x[k + 10], S34, 0xbebfbc70);
+    a = HH(a, b, c, d, x[k + 13], S31, 0x289b7ec6);
+    d = HH(d, a, b, c, x[k + 0], S32, 0xeaa127fa);
+    c = HH(c, d, a, b, x[k + 3], S33, 0xd4ef3085);
+    b = HH(b, c, d, a, x[k + 6], S34, 0x4881d05);
+    a = HH(a, b, c, d, x[k + 9], S31, 0xd9d4d039);
+    d = HH(d, a, b, c, x[k + 12], S32, 0xe6db99e5);
+    c = HH(c, d, a, b, x[k + 15], S33, 0x1fa27cf8);
+    b = HH(b, c, d, a, x[k + 2], S34, 0xc4ac5665);
+    a = II(a, b, c, d, x[k + 0], S41, 0xf4292244);
+    d = II(d, a, b, c, x[k + 7], S42, 0x432aff97);
+    c = II(c, d, a, b, x[k + 14], S43, 0xab9423a7);
+    b = II(b, c, d, a, x[k + 5], S44, 0xfc93a039);
+    a = II(a, b, c, d, x[k + 12], S41, 0x655b59c3);
+    d = II(d, a, b, c, x[k + 3], S42, 0x8f0ccc92);
+    c = II(c, d, a, b, x[k + 10], S43, 0xffeff47d);
+    b = II(b, c, d, a, x[k + 1], S44, 0x85845dd1);
+    a = II(a, b, c, d, x[k + 8], S41, 0x6fa87e4f);
+    d = II(d, a, b, c, x[k + 15], S42, 0xfe2ce6e0);
+    c = II(c, d, a, b, x[k + 6], S43, 0xa3014314);
+    b = II(b, c, d, a, x[k + 13], S44, 0x4e0811a1);
+    a = II(a, b, c, d, x[k + 4], S41, 0xf7537e82);
+    d = II(d, a, b, c, x[k + 11], S42, 0xbd3af235);
+    c = II(c, d, a, b, x[k + 2], S43, 0x2ad7d2bb);
+    b = II(b, c, d, a, x[k + 9], S44, 0xeb86d391);
+    a = AddUnsigned(a, AA);
+    b = AddUnsigned(b, BB);
+    c = AddUnsigned(c, CC);
+    d = AddUnsigned(d, DD);
+  }
+
+  var temp = WordToHex(a) + WordToHex(b) + WordToHex(c) + WordToHex(d);
+
+  return temp.toLowerCase();
+};
+
+export { MD5 };