nirguna 0.1.0

package/README.md

@@ -0,0 +1,140 @@
+# Ishvara
+
+![ishvara](https://github.com/putoutjs/ishvara/blob/master/images/ishvara.jpg)
+
+Compile JavaScript to WASM and Fasm.
+
+<img width="300" alt="image" src="https://github.com/user-attachments/assets/e3808fa0-90cc-4e9f-acb3-68babafa0350" />
+
+## Install
+
+```
+npm i ishvara -g
+```
+
+## Usage Example
+
+Let's suppose you have JavaScript:
+
+```js
+function add() {
+    const eax = 1;
+    const ebx = 2;
+    
+    return eax + ebx;
+}
+```
+
+You can compile it to fasm and wasm.
+
+### Fasm
+
+Let's compile javascript with:
+
+```sh
+ishvara --target fasm example/fn.ts -o code
+```
+
+To intermediate representation:
+
+```js
+__ishvara_add: {
+    mov(eax, 0x1);
+    mov(ebx, 0x2);
+    add(eax, ebx);
+    ret;
+}
+```
+
+Also we can compile it with:
+
+```sh
+ishvara -t fasm example/fn.ts -o code
+```
+
+to assembly representation with:
+
+```asm
+__ishvara_add:
+mov eax, 0x1
+mov ebx, 0x2
+add eax, ebx
+ret
+```
+
+Also we can compile it to binary representation with `ishvara fasm example/fn.ts`:
+
+```sh
+$ hexdump example/fn.bin
+
+0000000 b866 0001 0000 bb66 0002 0000 0166 c3d8
+0000010
+```
+
+### wasm
+
+Let's suppose we have absolutely valid JavaScript file with types, which we can run with node v24.
+
+```ts
+import {create} from '#ishvara';
+
+export const stack = [];
+
+export const imports = [
+    ['console', 'log', function log() {
+        return i32;
+    }],
+];
+
+const {
+    i32,
+    local,
+    call,
+} = create({
+    stack,
+    imports,
+});
+
+export function x(a: i32, b: i32): i32 {
+    i32.add(local.get(a), local.get(b));
+    call('log');
+}
+```
+
+Compiled with `ishvara 1.wast.ts` to `1.wast`:
+
+```wast
+(module
+    (import "console" "log" (func $log (param $message i32) (result i32)))
+    (func $x (export "x") (param $a i32) (param $b i32) (result i32)
+        (i32.add (local.get $a) (local.get $b))
+        (call $log)
+    )
+)
+```
+
+With:
+
+```js
+import {compile} from 'ishvara';
+
+const wast = compile(wastts);
+const binary = await translate(wast);
+
+const {x} = run(binary, {
+    console: {
+        log: (a) => {
+            console.log(a);
+            return a;
+        },
+    },
+});
+
+x(1, 2);
+// outputs
+3;
+```
+
+## License
+
+MIT

package/bin/ishvara.js

@@ -0,0 +1,174 @@
+#!/usr/bin/env node
+
+import {writeFileSync} from 'node:fs';
+import process, {cwd, exit} from 'node:process';
+import {stat} from 'node:fs/promises';
+import path, {join} from 'node:path';
+import {codeFrameColumns} from '@putout/babel';
+import chalk from 'chalk';
+import {bundle} from '@nirguna/bundler';
+import {prepareError} from '@nirguna/bundler/prepare-error';
+import {help} from '@nirguna/cli-help';
+import {
+    parseArgs,
+    validateArgs,
+    parseConfig,
+} from '@nirguna/cli-args';
+import {compile} from '#ishvara';
+
+debugger;
+const onStageChange = (args) => (stage, {last, places}) => {
+    const line = stage[0].toUpperCase() + stage.slice(1);
+    
+    log(args, '✅ \n');
+    log(args, line, {
+        withDivider: true,
+    });
+    
+    if (!last)
+        return;
+    
+    if (!places.length) {
+        log(args, '✅ \n\n');
+        return;
+    }
+    
+    log(args, '❌ \n\n');
+    
+    const fullName = join(cwd(), name);
+    
+    for (const {message, position} of places) {
+        const {line, column} = position;
+        
+        if (stage === 'translate') {
+            console.error(`${chalk.blue(`${line}:${column}`)}: ${chalk.red(message)}`);
+            continue;
+        }
+        
+        console.error(`file://${chalk.blue(`${fullName}:${line}:${column}`)}: ${chalk.red(message)}`);
+    }
+    
+    exit(1);
+};
+
+const {O = 1, RAW} = process.env;
+const args = parseArgs(process.argv.slice(2));
+
+if (args.help) {
+    console.log(help());
+    process.exit(0);
+}
+
+await validateArgs(args, {
+    log: (a) => console.error(chalk.red(a)),
+    exit: process.exit,
+    stat,
+});
+
+const [name] = args._;
+
+const [errorOptions, config] = parseConfig(name);
+
+if (errorOptions) {
+    console.error(errorOptions);
+    process.exit(1);
+}
+
+log(args, `🔎 ${name}\n`);
+log(args, `🚀 ${args.target}\n\n`);
+
+log(args, 'Bundle', {
+    withDivider: true,
+});
+
+const [error, source] = await bundle(name, config);
+
+if (error) {
+    console.log(error);
+    
+    if (!error.id) {
+        console.error(error.message);
+        process.exit(1);
+    }
+    
+    if (error.code === 'UNRESOLVED_IMPORT') {
+        console.error(`file://${chalk.blue(error.id)}: ${chalk.red(error.message)}`);
+        process.exit(1);
+    }
+    
+    const {message} = await prepareError(error);
+    
+    const {line} = error.location?.start || error.loc;
+    const name = error.id || error.fileName;
+    
+    console.error(`file://${chalk.blue(name)}:${line}: ${chalk.red(message)}`);
+    process.exit(1);
+}
+
+if (/bundled?/.test(args.output)) {
+    log(args, `✅ \n\n`);
+    
+    if (RAW)
+        console.log(source);
+    else
+        console.log(codeFrameColumns(source, {}, {
+            highlightCode: true,
+            forceColor: true,
+        }));
+    
+    process.exit();
+}
+
+const [binary] = await compile(source, {
+    name,
+    type: args.output,
+    target: args.target,
+    optimization: Boolean(Number(O)),
+    config,
+    onStageChange: onStageChange(args),
+});
+
+if (args.output) {
+    if (args.output === 'binary' || RAW)
+        process.stdout.write(binary);
+    else
+        console.log(codeFrameColumns(String(binary), {}, {
+            highlightCode: true,
+            forceColor: true,
+        }));
+    
+    process.exit();
+}
+
+if (!args.output)
+    if (args.target === 'fasm')
+        write(name, 'bin', binary);
+    else if (args.target === 'wasm')
+        write(name, 'wasm', binary);
+
+if (args.target === 'wast')
+    write(name, 'wast', binary);
+else if (args.target === 'asm')
+    write(name, 'asm', binary);
+
+process.exit(0);
+
+function write(input, extension, binary) {
+    const {dir, name} = path.parse(input);
+    const full = `${join(dir, name)}.${extension}`;
+    
+    writeFileSync(full, binary);
+    log(args, `💾 ${full}\n\n`);
+}
+
+function log({quiet}, message, {withDivider} = {}) {
+    if (quiet)
+        return;
+    
+    process.stdout.write(message);
+    
+    if (withDivider) {
+        const divider = Array(35 - message.length).join('.');
+        process.stdout.write(divider);
+    }
+}

package/lib/ishvara.js

@@ -0,0 +1,29 @@
+import * as wasm from '#compiler-wasm';
+import * as fasm from '#compiler-fasm';
+
+export const compile = async (source, options) => {
+    const {
+        target,
+        type,
+        name,
+        optimization,
+        config,
+        onStageChange,
+    } = options;
+    
+    if (target === 'wasm')
+        return await wasm.compile(source, {
+            type,
+            name,
+            optimization,
+            onStageChange,
+        });
+    
+    return await fasm.compile(source, {
+        type,
+        target,
+        optimization,
+        config,
+        onStageChange,
+    });
+};

package/package.json

@@ -0,0 +1,111 @@
+{
+  "name": "nirguna",
+  "version": "0.1.0",
+  "type": "module",
+  "author": "coderaiser <mnemonic.enemy@gmail.com> (https://github.com/coderaiser)",
+  "description": "Compile JavaScript to WASM and FASM",
+  "homepage": "https://github.com/putoutjs/nirguna",
+  "main": "lib/nirguna.js",
+  "bin": {
+    "nirguna": "bin/nirguna.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/putoutjs/nirguna.git"
+  },
+  "scripts": {
+    "test": "madrun test",
+    "watch:test": "madrun watch:test",
+    "lint": "madrun lint",
+    "fresh:lint": "madrun fresh:lint",
+    "lint:fresh": "madrun lint:fresh",
+    "fix:lint": "madrun fix:lint",
+    "coverage": "madrun coverage",
+    "report": "madrun report",
+    "build:boot": "madrun build:boot",
+    "build:boot:fasm": "madrun build:boot:fasm",
+    "build:boot:asm": "madrun build:boot:asm",
+    "build:nemesis": "madrun build:nemesis",
+    "build:nemesis:asm": "madrun build:nemesis:asm",
+    "build:nemesis:fasm": "madrun build:nemesis:fasm"
+  },
+  "dependencies": {
+    "@nirguna/bundler": "*",
+    "@nirguna/cli-args": "*",
+    "@nirguna/cli-help": "*",
+    "@nirguna/operator-fasm": "*",
+    "@nirguna/plugin-bandler-fasm": "*",
+    "@nirguna/plugin-fasm": "*",
+    "@nirguna/plugin-nirguna": "*",
+    "@nirguna/plugin-nemesis": "*",
+    "@nirguna/plugin-optimizer-fasm": "*",
+    "@nirguna/plugin-optimizer-wasm": "*",
+    "@nirguna/plugin-wasm": "*",
+    "@nirguna/runner-fasm": "*",
+    "@nirguna/runner-wasm": "*",
+    "@putout/babel": "^5.2.12",
+    "@putout/plugin-assignment": "^2.0.0",
+    "@putout/plugin-esm": "^9.2.0",
+    "@putout/plugin-remove-nested-blocks": "^9.0.0",
+    "@putout/plugin-remove-useless-operand": "^3.0.0",
+    "@putout/printer": "^17.1.0",
+    "@typescript-eslint/typescript-estree": "^8.32.1",
+    "chalk": "^5.4.1",
+    "fasm.js": "^1.0.7",
+    "hexdump-nodejs": "^0.1.0",
+    "iced-x86": "^1.21.0",
+    "just-snake-case": "^3.2.0",
+    "putout": "^41.20.0",
+    "try-catch": "^4.0.9",
+    "try-to-catch": "^4.0.5",
+    "typescript": "^5.8.3",
+    "wabt": "^1.0.37",
+    "yargs-parser": "^22.0.0"
+  },
+  "keywords": [
+    "putout"
+  ],
+  "devDependencies": {
+    "@putout/plugin-printer": "^7.1.1",
+    "@putout/test": "^15.1.1",
+    "c8": "^10.0.0",
+    "eslint": "^10.0.0",
+    "eslint-plugin-n": "^17.0.0",
+    "eslint-plugin-putout": "^30.0.2",
+    "just-kebab-case": "^4.2.0",
+    "madrun": "^12.1.3",
+    "montag": "^1.2.1",
+    "nodemon": "^3.0.1",
+    "redlint": "^5.7.0",
+    "supertape": "^12.4.0"
+  },
+  "imports": {
+    "#cli-args": "./packages/cli-args/index.js",
+    "#cli-help": "./packages/cli-help/help.js",
+    "#plugin-wasm": "./packages/plugin-wasm/lib/index.js",
+    "#plugin-fasm": "./packages/plugin-fasm/lib/index.js",
+    "#plugin-nirguna": "./packages/plugin-nirguna/lib/index.js",
+    "#plugin-bundler-fasm": "./packages/plugin-bundler-fasm/lib/index.js",
+    "#compiler-wasm": "./packages/compiler-wasm/compiler.js",
+    "#compiler-fasm": "./packages/compiler-fasm/compiler.js",
+    "#optimizer-fasm": "./packages/optimizer-fasm/optimizer.js",
+    "#optimizer-wasm": "./packages/optimizer-wasm/optimizer.js",
+    "#printer-wasm": "./packages/printer-wasm/printer.js",
+    "#printer-fasm": "./packages/printer-fasm/printer.js",
+    "#translator-wasm": "./packages/translator-wasm/translator.js",
+    "#test-wasm": "./packages/test-wasm/test.js",
+    "#translator-fasm": "./packages/translator-fasm/translator.js",
+    "#transformer-wasm": "./packages/transformer-wasm/transformer.js",
+    "#transformer-fasm": "./packages/transformer-fasm/transformer.js",
+    "#operator-wasm": "./packages/operator-wasm/index.js",
+    "#operator-fasm": "./externals/operator-fasm/index.ts",
+    "#nirguna": "./lib/nirguna.js"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/packages/compiler-fasm/compiler.js

@@ -0,0 +1,75 @@
+import {transform} from '#transformer-fasm';
+import {print} from '#printer-fasm';
+import {translate} from '#translator-fasm';
+import {optimize} from '#optimizer-fasm';
+
+const noop = () => {};
+
+export const compile = async (source, options = {}) => {
+    const {
+        name,
+        type = 'binary',
+        optimization = true,
+        target = 'fasm',
+        config,
+        onStageChange = noop,
+    } = options;
+    
+    const emitStateChange = (a) => onStageChange(a, {
+        last: false,
+        places: [],
+    });
+    
+    const emitLastStateChange = (a, places = []) => onStageChange(a, {
+        last: true,
+        places,
+    });
+    
+    const [code, compilePlaces] = transform(source, config);
+    
+    if (compilePlaces.length) {
+        emitLastStateChange('transform', compilePlaces);
+        
+        return [code, compilePlaces];
+    }
+    
+    if (type === 'code') {
+        emitLastStateChange('transform');
+        return [code, compilePlaces];
+    }
+    
+    emitStateChange('transform');
+    
+    const [optimized, optimizedPlaces] = optimization ? optimize(code) : [
+        code,
+        [],
+    ];
+    
+    if (type === 'optimized') {
+        emitLastStateChange('optimize');
+        return [optimized, optimizedPlaces];
+    }
+    
+    emitStateChange('optimize');
+    
+    const assembly = print(optimized);
+    
+    if (type === 'assembly' || target === 'asm') {
+        emitLastStateChange('Print');
+        return [
+            assembly,
+            [],
+        ];
+    }
+    
+    emitStateChange('print');
+    
+    const [binary, places] = await translate(assembly, {
+        name,
+        type,
+    });
+    
+    emitLastStateChange('translate', places);
+    
+    return [binary, places];
+};

package/packages/compiler-wasm/compiler.js

@@ -0,0 +1,62 @@
+import {translate} from '#translator-wasm';
+import {transform} from '#transformer-wasm';
+import {print} from '#printer-wasm';
+import {optimize} from '#optimizer-wasm';
+
+const noop = () => {};
+
+export const compile = async (source, options = {}) => {
+    const {
+        name,
+        type = 'binary',
+        onStageChange = noop,
+    } = options;
+    
+    const emitStateChange = (a) => onStageChange(a, {
+        last: false,
+        places: [],
+    });
+    
+    const emitLastStateChange = (a, places = []) => onStageChange(a, {
+        last: true,
+        places,
+    });
+    
+    const [code, compilePlaces] = transform(source);
+    
+    if (compilePlaces.length) {
+        emitLastStateChange('Transform', compilePlaces);
+        return [code, compilePlaces];
+    }
+    
+    if (type === 'code') {
+        emitLastStateChange('Transform');
+        return [code, compilePlaces];
+    }
+    
+    emitStateChange('transform');
+    const [optimized, optimizedPlaces] = optimize(code);
+    
+    if (/optimize/.test(type)) {
+        emitLastStateChange('optimize');
+        return [optimized, optimizedPlaces];
+    }
+    
+    emitStateChange('Optimize');
+    const assembly = print(optimized);
+    
+    if (type === 'assembly')
+        return [
+            assembly,
+            [],
+        ];
+    
+    emitStateChange('print');
+    const [binary, places] = await translate(assembly, {
+        name,
+        type,
+    });
+    
+    emitLastStateChange('translate', places);
+    return [binary, places];
+};

package/packages/operator-wasm/index.js

@@ -0,0 +1,55 @@
+const isFn = (a) => typeof a === 'function';
+
+export const create = ({stack, imports = []}) => {
+    const push = stack.push.bind(stack);
+    const pop = stack.pop.bind(stack);
+    
+    const i32 = createI32({
+        push,
+        pop,
+    });
+    
+    const local = createLocal({
+        push,
+    });
+    
+    const call = createCall(imports);
+    
+    return {
+        i32,
+        local,
+        call,
+    };
+};
+
+const createCall = (imports) => (name, ...args) => {
+    if (isFn(name))
+        return name(...args);
+    
+    for (const [, currentName, fn, override] of imports) {
+        if (name !== currentName)
+            continue;
+        
+        const currentFn = override || fn;
+        
+        return currentFn(...args);
+    }
+    
+    throw Error(`[call]: '${name}' not found`);
+};
+
+const createI32 = ({push, pop}) => ({
+    const: push,
+    add: createAdd({
+        push,
+        pop,
+    }),
+});
+
+const createLocal = ({push}) => ({
+    get: push,
+});
+
+const createAdd = ({push, pop}) => (a, b) => {
+    push(pop(a) + pop(b));
+};

package/packages/optimizer-fasm/optimizer.js

@@ -0,0 +1,15 @@
+import putout from 'putout';
+import * as removeNestedBlocks from '@putout/plugin-remove-nested-blocks';
+import * as fasm from '@nirguna/plugin-optimizer-fasm';
+
+export const optimize = (source) => {
+    const {code, places} = putout(source, {
+        isTS: true,
+        plugins: [
+            ['ishvara/optimizer-fasm', fasm],
+            ['remove-nested-blocks', removeNestedBlocks],
+        ],
+    });
+    
+    return [code, places];
+};

package/packages/optimizer-wasm/optimizer.js

@@ -0,0 +1,13 @@
+import putout from 'putout';
+import * as wasm from '@nirguna/plugin-optimizer-wasm';
+
+export const optimize = (source) => {
+    const {code, places} = putout(source, {
+        isTS: true,
+        plugins: [
+            ['ishvara/optimizer-wasm', wasm],
+        ],
+    });
+    
+    return [code, places];
+};

package/packages/printer-fasm/printer/printer.js

@@ -0,0 +1,30 @@
+import {print as putoutPrint} from '@putout/printer';
+import {CallExpression} from './visitors/call-expression.js';
+import {MemberExpression} from './visitors/member-expression.js';
+import {BlockStatement} from './visitors/block-statement.js';
+import {LabeledStatement} from './visitors/labeled-statement.js';
+import {ExpressionStatement} from './visitors/expression-statement/expression-statement.js';
+import {SequenceExpression} from './visitors/sequence-expression.js';
+import {AssignmentExpression} from './visitors/assignment-expression.js';
+import {TaggedTemplateExpression} from './visitors/tagged-template-expression.js';
+import {StringLiteral} from './visitors/string-literal.js';
+
+export const print = (ast) => {
+    return putoutPrint(ast, {
+        semantics: {
+            comments: false,
+            maxElementLengthInOneLine: 100,
+        },
+        visitors: {
+            AssignmentExpression,
+            CallExpression,
+            MemberExpression,
+            BlockStatement,
+            LabeledStatement,
+            ExpressionStatement,
+            SequenceExpression,
+            StringLiteral,
+            TaggedTemplateExpression,
+        },
+    });
+};