function make_parse() {
    let symbol_table = {};
    let currentToken;
    let tokens;
    let token_nr;

    let itself = function () {
        return this;
    };

    let advance = function (id) {
        let type, o, token, value;
        if (id && currentToken.id !== id) {
            currentToken.error(`Expected ${id}`);
        }
        if (token_nr >= tokens.length) {
            currentToken = symbol_table['(end)'];
            return;
        }
        token = tokens[token_nr];
        token_nr += 1;
        value = token.value;
        type = token.type;
        if (type === 'name') {
            o = symbol_table['(name)'];
            type = 'variable';
        } else if (type === 'operator' || type === 'group') {
            o = symbol_table[value];
            if (!o) {
                token.error('Unknown operator.');
            }
        } else if (type ===  'number') {
            o = symbol_table['(literal)'];
            type = 'literal';
        } else {
            token.error('Unexpected token.');
        }
        currentToken = Object.create(o);
        currentToken.type = type;
        // currentToken.line_nr  = token.line_nr;
        // currentToken.column_nr = token.column_nr;
        currentToken.value = value;
        return currentToken;
    };

    let expression = function (rbp) {
        let left;
        let t = currentToken;
        advance();
        left = t.nud();
        while (rbp < currentToken.lbp) {
            t = currentToken;
            advance();
            left = t.led(left);
        }
        return left;
    };

    let original_symbol = {
        nud: function () {
            this.error('Undefined.');
        },
        led: function (left) {
            this.error('Missing operator.');
        }
    };

    let symbol = function (id, bp) {
        let s = symbol_table[id];
        bp = bp || 0;
        if (s) {
            if (bp >= s.lbp) {
                s.lbp = bp;
            }
        } else {
            s = Object.create(original_symbol);
            s.id = s.value = id;
            s.lbp = bp;
            symbol_table[id] = s;
        }
        return s;
    };

    let infix = function (id, bp, led) {
        let s = symbol(id, bp);
        s.led = led || function (left) {
            this.first = left;
            this.second = expression(bp);
            this.type = 'binary';
            return this;
        };
        return s;
    };

    let prefix = function (id, nud) {
        let s = symbol(id);
        s.nud = nud || function () {
            this.first = expression(70);
            this.type = 'unary';
            return this;
        };
        return s;
    };

    symbol('(end)');
    symbol('(name)').nud = itself;
    symbol(')');
    symbol('(literal)').nud = itself;

    infix('+', 50);
    infix('-', 50);

    infix('*', 60);
    infix('/', 60);
    infix('%', 60);

    infix('^', 70);

    prefix('-');
    prefix('(', function () {
        let e = expression(0);
        advance(')');
        return e;
    });

    return function (array_of_tokens) {
        tokens = array_of_tokens;
        token_nr = 0;
        advance();
        let e = expression(0);
        advance('(end)');

        return e;
    };
}

module.exports = {make_parse};

const rx_crlf = /\n|\r\n?/;

function tokenize(source) {
    const lines = (Array.isArray(source))
        ? source
        : source.split(rx_crlf);
    const result = [];

    lines.forEach(function (line, line_nr) {
        const rx_token = /(\u0020+)|([a-zA-Z][a-zA-Z_0-9]*)|(\d+(?:\.\d+)?(?:[eE][+\-]?\d+)?)|(\(|\))|([\+\-\/*\%\^])/y;

// Capture Group
// [1]  Whitespace
// [2]  Name
// [3]  Number
// [4]  Punctuator

        let column_nr = 0;
        let make = function (type, value) {

// Make a token object and append it to the result.

            result.push({
                type,
                value,
                line_nr,
                column_nr
            });
        };

        while (column_nr < line.length) {
            let captives = rx_token.exec(line);
            if (!captives) {
                throw new SyntaxError(
                    "line "
                    + line_nr
                    + " column "
                    + column_nr
                );
            } else if (captives[1]) {
                // ignore
            } else if (captives[2]) {
                make("name", captives[2]);
            } else if (captives[3]) {
                make("number", captives[3]);
            } else if (captives[4]) {
                make("group", captives[4]);
            } else if (captives[5]) {
                make("operator", captives[5]);
            }
            column_nr = rx_token.lastIndex;
        }
    });
    return result;
}

module.exports = {tokenize};

const {tokenize} = require('./tokenize');
const {make_parse} = require('./pratt');
const parse = make_parse();

const tokens = tokenize('2 * (-2.9*k - 8)');
const x = parse(tokens);

console.log(JSON.stringify(x, null, 2));

infix("(", 80, function (left) {
        let a = [];
        if (left.id === "." || left.id === "[") {
            this.arity = "ternary";
            this.first = left.first;
            this.second = left.second;
            this.third = a;
        } else {
            this.arity = "binary";
            this.first = left;
            this.second = a;
            if ((left.arity !== "unary" || left.id !== "function") &&
                    left.arity !== "name" && left.id !== "(" &&
                    left.id !== "&&" && left.id !== "||" && left.id !== "?") {
                left.error("Expected a variable name.");
            }
        }
        if (token.id !== ")") {
            while (true) {
                a.push(expression(0));
                if (token.id !== ",") {
                    break;
                }
                advance(",");
            }
        }
        advance(")");
        return this;
    });

expr = add
add = mul '+' mul | mul '-' mul | mul 
mul = power '*' power | power '/' power | power '%' power | power
power = atom '^' atom | atom
atom = number | var | '-' atom | '(' expr ')'
number = [0-9]+
var = [a-zA-Z][a-zA-Z0-9]*

vaa>Все уже реализовано, но нам нужен свой велосипед.

Ну там конкатенация, добавление префикса, проверку на равенство строк и пр.

|     Method |              Mean |             Error |            StdDev |
|----------- |------------------:|------------------:|------------------:|
|     Script | 46,113,033.333 ns | 1,611,812.3684 ns | 4,727,166.6613 ns |
|   ByteCode |          4.228 ns |         0.2075 ns |         0.2390 ns |
| IronPython |     36,127.126 ns |       563.4038 ns |       527.0083 ns |

        [Benchmark]
        public object Script() => CSharpScript.EvaluateAsync("1 + 1").GetAwaiter().GetResult();

        [Benchmark]
        public object ByteCode() => (object)(1 + 1);

    static ScriptEngine engine = Python.CreateEngine();

        [Benchmark]
        public object IronPython() =>  engine.Execute("1 + 1");

SIGN = '-' / '+'
DIGIT = '0'/'1'/'2'/3'/'4'/'5'/'6'/'7'/'8'/'9'
decimal = [ SIGN ] 1*DIGIT [ "." 1*DIGIT ] [ "e" [ SIGN ] 1*DIGIT ]

sign = or('-', '+')
digit = or('0','1','2',3','4','5','6','7','8','9')
decimal = sequence(sign, rep(1, digit), optional('.', rep(1, digit)), optional('e', sign, rep(1, digit)))

BenchmarkDotNet=v0.13.1, OS=Windows 10.0.19043.1348 (21H1/May2021Update)
Intel Core i3-6100U CPU 2.30GHz (Skylake), 1 CPU, 4 logical and 2 physical cores
.NET SDK=6.0.100
  [Host]     : .NET 6.0.0 (6.0.21.52210), X64 RyuJIT
  DefaultJob : .NET 6.0.0 (6.0.21.52210), X64 RyuJIT


|   Method |               Mean |             Error |            StdDev |
|--------- |-------------------:|------------------:|------------------:|
|   Script | 40,965,881.4433 ns | 1,100,732.4731 ns | 3,193,424.4939 ns |
| ByteCode |          0.0096 ns |         0.0049 ns |         0.0041 ns |

using System;
using static System.Console;
using System.Security.Cryptography;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;
using Microsoft.CodeAnalysis.CSharp.Scripting;

public class ScriptVsByteCode {

        [Benchmark]
        public int Script() => (int)CSharpScript.EvaluateAsync("1 + 1").Result;

        [Benchmark]
        public int ByteCode() => 1 + 1;
}

static class Program {
    static void Main() {
        var summary = BenchmarkRunner.Run<ScriptVsByteCode>();
    }
}

using System;
using System.Linq;
using System.Management.Automation;
using System.Management.Automation.Runspaces;

class A
{
    public static void Main()
    {
        // Full 
        InitialSessionState fullIss = InitialSessionState.CreateDefault();
        
        // No commands !
        InitialSessionState iss = InitialSessionState.CreateRestricted(SessionCapabilities.Language); 
        Console.WriteLine(iss.Commands.Count); // 0

        // No external calls
        iss.LanguageMode = PSLanguageMode.ConstrainedLanguage;

        // Add Get-Variable
        var getVariableCmdlet = fullIss.Commands.First(c => c.Name == "Get-Variable");
        iss.Commands.Add(getVariableCmdlet);

        // Only Get-Variable exists
        foreach (var c in iss.Commands) Console.WriteLine(c.Name);

        // Run script
        PowerShell ps = PowerShell.Create(iss);
        var r = ps.AddScript(@"$a = 'x,y';
$b = (get-variable a).Value.Split(',');
return $b;
");
        foreach (var x in r.Invoke())
        {
            Console.WriteLine(x);
        }

    }
}

public class Concat {
 public string First {get;set;}
 public string Second {get;set;}
 public string Result => First + Second;    
}

#r "nuget: Microsoft.CodeAnalysis.CSharp.Scripting"
open Microsft.CodeAnalysis.CSharp.Scripting
let result:obj = CSharpScript.EvaluateAsync("1 + 1").Result

|     Method |              Mean |             Error |            StdDev |            Median |
|----------- |------------------:|------------------:|------------------:|------------------:|
|     Script | 38,895,082.000 ns | 1,158,899.6864 ns | 3,417,041.8728 ns | 38,503,800.000 ns |
|   ByteCode |          4.397 ns |         0.2812 ns |         0.7932 ns |          4.029 ns |
| IronPython |     36,691.971 ns |       733.0558 ns |     1,624.4011 ns |     36,369.061 ns |
| IronScheme | 15,918,611.707 ns | 2,620,438.8590 ns | 7,726,423.0989 ns | 15,823,650.391 ns |

        [Benchmark]
        public object Script() => CSharpScript.EvaluateAsync("1 + 1").GetAwaiter().GetResult();

        [Benchmark]
        public object ByteCode() => (object)(1 + 1);

    static ScriptEngine engine = Python.CreateEngine();

        [Benchmark]
        public object IronPython() =>  engine.Execute("1 + 1");

        [Benchmark]
        public object IronScheme() => "(+ 1 1)".Eval();

using Microsoft.CodeAnalysis;
using Microsoft.CodeAnalysis.CSharp.Scripting;

var options = Microsoft.CodeAnalysis.Scripting.ScriptOptions
.Default.WithImports(Array.Empty<string>())
.WithReferences(Array.Empty<MetadataReference>());

var deleg = await CSharpScript.EvaluateAsync<Func<string, string, string>>("(a, b) => a + b", options);
Console.WriteLine(deleg("Hello, ", "Alice!"));

S>expr = add
S>add = mul '+' mul | mul '-' mul | mul 
S>mul = power '*' power | power '/' power | power '%' power | power
S>power = atom '^' atom | atom
S>atom = number | var | '-' atom | '(' expr ')'
S>number = [0-9]+
S>var = [a-zA-Z][a-zA-Z0-9]*
S>

/*
expr = add
add = mul (('+'|'-') mul)* 
mul = power (('*'|'/'|'%') power)*
power = atom ('^' atom)*
atom = number | var | '-' atom | '(' expr ')'
number = [0-9]+
var = [a-zA-Z][a-zA-Z0-9]*
*/

const digit = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
const letterLower = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
const letterUpper = letterLower.map(x => x.toUpperCase());
const letter = [...letterLower, ...letterUpper];
const letterOrDigit = [...letter, ...digit];

function parse(source) {
    let currentPosition = 0;

    function next(...tokens) {
        const t = peek(...tokens);

        if (t != null) {
            currentPosition += t.length;
            return t;
        }

        return null;
    }

    function peek(...tokens) {
        for (const t of tokens) {
            if (source.startsWith(t, currentPosition)) {
                return t;
            }
        }
        return null;
    }

    function revert(toPosition) {
        currentPosition = toPosition;
    }

    function expr() {
        return add();
    }

    function add() {
        const savePosition = currentPosition;
        let left = mul();

        while (true) {
            let operator = next('+', '-');
            if (operator == null) {
                break;
            }
            const right = mul();
            if (right == null) {
                revert(savePosition);
                return null;
            }
            left = {type: 'add', operator, left, right};
        }

        return left;
    }

    function mul() {
        const savePosition = currentPosition;
        let left = power();

        while (true) {
            let operator = next('*', '/', '%');
            if (operator == null) {
                break;
            }
            const right = power();
            if (right == null) {
                revert(savePosition);
                return null;
            }
            left = {type: 'mul', operator, left, right};
        }

        return left;
    }

    function power() {
        const savePosition = currentPosition;
        let left = atom();

        while (true) {
            let operator = next('^');
            if (operator == null) {
                break;
            }
            const right = atom();
            if (right == null) {
                revert(savePosition);
                return null;
            }
            left = {type: 'power', operator, left, right};
        }

        return left;
    }

    function atom() {
        return number() || variable() || negation() || grouping();
    }

    function grouping() {
        const savePosition = currentPosition;

        if (peek('(') == null) {
            return null;
        }
        next('(');
        const e = expr();
        if (e == null) {
            revert(savePosition);
            return null;
        }
        if (next(')') == null) {
            revert(savePosition);
        }
        return e;
    }

    function negation() {
        if (peek('-')) {
            next('-');

            const right = atom();

            return {type: 'negation', right};
        }

        return null;
    }

    function variable() {
        const input = [];

        const start = next(...letter);

        if (start == null) {
            return null;
        }

        input.push(start);

        while (true) {
            const x = next(...letterOrDigit);

            if (x == null) {
                break;
            }

            input.push(x);
        }

        return input.length === 0 ? null : {type: 'variable', name: input.join('')};
    }

    function number() {
        const input = [];

        while (true) {
            const d = next(...digit);

            if (d == null) {
                break;
            }

            input.push(d);
        }

        return input.length === 0 ? null : {type: 'number', value: input.join('')};
    }

    return expr();
}

console.log(JSON.stringify(parse(process.argv[2]), null, 4));

var prefix = function (id, nud) {
    var s = symbol(id);
    s.nud = nud || function () {
        scope.reserve(this);
        this.first = expression(70);
        this.arity = "unary";
        return this;
    };
    return s;
}
prefix("-");
prefix("!");
prefix("typeod");
prefix("(", function () {
    var e = expression(0);
    advance(")");
    return e;
});

var expression = function (rbp) {
    var left;
    var t = token;
    advance();
    left = t.nud();           // обрабатывается префикс оператор
    while (rbp < token.lbp) {
        t = token;
        advance();
        left = t.led(left);   // инфиксные и суффиксные операторы
    }
    return left;
}

operators = { # приоритеты и функции led
    '+': [1, lambda left: "(%s + %s)" % (left, parse(1))],
    '*': [2, lambda left: "(%s * %s)" % (left, parse(2))],
    '^': [3, lambda left: "(%s ^ %s)" % (left, parse(3))],
    '$': [0]
    }

def lbp(t):
    try:
        return operators[t][0]
    except KeyError:
        return 0
    
def nud(t):
    return t

def led(t,left):
    return operators[t][1](left)

# можно соорудить класс для каждого оператора, но это очень больше строчек получится.

def parse(rbp=0):
    global tokens
    tok = tokens.pop(0)
    result = nud(tok)
    while lbp(tokens[0]) > rbp:
        tok = tokens.pop(0)
        result = led(tok,result)
    return result

def evaluate(expr):
    global tokens
    tokens = expr.split(" ") + ['$']
    return parse()

x = evaluate("1 + 2 * 3 ^ 4 * 5 + 6")
print(x)
# https://habr.com/ru/post/50349/