simpleline 1.0.2

package/bin/simpleline.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+const sl = require("../lib/index");
+
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+    console.log("Usage: simpleline <file.smplin>");
+    process.exit(1);
+}
+
+const filePath = path.resolve(process.cwd(), args[0]);
+
+try {
+    const code = fs.readFileSync(filePath, "utf-8");
+    sl.run(code);
+} catch (err) {
+    console.error("Error reading file:", err.message);
+}

package/command.smplin

@@ -0,0 +1 @@
+|Hello, World| > log

package/lib/index.js

@@ -0,0 +1,222 @@
+function run(code) {
+    runCode(code, { "PI": Math.PI, "E": Math.E })
+    function runCode(code, setVars) {
+        function decide(txt) {
+            if (txt.match(/\/.*\//)) txt = RegExp(txt.replaceAll("/", ""))
+            if (typeof (txt) == 'string') {
+                txt = txt.replaceAll("|", "\"")
+                if (txt.match(/^[0-9]+(\.[0-9]+)?$/g)) {
+                    value = parseFloat(txt);
+                } else if (txt.match(/^\".*\"/)) {
+                    value = txt.replaceAll("\"", "")
+                } else if (txt.match(/^\[.*\]/)) {
+                    value = JSON.parse("[" + txt.replace("[", "").replace("]", "").split(", ").map((v) => variableReplace(v)) + "]")
+                } else if (txt.match(/.+( .*| (.* <? )+)?/g)) {
+                    let splt = txt.split(" < ")
+                    let first = splt[0].split(" ")
+                    let firstFirst = first.shift()
+                    let inp = first.join(" ")
+                    value = fn(firstFirst, inp, value)
+                }
+            } else {
+                value = txt
+            }
+        }
+        function variableReplace(txt) {
+            if (vars[txt]) {
+                return vars[txt]
+            } else {
+                return txt
+            }
+        }
+        function fn(type, input, val) {
+            input = input.replaceAll("\"", "")
+            input = variableReplace(input)
+            if (type == "store") {
+                if (input != "") {
+                    if (input.match(/\[.+\]/)) {
+                        vars[variableReplace(input.toString().replaceAll(/|\[|\]/g, ""))] = val
+                    } else {
+                        vars[input] = val
+                    }
+                } else {
+                    vars[curVar] = val
+                }
+                return val
+            } else if (type == "+") {
+                if (typeof (val) == 'number') {
+                    return val + parseFloat(input)
+                } else {
+                    return val + input
+                }
+            } else if (type == "get_var") {
+                return variableReplace(val)
+            } else if (type == "-") {
+                return val - parseFloat(input)
+            } else if (type == "*") {
+                return val * parseFloat(input)
+            } else if (type == "/") {
+                return val / parseFloat(input)
+            } else if (type == "^") {
+                return Math.pow(val, parseFloat(input))
+            } else if (type == "=") {
+                if (val != null && val !== 'number') {
+                    return val == input
+                } else {
+                    return val == parseFloat(input)
+                }
+            } else if (type == "->") {
+                return val > parseFloat(input)
+            } else if (type == "<-") {
+                return val < parseFloat(input)
+            } else if (type == "=->") {
+                return val >= parseFloat(input)
+            } else if (type == "<-=") {
+                return val <= parseFloat(input)
+            } else if (type == "log") {
+                console.log(val)
+                return val
+            } else if (type == "?") {
+                shouldContinueLine = (val == true)
+                if (val == false) lastLineIsFalse = 2
+                return val
+            } else if (type == "??") {
+                if (lastLineIsFalse == 1) {
+                    if (val != null) {
+                        shouldContinueLine = (val == true)
+                        if (val == false) lastLineIsFalse = 2
+                        return val
+                    } else {
+                        shouldContinueLine = true
+                        return true
+                    }
+                } else {
+                    shouldContinueLine = false
+                    return false
+                }
+            } else if (type == "!") {
+                for (vars[input] = 0; vars[input] < val - 1; vars[input]++) {
+                    run(repeatPattern, vars);
+                }
+                return vars[input]
+            } else if (type == "length") {
+                if (typeof (val) == 'object') {
+                    return val.length
+                }
+                else {
+                    return val
+                }
+            } else if (type == "round") {
+                return Math.round(val)
+            } else if (type == "ceil") {
+                return Math.ceil(val)
+            } else if (type == "floor") {
+                return Math.floor(val)
+            } else if (type == "trunc") {
+                return Math.trunc(val)
+            } else if (type == "abs") {
+                return Math.abs(val)
+            } else if (type == "sign") {
+                return Math.sign(val)
+            } else if (type == "exp") {
+                return Math.exp(val)
+            } else if (type == "logr") {
+                return Math.log(val)
+            } else if (type == "sin") {
+                return Math.sin(val)
+            } else if (type == "cos") {
+                return Math.cos(val)
+            } else if (type == "tan") {
+                return Math.tan(val)
+            } else if (type == "asin") {
+                return Math.asin(val)
+            } else if (type == "acos") {
+                return Math.acos(val)
+            } else if (type == "atan") {
+                return Math.atan(val)
+            } else if (type == "sinh") {
+                return Math.sinh(val)
+            } else if (type == "cosh") {
+                return Math.cosh(val)
+            } else if (type == "tanh") {
+                return Math.tanh(val)
+            } else if (type == "asinh") {
+                return Math.asinh(val)
+            } else if (type == "acosh") {
+                return Math.acosh(val)
+            } else if (type == "atanh") {
+                return Math.atanh(val)
+            } else if (type == "max") {
+                return Math.max(val, input)
+            } else if (type == "min") {
+                return Math.min(val, input)
+            } else if (type == "sqrt") {
+                return Math.sqrt(val)
+            } else if (type == "random") {
+                return Math.random() * (input - val) + val;
+            } else if (type == "match") {
+                return input.match(val) != null
+            } else if (type == "split") {
+                return val.split(input)
+            } else if (type.match(/.+\[[0-9]\]/g)) {
+                let varia = type.replace(/[\[0-9\]]/g, "")
+                return vars[varia][parseInt(type.replace(/[^0-9]/g, ""))]
+            } else if (type.match(/.+\[.+\]/g)) {
+                let varia = type.replace(/\[.+\]/g, "")
+                return vars[varia][vars[type.replace(/.+\[/g, "").replace(/\]/g, "")]]
+            } else if (vars[type] != null) {
+                curVar = type;
+                return vars[type]
+            } else {
+                return val
+            }
+        }
+        /**
+        * Get all indexes of a specific character in a string
+        * @param {string} str - The string to search
+        * @param {string} char - The character to find (must be a single character)
+        * @returns {number[]} - Array of indexes where the character occurs
+        */
+        function getAllIndexes(str, char) {
+            // Input validation
+            if (typeof str !== 'string' || typeof char !== 'string') {
+                throw new TypeError('Both arguments must be strings.');
+            }
+            if (char.length !== 1) {
+                throw new Error('The search character must be exactly one character long.');
+            }
+
+            const indexes = [];
+            for (let i = 0; i < str.length; i++) {
+                if (str[i] === char) {
+                    indexes.push(i);
+                }
+            }
+            return indexes;
+        }
+        let currentLine = "";
+        let repeatPattern = "";
+        let vars = setVars
+        let value = null;
+        let curVar = "";
+        let shouldContinueLine = true;
+        let lastLineIsFalse = 0;
+        code.split("\n").map((v) => v.trim()).forEach((s, i) => {
+            shouldContinueLine = true;
+            if (lastLineIsFalse > 0) lastLineIsFalse -= 1;
+            value = null
+            currentLine = s.replace(/^.*! [A-Za-z]+ >|> \?!.*$/g, '').trim();
+            repeatPattern = currentLine.replace(/^.*! [A-Za-z]+ >|> \?!.*$/g, '').trim()
+            s.split(" > ").map((v) => v.trim()).forEach((h) => {
+                if (h == "?!") shouldContinueLine = true;
+                currentLine = currentLine.replace(h + " > ", "")
+                repeatPattern = currentLine.replace(/^.*! [A-Za-z]+ >|> \?!.*$/g, '').trim()
+                if (shouldContinueLine) decide(h, vars)
+            })
+        })
+    }
+}
+
+module.exports = {
+    run
+};

package/package.json

@@ -0,0 +1,13 @@
+{
+    "name": "simpleline",
+    "version": "1.0.2",
+    "description": "Simple Line programming language",
+    "main": "lib/index.js",
+    "bin": {
+        "simpleline": "./bin/simpleline.js"
+    },
+    "type": "commonjs",
+    "keywords": [ "language", "programming", "simpleline" ],
+    "author": "ecnryptionStudios",
+    "license": "MIT"
+}