cpp.js 1.0.0-beta.6 → 1.0.0

package/src/state/calculateDependencyParameters.js

@@ -0,0 +1,64 @@
+export default function calculateDependencyParameters(config) {
+    const sourceFilter = (d) => d === config || d.export.type === 'source';
+    let headerPathWithDepends = [];
+    setPath(headerPathWithDepends, config, 'header', sourceFilter);
+    headerPathWithDepends = [...new Set(headerPathWithDepends)].join(';');
+
+    const headerGlob = [];
+    headerPathWithDepends.split(';').forEach((h) => {
+        config.ext.header.forEach((ext) => {
+            headerGlob.push(`${h}/*.${ext}`);
+        });
+    });
+
+    let nativePathWithDepends = [];
+    setPath(nativePathWithDepends, config, 'native', sourceFilter);
+    nativePathWithDepends = [...new Set(nativePathWithDepends)].join(';');
+
+    const nativeGlob = [];
+    nativePathWithDepends.split(';').forEach((h) => {
+        config.ext.source.forEach((ext) => {
+            nativeGlob.push(`${h}/*.${ext}`);
+        });
+    });
+
+    const cmakeFilter = (d) => d !== config && d.export.type === 'cmake' && d.paths.cmake !== config.paths.cliCMakeListsTxt;
+    let cmakeDepends = [];
+    setPath(cmakeDepends, config, 'this', cmakeFilter);
+    cmakeDepends = [...new Set(cmakeDepends)];
+
+    const pathsOfCmakeDepends = [...new Set(cmakeDepends
+        .map((d) => getParentPath(d.paths.cmake)))].join(';');
+    const nameOfCmakeDepends = [...new Set(cmakeDepends.map((d) => d.general.name))].join(';');
+
+    return {
+        nativeGlob,
+        headerGlob,
+        headerPathWithDepends,
+        cmakeDepends,
+        pathsOfCmakeDepends,
+        nameOfCmakeDepends,
+    };
+}
+
+function setPath(arr, dependency, type, filter = () => {}) {
+    if (filter(dependency)) {
+        if (type === 'this') {
+            arr.push(dependency);
+        } else if (Array.isArray(dependency.paths[type])) {
+            arr.push(...dependency.paths[type]);
+        } else {
+            arr.push(dependency.paths[type]);
+        }
+    }
+
+    dependency.dependencies.forEach((dep) => {
+        setPath(arr, dep, type, filter);
+    });
+}
+
+function getParentPath(path) {
+    const pathArray = path.split('/');
+    pathArray.pop();
+    return pathArray.join('/');
+}

package/src/state/index.js

@@ -0,0 +1,81 @@
+import loadJson from '../utils/loadJson.js';
+import writeJson from '../utils/writeJson.js';
+import loadConfig from './loadConfig.js';
+
+const cacheDir = `${process.cwd()}/.cppjs`;
+
+const state = {
+    platforms: {
+        All: ['Emscripten-x86_64', 'Android-arm64-v8a', 'Android-x86_64', 'iOS-iphoneos', 'iOS-iphonesimulator'],
+        WebAssembly: ['Emscripten-x86_64'],
+        Android: ['Android-arm64-v8a', 'Android-x86_64'],
+        iOS: ['iOS-iphoneos', 'iOS-iphonesimulator'],
+    },
+    config: null,
+    cache: {
+        hashes: {},
+        interfaces: {},
+        bridges: {},
+    },
+};
+
+if (typeof module !== 'undefined' && module.exports) {
+    initProcessState();
+} else {
+    await initProcessState();
+}
+
+await initProcessState();
+
+async function initProcessState() {
+    state.cache = loadCacheState();
+    state.config = await loadConfig();
+    setAllDependecyPaths();
+    if (state.config.build?.setState) {
+        state.config.build.setState(state);
+    }
+}
+
+function loadCacheState() {
+    const stateFilePath = `${cacheDir}/cache.json`;
+    return loadJson(stateFilePath) || state.cache;
+}
+
+function setAllDependecyPaths() {
+    state.config.allDependencyPaths = {};
+    state.platforms.All.forEach((platform) => {
+        const basePlatform = platform.split('-', 1)[0];
+        state.config.allDependencyPaths[platform] = {};
+        state.config.allDependencies.forEach((d) => {
+            d.export.libName.forEach((name) => {
+                state.config.allDependencyPaths[platform][name] = {
+                    root: `${d.paths.output}/prebuilt/${platform}`,
+                };
+                const dep = state.config.allDependencyPaths[platform][name];
+                if (basePlatform === 'iOS') {
+                    let xcRoot;
+                    if (platform === 'iOS-iphoneos') {
+                        xcRoot = `${d.paths.project}/${name}.xcframework/ios-arm64_arm64e`;
+                    } else if (platform === 'iOS-iphonesimulator') {
+                        xcRoot = `${d.paths.project}/${name}.xcframework/ios-arm64_arm64e_x86_64-simulator`;
+                    }
+                    dep.header = `${xcRoot}/Headers`;
+                    dep.libPath = xcRoot;
+                    dep.lib = `${dep.libPath}/lib${name}.a`;
+                    dep.bin = `${dep.root}/bin`;
+                } else {
+                    dep.header = `${dep.root}/include`;
+                    dep.libPath = `${dep.root}/lib`;
+                    dep.lib = `${dep.libPath}/lib${name}.${basePlatform === 'Android' ? 'so' : 'a'}`;
+                    dep.bin = `${dep.root}/bin`;
+                }
+            });
+        });
+    });
+}
+
+export function saveCache() {
+    writeJson(`${cacheDir}/cache.json`, state.cache);
+}
+
+export default state;

package/src/state/loadConfig.js

@@ -0,0 +1,104 @@
+import os from 'node:os';
+import systemKeys from '../utils/systemKeys.js';
+import loadJs from '../utils/loadJs.js';
+import loadJson from '../utils/loadJson.js';
+import getParentPath from '../utils/getParentPath.js';
+import getAbsolutePath from '../utils/getAbsolutePath.js';
+import fixPackageName from '../utils/fixPackageName.js';
+import getCMakeListsFilePath from '../utils/getCMakeListsFilePath.js';
+import calculateDependencyParameters from './calculateDependencyParameters.js';
+// import getCmakeParameters from './getCmakeParameters.js';
+
+export default async function loadConfig(configDir = process.cwd(), configName = 'cppjs.config') {
+    const config = await loadJs(configDir, configName) || {};
+    const output = getFilledConfig(config);
+    output.build = await loadJs(configDir, 'cppjs.build');
+
+    output.paths.systemConfig = `${os.homedir()}/.cppjs.json`;
+    output.system = loadJson(output.paths.systemConfig) || {};
+
+    Object.entries(systemKeys).forEach(([key, value]) => {
+        if (!(key in output.system)) {
+            output.system[key] = value.default;
+        }
+    });
+
+    return output;
+}
+
+function getFilledConfig(config, options = { isDepend: false }) {
+    const newConfig = {
+        general: config.general || {},
+        dependencies: (config.dependencies || []).map((d) => getFilledConfig(d, { isDepend: true })),
+        paths: config.paths || {},
+        ext: config.ext || {},
+        export: config.export || {},
+        platform: config.platform || {},
+        package: null,
+    };
+
+    if (newConfig.paths.config && !newConfig.paths.project) {
+        newConfig.paths.project = getParentPath(newConfig.paths.config);
+    }
+
+    if (!newConfig.paths.project) {
+        newConfig.paths.project = process.cwd();
+    } else {
+        newConfig.paths.project = getAbsolutePath(null, newConfig.paths.project);
+    }
+
+    newConfig.package = loadJson(`${newConfig.paths.project}/package.json`);
+
+    if (!newConfig?.general?.name) {
+        newConfig.general.name = fixPackageName(newConfig.package.name) || 'cppjssample';
+    }
+
+    const getPath = getAbsolutePath.bind(null, newConfig.paths.project);
+
+    newConfig.paths.base = getPath(newConfig.paths.base) || newConfig.paths.project;
+    newConfig.paths.cache = getPath(newConfig.paths.cache) || getPath('.cppjs');
+    newConfig.paths.build = getPath(newConfig.paths.build) || getPath(`${newConfig.paths.cache}/build`);
+    newConfig.paths.native = (newConfig.paths.native || ['src/native']).map((p) => getPath(p));
+    newConfig.paths.module = (newConfig.paths.module || newConfig.paths.native).map((p) => getPath(p));
+    newConfig.paths.header = (newConfig.paths.header || newConfig.paths.native).map((p) => getPath(p));
+    newConfig.paths.bridge = (newConfig.paths.bridge || [...newConfig.paths.native, newConfig.paths.build])
+        .map((p) => getPath(p));
+    newConfig.paths.output = getPath(newConfig.paths.output) || newConfig.paths.build;
+    newConfig.paths.cmake = options.isDepend ? getPath(getCMakeListsFilePath(newConfig.paths.output)) : (
+        getPath(newConfig.paths.cmake || getCMakeListsFilePath(newConfig.paths.project))
+    );
+    newConfig.paths.cmakeDir = getParentPath(newConfig.paths.cmake);
+    newConfig.paths.cli = getParentPath(getParentPath(import.meta.url));
+    newConfig.paths.cliCMakeListsTxt = `${newConfig.paths.cli}/assets/CMakeLists.txt`;
+
+    newConfig.ext.header = newConfig.ext.header || ['h', 'hpp', 'hxx', 'hh'];
+    newConfig.ext.source = newConfig.ext.source || ['c', 'cpp', 'cxx', 'cc'];
+    newConfig.ext.module = newConfig.ext.module || ['i'];
+
+    newConfig.export.type = newConfig.export.type || 'cmake';
+    newConfig.export.header = newConfig.export.header || 'include';
+    newConfig.export.libPath = getPath(newConfig.export.libPath || 'lib');
+    newConfig.export.libName = newConfig.export.libName || [newConfig.general.name];
+    newConfig.export.binHeaders = newConfig.export.binHeaders || [];
+
+    newConfig.platform['Emscripten-x86_64'] = newConfig.platform['Emscripten-x86_64'] || {};
+    newConfig.platform['Emscripten-x86_64-browser'] = newConfig.platform['Emscripten-x86_64-browser'] || {};
+    newConfig.platform['Emscripten-x86_64-node'] = newConfig.platform['Emscripten-x86_64-node'] || {};
+    newConfig.platform['Android-arm64-v8a'] = newConfig.platform['Android-arm64-v8a'] || {};
+    newConfig.platform['Android-x86_64'] = newConfig.platform['Android-x86_64'] || {};
+    newConfig.platform['iOS-iphoneos'] = newConfig.platform['iOS-iphoneos'] || {};
+    newConfig.platform['iOS-iphonesimulator'] = newConfig.platform['iOS-iphonesimulator'] || {};
+
+    newConfig.allDependencies = (() => {
+        const output = {};
+        [...newConfig.dependencies, ...newConfig.dependencies.map((d) => d.allDependencies).flat()].forEach((d) => {
+            output[d.paths.project] = d;
+        });
+        return Object.values(output);
+    })();
+
+    newConfig.dependencyParameters = calculateDependencyParameters(newConfig);
+    // newConfig.cmakeParameters = getCmakeParameters(newConfig);
+
+    return newConfig;
+}

package/src/utils/downloadAndExtractFile.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import fs, { mkdirSync } from 'node:fs';
+import fr from 'follow-redirects';
+import decompress from 'decompress';
+
+export default async function downloadAndExtractFile(url, output) {
+    if (fs.existsSync(`${output}/source`)) {
+        return false;
+    }
+    const filePath = await downloadFile(url, output);
+    const a = await decompress(filePath, output);
+    const oldFolder = a[0].path.split('/')[0];
+    fs.renameSync(`${output}/${oldFolder}`, `${output}/source`);
+    return true;
+}
+
+function downloadFile(url, folder) {
+    mkdirSync(folder, { recursive: true });
+    return new Promise((resolve) => {
+        const filename = path.basename(url);
+        if (fs.existsSync(`${folder}/${filename}`)) {
+            resolve(`${folder}/${filename}`);
+            return;
+        }
+
+        fr.https.get(url, (res) => {
+            const fileStream = fs.createWriteStream(`${folder}/${filename}`);
+            res.pipe(fileStream);
+
+            fileStream.on('finish', () => {
+                fileStream.close();
+                resolve(`${folder}/${filename}`);
+            });
+        });
+    });
+}

package/src/utils/findFiles.js

@@ -0,0 +1,5 @@
+import { glob } from 'glob';
+
+export default function findFiles(regex, options = {}) {
+    return glob.sync(regex, { absolute: true, posix: true, ...options }).map(p => p.replace('//?/', ''));
+}

package/src/utils/fixPackageName.js

@@ -0,0 +1,7 @@
+export default function fixPackageName(name) {
+    if (!name) {
+        return null;
+    }
+
+    return name.replace(/[^a-zA-Z0-9-_]+/g, '');
+}

package/src/utils/getAbsolutePath.js

@@ -0,0 +1,14 @@
+import upath from 'upath';
+
+export default function getAbsolutePath(projectPath, path) {
+    if (!path) {
+        return null;
+    }
+    if (upath.isAbsolute(path)) {
+        return upath.resolve(path);
+    }
+    if (projectPath) {
+        return upath.resolve(upath.join(upath.resolve(projectPath), path));
+    }
+    return upath.resolve(path);
+}

package/src/utils/getCMakeListsFilePath.js

@@ -0,0 +1,17 @@
+import getParentPath from './getParentPath.js';
+import findFiles from './findFiles.js';
+
+export default function getCMakeListsFilePath(basePath = process.cwd()) {
+    let temp = findFiles('CMakeLists.txt', { cwd: basePath });
+    if (temp.length === 0) {
+        temp = findFiles('*/CMakeLists.txt', { cwd: basePath, ignore: ['node_modules/*', 'dist/*', 'build/*'] });
+    }
+
+    if (temp.length > 0) return temp[0];
+    return getCliCMakeListsFile();
+}
+
+export function getCliCMakeListsFile() {
+    const cliPath = getParentPath(getParentPath(import.meta.url));
+    return `${cliPath}/assets/CMakeLists.txt`;
+}

package/src/utils/getOsUserAndGroupId.js

@@ -1,4 +1,4 @@
-import os from 'os';
+import os from 'node:os';
 
 let osUserAndGroupId;
 export default function getOsUserAndGroupId() {

package/src/utils/getParentPath.js

@@ -0,0 +1,12 @@
+import * as url from 'node:url';
+import upath from 'upath';
+
+export default function getParentPath(importUrl) {
+    let input = importUrl;
+    try {
+        input = url.fileURLToPath(input);
+    } catch (e) { /* empty */ }
+    const filename = upath.normalize(input);
+    const temp = filename.split('/'); temp.pop();
+    return temp.join('/');
+}

package/src/utils/hash.js

@@ -0,0 +1,20 @@
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+
+export function getFileHash(path) {
+    const data = fs.readFileSync(path);
+    return getContentHash(data);
+    /* return new Promise((resolve, reject) => {
+        const hash = createHash('sha256');
+        const rs = fs.createReadStream(path);
+        rs.on('error', reject);
+        rs.on('data', (chunk) => hash.update(chunk));
+        rs.on('end', () => resolve(hash.digest('hex')));
+    }); */
+}
+
+export function getContentHash(content) {
+    const hash = createHash('sha256');
+    hash.update(content);
+    return hash.digest('hex');
+}

package/src/utils/loadJs.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+
+export default async function loadJs(path, fileName, fileExt = ['json', 'js', 'mjs', 'cjs', 'ts']) {
+    let filePath;
+    fileExt.some((e) => {
+        filePath = `${path}/${fileName}.${e}`;
+        if (!fs.existsSync(filePath)) {
+            filePath = null;
+            return false;
+        }
+        return true;
+    });
+
+    if (filePath) {
+        let file;
+        if (typeof module !== 'undefined' && module.exports) {
+            file = require(`file:///${filePath}`);
+        } else {
+            file = await import(`file:///${filePath}`);
+        }
+        if (file.default) file = file.default;
+
+        if (typeof file === 'function') {
+            return file();
+        }
+        if (typeof file === 'object') {
+            return file;
+        }
+    }
+
+    return null;
+}

package/src/utils/loadJson.js

@@ -0,0 +1,16 @@
+import fs from 'node:fs';
+
+export default function loadJson(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+
+    try {
+        const stateContent = fs.readFileSync(filePath, { encoding: 'utf8', flag: 'r' });
+        const state = JSON.parse(stateContent);
+        return state;
+    } catch (e) {
+        console.error(e);
+        return null;
+    }
+}

package/src/utils/pullDockerImage.js

@@ -1,9 +1,9 @@
-import { execFileSync } from 'child_process';
+import { execFileSync } from 'node:child_process';
 
 let isDockerImageAvailable = false;
 
 export function getDockerImage() {
-    return 'bugra9/cpp.js:0.2.6';
+    return 'bugra9/cpp.js:0.2.8';
 }
 
 export default function pullDockerImage() {

package/src/utils/systemKeys.js

@@ -0,0 +1,18 @@
+const systemKeys = {
+    XCODE_DEVELOPMENT_TEAM: {
+        description: 'The unique identifier of the development team used for code signing and app distribution in Xcode.',
+        default: '',
+    },
+    RUNNER: {
+        description: 'The execution environment for running the application.',
+        options: ['DOCKER_RUN', 'DOCKER_EXEC', 'LOCAL'],
+        default: 'DOCKER_RUN',
+    },
+    LOG_LEVEL: {
+        description: 'The verbosity of log output.',
+        options: ['DEBUG', 'INFO', 'WARN', 'ERROR'],
+        default: 'INFO',
+    },
+};
+
+export default systemKeys;

package/src/utils/writeJson.js

@@ -0,0 +1,9 @@
+import fs from 'node:fs';
+
+export default function writeJson(filePath, data) {
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 4));
+    } catch (e) {
+        console.error(e);
+    }
+}

package/.mocharc.yaml

@@ -1,3 +0,0 @@
-spec:
-  - 'src/**/*.spec.js'
-  - 'test/*.spec.js'

package/src/functions/createBridge.js

@@ -1,37 +0,0 @@
-import getBaseInfo from '../utils/getBaseInfo.js';
-import getPathInfo from '../utils/getPathInfo.js';
-import { getDependencyParams } from './getCmakeParams.js';
-import run from './run.js';
-
-const platform = 'Emscripten-x86_64';
-
-export default function createBridge(compiler) {
-    const bridges = [];
-
-    const allHeaders = getDependencyParams(compiler.config).headerPathWithDepends.split(';');
-
-    let includePath = [
-        ...compiler.config.getAllDependencies().map((d) => `${d.paths.output}/prebuilt/${platform}/include`),
-        ...compiler.config.getAllDependencies().map((d) => `${d.paths.output}/prebuilt/${platform}/swig`),
-        ...compiler.config.paths.header,
-        ...allHeaders,
-    ].filter((path) => !!path.toString()).map((path) => `-I/tmp/cppjs/live/${getPathInfo(path, compiler.config.paths.base).relative}`);
-    includePath = [...new Set(includePath)];
-
-    compiler.interfaces.forEach((filePath) => {
-        const input = getPathInfo(filePath, compiler.config.paths.base);
-        const output = getPathInfo(`${compiler.config.paths.temp}/bridge`, compiler.config.paths.base);
-        const base = getBaseInfo(compiler.config.paths.base);
-
-        run(compiler, 'swig', [
-            '-c++',
-            '-embind',
-            '-o', `/tmp/cppjs/live/${output.relative}/${filePath.split('/').at(-1)}.cpp`,
-            ...includePath,
-            `/tmp/cppjs/live/${input.relative}`,
-        ]);
-
-        bridges.push(`${base.withSlash}${output.relative}/${filePath.split('/').at(-1)}.cpp`);
-    });
-    return bridges;
-}

package/src/functions/createLib.js

@@ -1,44 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import getCmakeParams from './getCmakeParams.js';
-import getPathInfo from '../utils/getPathInfo.js';
-
-const cpuCount = os.cpus().length - 1;
-
-export default function createLib(compiler) {
-    if (!compiler.platform) return;
-
-    let platformParams = [];
-    switch (compiler.platform) {
-        case 'Emscripten-x86_64':
-            platformParams = ['-DBUILD_TYPE=STATIC'];
-            break;
-        case 'Android-arm64-v8a':
-            platformParams = ['-DBUILD_TYPE=SHARED'];
-            break;
-        case 'iOS-iphoneos':
-            platformParams = ['-DBUILD_TYPE=STATIC'];
-            break;
-        case 'iOS-iphonesimulator':
-            platformParams = ['-DBUILD_TYPE=STATIC'];
-            break;
-        default:
-    }
-
-    const libdir = `${getPathInfo(compiler.config.paths.output, compiler.config.paths.base).relative}/prebuilt/${compiler.platform}`;
-    const basePlatform = compiler.platform.split('-', 1)[0];
-    const params = getCmakeParams(compiler.config, '/tmp/cppjs/live/', true, false);
-    compiler.run(null, [
-        basePlatform === 'iOS' ? 'ios-cmake' : 'cmake', '/tmp/cppjs/cmake',
-        '-DCMAKE_BUILD_TYPE=Release', ...platformParams,
-        `-DCMAKE_INSTALL_PREFIX=/tmp/cppjs/live/${libdir}`, `-DPROJECT_NAME=${compiler.config.general.name}`,
-        ...params,
-    ]);
-    if (basePlatform === 'iOS') {
-        compiler.run(null, ['ios-cmake', '--build', '.', '--config', 'Release', '--target', 'install']);
-    } else {
-        compiler.run(null, ['make', `-j${cpuCount}`, 'install']);
-    }
-
-    fs.rmSync(compiler.config.paths.temp, { recursive: true, force: true });
-}

package/src/functions/createWasm.js

@@ -1,67 +0,0 @@
-import fs from 'fs';
-import buildJS from './buildJS.js';
-import run from './run.js';
-import getCmakeParams from './getCmakeParams.js';
-import getLibs from './getLibs.js';
-import getData from './getData.js';
-import getPathInfo from '../utils/getPathInfo.js';
-
-export default async function createWasm(compiler, options = {}) {
-    const output = `/tmp/cppjs/live/${getPathInfo(compiler.config.paths.temp, compiler.config.paths.base).relative}`;
-
-    let params = getCmakeParams(compiler.config, '/tmp/cppjs/live/', true, false);
-    run(compiler, 'emcmake', [
-        'cmake', '/tmp/cppjs/cmake',
-        '-DCMAKE_BUILD_TYPE=Release', '-DBUILD_TYPE=STATIC',
-        `-DCMAKE_INSTALL_PREFIX=${output}`, `-DPROJECT_NAME=${compiler.config.general.name}`,
-        ...params,
-    ]);
-    run(compiler, 'emmake', ['make', 'install']);
-
-    params = getCmakeParams(compiler.config, '/tmp/cppjs/live/', false, true);
-    run(compiler, 'emcmake', [
-        'cmake', '/tmp/cppjs/cmake',
-        '-DCMAKE_BUILD_TYPE=Release', '-DBUILD_TYPE=STATIC',
-        `-DCMAKE_INSTALL_PREFIX=${output}`, `-DPROJECT_NAME=${compiler.config.general.name}bridge`,
-        ...params,
-    ]);
-    run(compiler, 'emmake', ['make', 'install']);
-
-    const libs = getLibs(compiler.config, '/tmp/cppjs/live/');
-    const data = Object.entries(getData(compiler.config, 'data', '/tmp/cppjs/live/', 'Emscripten-x86_64', 'browser')).map(([key, value]) => ['--preload-file', `${key.replaceAll('@', '@@')}@${value}`]).flat();
-    run(compiler, 'emcc', [
-        '-lembind', '-Wl,--whole-archive',
-        ...libs, ...(options.cc || []),
-        '-s', 'WASM=1', '-s', 'MODULARIZE=1', '-s', 'DYNAMIC_EXECUTION=0',
-        '-s', 'RESERVED_FUNCTION_POINTERS=200', '-s', 'DISABLE_EXCEPTION_CATCHING=0', '-s', 'FORCE_FILESYSTEM=1',
-        '-s', 'ALLOW_MEMORY_GROWTH=1',
-        '-s', 'EXPORTED_RUNTIME_METHODS=["FS", "ENV"]',
-        '-o', `${output}/${compiler.config.general.name}.js`,
-        ...data,
-    ]);
-    await buildJS(compiler, `${compiler.config.paths.temp}/${compiler.config.general.name}.js`, 'browser');
-    run(compiler, 'emcc', [
-        '-lembind', '-Wl,--whole-archive', '-lnodefs.js',
-        ...libs, ...(options.cc || []),
-        '-s', 'WASM=1', '-s', 'MODULARIZE=1', '-s', 'DYNAMIC_EXECUTION=0',
-        '-s', 'RESERVED_FUNCTION_POINTERS=200', '-s', 'DISABLE_EXCEPTION_CATCHING=0', '-s', 'FORCE_FILESYSTEM=1', '-s', 'NODERAWFS',
-        '-s', 'ALLOW_MEMORY_GROWTH=1',
-        '-s', 'EXPORTED_RUNTIME_METHODS=["FS", "ENV", "NODEFS"]',
-        '-o', `${output}/${compiler.config.general.name}.js`,
-    ]);
-    Object.entries(getData(compiler.config, 'data', null, 'Emscripten-x86_64', 'node')).forEach(([key, value]) => {
-        if (fs.existsSync(key)) {
-            const dAssetPath = `${compiler.config.paths.temp}/data/${value}`;
-            if (!fs.existsSync(dAssetPath)) {
-                fs.mkdirSync(dAssetPath, { recursive: true });
-                fs.cpSync(key, dAssetPath, { recursive: true });
-            }
-        }
-    });
-    await buildJS(compiler, `${compiler.config.paths.temp}/${compiler.config.general.name}.js`, 'node');
-    if (fs.existsSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.data`)) {
-        fs.renameSync(`${compiler.config.paths.temp}/${compiler.config.general.name}.data`, `${compiler.config.paths.temp}/${compiler.config.general.name}.data.txt`);
-    }
-
-    return compiler.config.paths.temp;
-}