Ensure eval is isolated.

@ignore
@api private
482205
function(functionCache, hash, functionString, object) {
  // Contains the value we are going to set
  var value = null;

  // Check for cache hit, eval if missing and return cached function
  if(functionCache[hash] == null) {
    eval("value = " + functionString);
    functionCache[hash] = value;
  }
  // Set the object
  return functionCache[hash].bind(object);
}
1115620
function (cmd,context,silent)
		{
			var ctx = (context!=undefined?context:this);
			try
			{
				return (function () {
					var result = eval(cmd);
					if (!silent)
						self.e.log&&self.e.log(util.inspect(result),'result');
					return result;
				}.bind(ctx))();
			} catch (e)
			{
				this.e.exception&&this.e.exception(e);
			}
			return;
		}
404707
def eval(self, code, mode='single'):
        """"""
        if isinstance(code, str):
            if isinstance(code, str):
                code = UTF8_COOKIE + code.encode('utf-8')
            code = compile(code, '<interactive>', mode)
        if mode != 'exec':
            return eval(code, self.globals, self.locals)
        exec(code, self.globals, self.locals)
527980
function(scope, defaultValue) {
            var val = evaluator(tree, scope);
            if( typeof defaultValue === 'undefined') {
                return val;
            } else {
                return (val === undefined || val === null || val != val) ? defaultValue : val;
            }
        }
894902
function __eval(__source, __global, load) {
    // Hijack System.register to set declare function
    System.__curRegister = System.register;
    System.register = function(name, deps, declare) {
      // store the registered declaration as load.declare
      load.declare = typeof name == 'string' ? declare : deps;
    }
    eval('var __moduleName = "' + (load.name || '').replace('"', '\"') + '"; (function() { ' + __source + ' \n }).call(__global);');

    System.register = System.__curRegister;
    delete System.__curRegister;
  }
165328
function reportAccessingEval(globalScope) {
            const variable = astUtils.getVariableByName(globalScope, "eval");

            if (!variable) {
                return;
            }

            const references = variable.references;

            for (let i = 0; i < references.length; ++i) {
                const reference = references[i];
                const id = reference.identifier;

                if (id.name === "eval" && !astUtils.isCallee(id)) {

                    // Is accessing to eval (excludes direct calls to eval)
                    report(id);
                }
            }
        }
270276
def eval data, model = nil
      instance_variable_set :"@model", model
      attributes.each do |name,block|
        instance_variable_set :"@#{name}", instance_eval(&block)
      end

      res = instance_eval &data

      remove_instance_variable :"@model"
      attributes.each do |name,block|
        remove_instance_variable :"@#{name}"
      end

      res
    end
1293439
function( code ) {
		var script,
				indirect = eval;

		code = jQuery.trim( code );

		if ( code ) {
			// If the code includes a valid, prologue position
			// strict mode pragma, execute code by injecting a
			// script tag into the document.
			if ( code.indexOf("use strict") === 1 ) {
				script = document.createElement("script");
				script.text = code;
				document.head.appendChild( script ).parentNode.removeChild( script );
			} else {
			// Otherwise, avoid the DOM node creation, insertion
			// and removal by using an indirect global eval
				indirect( code );
			}
		}
	}
152615
function clean(method) {
  for (let m of methods) {
    if (new RegExp(m, 'i').test(method)) {
      return m;
    }
  }

  throw new Error(`Invalid method name: ${method}`);
}
512725
function evalTasks (funcs, task) {
  /**
  * Evaluate a single task and inject it.
  *
  * @param {String} taskKey
  */

  function inject (taskKey) {
    var taskName = task[taskKey]

    try {
      var e = eval(taskName) // eslint-disable-line

      if (typeof e === 'function') {
        funcs[taskName] = e
      } else {
        funcs[taskName] = function () { return e }
      }
    } catch (err) {
      var msg = 'Task not compiled: ' + taskName + ' [' + taskKey + ']' + err
      throw new Error(msg)
    }
  }

  Object.keys(task)
    .filter(reserved(task))
    .filter(dflowDSL(task))
    .filter(alreadyDefined(funcs, task))
    .forEach(inject)
}
980504
function () {
      if (!this.helperContainer) {
        return;
      }

      for (var name in helpers) {
        this.helperContainer[name] = this.originalMethods[name];
        delete Test.Promise.prototype[name];
        delete this.testHelpers[name];
        delete this.originalMethods[name];
      }
    }
293488
public Object eval( CallStack callstack, Interpreter interpreter) throws EvalError {
        if ( null != types )
            return types;

        types = new Class[countTypes()];
        if ( isUntyped() )
            types[0] = UNTYPED;
        else for ( int i=0; i< countTypes(); i++ )
            types[i] = ((BSHType) jjtGetChild(i)).getType( callstack, interpreter );

        return types;
    }

    public Class<?>[] getTypes() {
        return this.types;
    }
}
413834
function evalFn(token, format_lib) {
    var splited = token.trim().split(/[\(\)]/g);

    if (splited.length < 3)
        return token;

    if (!format_lib)
        return token

    var fnstring = splited[0];
    var fnparams = splited.slice(1, splited.length - 1);
    var fn = format_lib[fnstring];

    if (typeof fn !== "function")
        return "";

    return fn.apply(null, fnparams);
}
1100067
def evaluate(context, *args, &block)
      self.result = if block
          context.define_singleton_method(:__callback__, &self)
          ret = context.send :__callback__, *args, &block
          context.class_eval { send :remove_method, :__callback__ }
          ret
        else
          context.instance_exec(*args, &self)
        end
    end
1189250
function() {

		var result = null;

		// in production - wrap evaluation into try/catch block
		if (Lava.schema.DEBUG) {

			result = this._evaluator();

		} else {

			try {

				result = this._evaluator();

			} catch (e) {

				Lava.logException(e);

			}

		}

		return result;

	}
375156
def constantize(str)
      str = str.to_s
      call_or_yield str do
        raise(NameError, "#{s.inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(str)
        Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
      end
    end
1214752
function safeEval(src, parentContext){
  var tree = prepareAst(src)
  var context = Object.create(parentContext || {})
  return finalValue(evaluateAst(tree, context))
}