numenor/lib/Compiler/Evaluator/Identifier.js

Customizable, safe evaluator of JavaScript-like expressions.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Identifier = void 0;

var _ = require("./");

var _Parser = require("../../Parser");

var _Error = require("../Error");

var _util = require("./util");

var Identifier = function Identifier(expr, options, compile) {
  if (expr.type !== _Parser.ExpressionType.Identifier) {
    throw new TypeError((0, _Error.UnknownExpression)(expr));
  }

  var name = expr.name;

  if (name === '__proto__') {
    return (0, _.mark)({
      isConst: true
    }, function () {
      throw new TypeError(_Error.CannotAccessProto);
    });
  }

  var contains = options.NoProtoAccess ? _util.hasOwnProp : (0, _util.makeProtoPropQuery)(options);

  if (options.Constants) {
    var constValue = undefined;

    if (contains(options.Constants, name)) {
      constValue = options.Constants[name];
    } else if (contains(options.Constants, _.ValueLookup)) {
      constValue = options.Constants[_.ValueLookup](name);
    }

    if (constValue !== undefined) {
      if (typeof constValue === 'function') {
        return (0, _.makeConstEval)((0, _util.bindFunction)(constValue, options.Constants));
      }

      return (0, _.makeConstEval)(constValue);
    }
  }

  var get = options.NoProtoAccess ? _util.ownPropGetter : (0, _util.makeProtoPropGetter)(options);
  return function (context) {
    var value = get(context, name);

    if (value === undefined && contains(context, _.ValueLookup)) {
      value = context[_.ValueLookup](name);
    }

    if (options.NoUndefinedVars && value === undefined) {
      throw new ReferenceError((0, _Error.UndefinedIdentifier)(name));
    }

    if (typeof value === 'function') {
      return (0, _util.bindFunction)(value, context);
    }

    return value;
  };
};

exports.Identifier = Identifier;