numenor/lib/Compiler/Evaluator/MemberAccess.js

Customizable, safe evaluator of JavaScript-like expressions.

"use strict";

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

var _ = require("./");

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

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

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

function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }

function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }

function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }

function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }

var MemberAccess = function MemberAccess(expr, options, compile) {
  if (expr.type !== _Parser.ExpressionType.MemberAccess) {
    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 lhs = compile(expr.lhs, options, compile);
  var isAsync = (0, _.hasAsyncValue)(lhs);
  var isConst = (0, _.hasConstValue)(lhs);
  var get = options.NoProtoAccess ? _util.ownPropGetter : (0, _util.makeProtoPropGetter)(options);
  return (0, _.mark)({
    isAsync: isAsync,
    isConst: isConst
  }, function (context, stack) {
    return (0, _util.evalMaybeAsyncSteps)(context, stack, [lhs]).then(function (_ref) {
      var _ref2 = _slicedToArray(_ref, 1),
          object = _ref2[0];

      if (object == null) {
        throw new TypeError((0, _Error.CannotAccessProperty)(object, name));
      }

      var value = get(object, name);

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

      return value;
    });
  });
};

exports.MemberAccess = MemberAccess;

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

  var lhs = compile(expr.lhs, options, compile);
  var rhs = compile(expr.rhs, options, compile);
  var isAsync = (0, _.hasAsyncValue)(lhs) || (0, _.hasAsyncValue)(rhs);
  var isConst = (0, _.hasConstValue)(lhs) && (0, _.hasConstValue)(rhs);
  var get = options.NoProtoAccess ? _util.ownPropGetter : (0, _util.makeProtoPropGetter)(options);
  return (0, _.mark)({
    isConst: isConst,
    isAsync: isAsync
  }, function (context, stack) {
    return (0, _util.evalMaybeAsyncSteps)(context, stack, [[lhs, function (object) {
      if (object == null) {
        throw new TypeError((0, _Error.CannotAccessProperty)(object));
      }

      return object;
    }], [rhs, function (name) {
      if (name === '__proto__') {
        throw new TypeError(_Error.CannotAccessProto);
      }

      return name;
    }]]).then(function (_ref3) {
      var _ref4 = _slicedToArray(_ref3, 2),
          object = _ref4[0],
          name = _ref4[1];

      var value = get(object, name);

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

      return value;
    });
  });
};

exports.ComputedMemberAccess = ComputedMemberAccess;