funnycode/dist/encode.cjs

obfuscation {js,ts,cjs,mjs} code

'use strict';

const fs = require('fs');
const node_process = require('node:process');
const path = require('path');
const fg = require('fast-glob');
const CryptoJS = require('crypto-js');
const JavaScriptObfuscator = require('javascript-obfuscator');
const ts = require('typescript');
const JSON5 = require('json5');
const utils = require('./utils.cjs');

function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e["default"] : e; }

const path__default = /*#__PURE__*/_interopDefaultLegacy(path);
const fg__default = /*#__PURE__*/_interopDefaultLegacy(fg);
const CryptoJS__default = /*#__PURE__*/_interopDefaultLegacy(CryptoJS);
const JavaScriptObfuscator__default = /*#__PURE__*/_interopDefaultLegacy(JavaScriptObfuscator);
const ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
const JSON5__default = /*#__PURE__*/_interopDefaultLegacy(JSON5);

const cache = utils.loadCache();
async function encode(entry, key) {
  let files = [];
  if (typeof entry === "string") {
    files = await getFiles(entry);
  } else {
    for (const i of entry)
      files.push(await getFiles(i));
  }
  await transform(files, key);
  await save();
}
async function getFiles(entry) {
  if (utils.isUnixBashShellPath(entry) || !utils.isDir(utils.winPath(path__default.join(utils.cwd, entry))))
    return await fg__default(entry);
  else
    return await fg__default(`${entry}/**/*.{js,ts,cjs,mjs}`);
}
async function transform(files, key) {
  for (const file of files) {
    if (Array.isArray(file)) {
      await transform(file, key);
    } else {
      const absolutePath = utils.winPath(path__default.join(utils.cwd, file));
      let code = await fs.promises.readFile(absolutePath, "utf8");
      if (/funnycode/.test(code)) {
        console.error(`${file} already encoded , Please decode first.`);
      } else {
        cache[file] = crypto(code, key);
        const isTs = path__default.extname(file) === ".ts";
        if (isTs)
          code = await toJavascript(code);
        let funnycode = obfuscator(code);
        funnycode = `/** funnycode symbol */
        ${funnycode}`;
        if (isTs) {
          funnycode = `/* eslint-disable @typescript-eslint/ban-ts-comment */
// @ts-nocheck
${funnycode}`;
        }
        funnycode = `/* eslint-disable eslint-comments/no-unlimited-disable */
/* eslint-disable */
${funnycode}`;
        await fs.promises.writeFile(absolutePath, funnycode);
        console.log(`done ${file}`);
      }
    }
  }
}
function crypto(code, key) {
  return CryptoJS__default.AES.encrypt(code, key).toString();
}
function obfuscator(code) {
  const obfuscationResult = JavaScriptObfuscator__default.obfuscate(code);
  return obfuscationResult.getObfuscatedCode();
}
async function toJavascript(code) {
  const configPath = ts__default.findConfigFile(
    utils.cwd,
    ts__default.sys.fileExists,
    "tsconfig.json"
  );
  if (!configPath)
    throw new Error("Could not find a valid 'tsconfig.json'.");
  const tsconfig = await fs.promises.readFile(configPath, "utf8");
  const { compilerOptions = {} } = JSON5__default.parse(tsconfig);
  const { outputText } = ts__default.transpileModule(code, { compilerOptions: { module: compilerOptions.module } });
  return outputText;
}
async function save() {
  await fs.promises.writeFile(utils.CACHE_PATH, JSON.stringify(cache, null, 2));
  node_process.exit(0);
}

module.exports = encode;