await is only valid in async function - eval in async

If you want to be able to await the eval you can use this:

await Object.getPrototypeOf(async function() {}).constructor("your code here")();

This uses the AsyncFunction constructor. MDN has a page on it which describes the differences between using it and using eval:

Note: async functions created with the AsyncFunction constructor do not create closures to their creation contexts; they are always created in the global scope.

When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the AsyncFunction constructor was called.

This is different from using eval with code for an async function expression.

This means that if you have variables that you want your evaled code to be able to access, you can either

1. Pass them in as arguments:

const testVar = "Hello world";
const result = await Object.getPrototypeOf(async function() {}).constructor('testVar', `
    console.log(testVar);
    await myAsyncFunc();
    return testVar;
`)(testVar);
// result will be "Hello world"

2. Add them to globalThis:

const testVar = "Hello world";
globalThis["testVar"] = testVar;
const result = await Object.getPrototypeOf(async function() {}).constructor(`
    console.log(testVar);
    await myAsyncFunc();
    return testVar;
`)();
// result will be "Hello world"
delete globalThis["testVar"];

Ended up using Ermir`s answer:

let ctxScript = '(async () => {await foo1();await foo2();is_script_ended = true; })();';

async function foo()
{
  // a lot of code
  is_script_ended = false;
  eval( ctxScript );
  while(!is_script_ended){ await sleep(1000); }
  // a lot of code
}

If you want to dynamically call some async code in some larger function, then you can supply a callback that does this for you. This way you can call your function with different extra functionality by giving it different callback functions to execute:

// some sample async functions
var resolveAfter2Seconds = function() {
  console.log("starting slow promise -> ");
  return new Promise(resolve => {
    setTimeout(function() {
      resolve("slow");
      console.log("<- slow promise is done");
    }, 2000);
  });
};

var resolveAfter1Second = function() {
  console.log("starting fast promise ->");
  return new Promise(resolve => {
    setTimeout(function() {
      resolve("fast");
      console.log("<- fast promise is done");
    }, 1000);
  });
};

//a function that accepts a callback and would await its execution
async function foo(callback) {
  console.log("-- some code --");
  await callback();
  console.log("-- some more code --");
}

//calling with an async function that combines any code you want to execute
foo(async () => { 
  await resolveAfter2Seconds();
  await resolveAfter1Second();
})

Here is another way without having to sleep or do anything complex.

In the code you pass to eval(), wrap your entire code in another async function and set it to some variable, for example, EVAL_ASYNC. Then after running eval(ctxScript), run that async function await EVAL_ASYNC.

let ctxScript = 'var EVAL_ASYNC = async function() {await foo1(); await foo2();}';
async function foo()
{
  eval( ctxScript );
  await EVAL_ASYNC();
}