"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _slicedToArray = function () { function sliceIterator(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"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _errors = require("../errors.js");

var _index = require("./index.js");

var _index2 = require("../domains/index.js");

var _index3 = require("../methods/index.js");

var _singletons = require("../singletons.js");

var _invariant = require("../invariant.js");

var _invariant2 = _interopRequireDefault(_invariant);

var _NumberValue = require("./NumberValue");

var _NumberValue2 = _interopRequireDefault(_NumberValue);

var _babelTypes = require("babel-types");

var t = _interopRequireWildcard(_babelTypes);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /**
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Copyright (c) 2017-present, Facebook, Inc.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * All rights reserved.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * This source code is licensed under the BSD-style license found in the
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * LICENSE file in the root directory of this source tree. An additional grant
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * of patent rights can be found in the PATENTS file in the same directory.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */

var AbstractObjectValue = function (_AbstractValue) {
  _inherits(AbstractObjectValue, _AbstractValue);

  function AbstractObjectValue(realm, types, values, hashValue, args, buildNode, optionalArgs) {
    _classCallCheck(this, AbstractObjectValue);

    var _this = _possibleConstructorReturn(this, (AbstractObjectValue.__proto__ || Object.getPrototypeOf(AbstractObjectValue)).call(this, realm, types, values, hashValue, args, buildNode, optionalArgs));

    if (!values.isTop()) {
      var _iteratorNormalCompletion = true;
      var _didIteratorError = false;
      var _iteratorError = undefined;

      try {
        for (var _iterator = _this.values.getElements()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var element = _step.value;
          (0, _invariant2.default)(element instanceof _index.ObjectValue);
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    }
    return _this;
  }

  _createClass(AbstractObjectValue, [{
    key: "getTemplate",
    value: function getTemplate() {
      var _iteratorNormalCompletion2 = true;
      var _didIteratorError2 = false;
      var _iteratorError2 = undefined;

      try {
        for (var _iterator2 = this.values.getElements()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
          var element = _step2.value;

          (0, _invariant2.default)(element instanceof _index.ObjectValue);
          if (element.isPartialObject()) {
            return element;
          } else {
            break;
          }
        }
      } catch (err) {
        _didIteratorError2 = true;
        _iteratorError2 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion2 && _iterator2.return) {
            _iterator2.return();
          }
        } finally {
          if (_didIteratorError2) {
            throw _iteratorError2;
          }
        }
      }

      _index.AbstractValue.reportIntrospectionError(this);
      throw new _errors.FatalError();
    }
  }, {
    key: "isPartialObject",
    value: function isPartialObject() {
      // At the very least, the identity of the object is unknown
      return true;
    }
  }, {
    key: "isSimpleObject",
    value: function isSimpleObject() {
      if (this.cachedIsSimpleObject === undefined) this.cachedIsSimpleObject = this._elementsAreSimpleObjects();
      return this.cachedIsSimpleObject;
    }
  }, {
    key: "_elementsAreSimpleObjects",
    value: function _elementsAreSimpleObjects() {
      if (this.values.isTop()) return false;
      var result = void 0;
      var _iteratorNormalCompletion3 = true;
      var _didIteratorError3 = false;
      var _iteratorError3 = undefined;

      try {
        for (var _iterator3 = this.values.getElements()[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
          var element = _step3.value;

          (0, _invariant2.default)(element instanceof _index.ObjectValue);
          if (result === undefined) {
            result = element.isSimpleObject();
          } else if (result !== element.isSimpleObject()) {
            _index.AbstractValue.reportIntrospectionError(this);
            throw new _errors.FatalError();
          }
        }
      } catch (err) {
        _didIteratorError3 = true;
        _iteratorError3 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion3 && _iterator3.return) {
            _iterator3.return();
          }
        } finally {
          if (_didIteratorError3) {
            throw _iteratorError3;
          }
        }
      }

      if (result === undefined) {
        _index.AbstractValue.reportIntrospectionError(this);
        throw new _errors.FatalError();
      }
      return result;
    }
  }, {
    key: "mightBeFalse",
    value: function mightBeFalse() {
      return false;
    }
  }, {
    key: "mightNotBeFalse",
    value: function mightNotBeFalse() {
      return true;
    }
  }, {
    key: "makeNotPartial",
    value: function makeNotPartial() {
      if (this.values.isTop()) {
        _index.AbstractValue.reportIntrospectionError(this);
        throw new _errors.FatalError();
      }
      var _iteratorNormalCompletion4 = true;
      var _didIteratorError4 = false;
      var _iteratorError4 = undefined;

      try {
        for (var _iterator4 = this.values.getElements()[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
          var element = _step4.value;

          (0, _invariant2.default)(element instanceof _index.ObjectValue);
          element.makeNotPartial();
        }
      } catch (err) {
        _didIteratorError4 = true;
        _iteratorError4 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion4 && _iterator4.return) {
            _iterator4.return();
          }
        } finally {
          if (_didIteratorError4) {
            throw _iteratorError4;
          }
        }
      }
    }
  }, {
    key: "makePartial",
    value: function makePartial() {
      if (this.values.isTop()) {
        _index.AbstractValue.reportIntrospectionError(this);
        throw new _errors.FatalError();
      }
      var _iteratorNormalCompletion5 = true;
      var _didIteratorError5 = false;
      var _iteratorError5 = undefined;

      try {
        for (var _iterator5 = this.values.getElements()[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
          var element = _step5.value;

          (0, _invariant2.default)(element instanceof _index.ObjectValue);
          element.makePartial();
        }
      } catch (err) {
        _didIteratorError5 = true;
        _iteratorError5 = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion5 && _iterator5.return) {
            _iterator5.return();
          }
        } finally {
          if (_didIteratorError5) {
            throw _iteratorError5;
          }
        }
      }
    }
  }, {
    key: "makeSimple",
    value: function makeSimple() {
      if (!this.values.isTop()) {
        var _iteratorNormalCompletion6 = true;
        var _didIteratorError6 = false;
        var _iteratorError6 = undefined;

        try {
          for (var _iterator6 = this.values.getElements()[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
            var element = _step6.value;

            (0, _invariant2.default)(element instanceof _index.ObjectValue);
            element.makeSimple();
          }
        } catch (err) {
          _didIteratorError6 = true;
          _iteratorError6 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion6 && _iterator6.return) {
              _iterator6.return();
            }
          } finally {
            if (_didIteratorError6) {
              throw _iteratorError6;
            }
          }
        }
      }
      this.cachedIsSimpleObject = true;
    }
  }, {
    key: "throwIfNotObject",
    value: function throwIfNotObject() {
      return this;
    }

    // ECMA262 9.1.3

  }, {
    key: "$IsExtensible",
    value: function $IsExtensible() {
      return false;
    }

    // ECMA262 9.1.5

  }, {
    key: "$GetOwnProperty",
    value: function $GetOwnProperty(P) {
      if (P instanceof _index.StringValue) P = P.value;

      var elements = this.values.getElements();
      if (elements.size === 1) {
        var _iteratorNormalCompletion7 = true;
        var _didIteratorError7 = false;
        var _iteratorError7 = undefined;

        try {
          for (var _iterator7 = elements[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
            var cv = _step7.value;

            (0, _invariant2.default)(cv instanceof _index.ObjectValue);
            return cv.$GetOwnProperty(P, cv);
          }
        } catch (err) {
          _didIteratorError7 = true;
          _iteratorError7 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion7 && _iterator7.return) {
              _iterator7.return();
            }
          } finally {
            if (_didIteratorError7) {
              throw _iteratorError7;
            }
          }
        }

        (0, _invariant2.default)(false);
      } else if (this.kind === "conditional") {
        // this is the join of two concrete objects
        var _args = _slicedToArray(this.args, 3),
            cond = _args[0],
            ob1 = _args[1],
            ob2 = _args[2];

        (0, _invariant2.default)(cond instanceof _index.AbstractValue);
        (0, _invariant2.default)(ob1 instanceof _index.ObjectValue);
        (0, _invariant2.default)(ob2 instanceof _index.ObjectValue);
        var d1 = ob1.$GetOwnProperty(P);
        var d2 = ob2.$GetOwnProperty(P);
        if (d1 === undefined || d2 === undefined || !(0, _index3.equalDescriptors)(d1, d2)) {
          _index.AbstractValue.reportIntrospectionError(this, P);
          throw new _errors.FatalError();
        }
        var desc = (0, _index3.cloneDescriptor)(d1);
        (0, _invariant2.default)(desc !== undefined);
        if ((0, _index3.IsDataDescriptor)(this.$Realm, desc)) {
          var d1Value = d1.value;
          (0, _invariant2.default)(d1Value === undefined || d1Value instanceof _index.Value);
          var d2Value = d2.value;
          (0, _invariant2.default)(d2Value === undefined || d2Value instanceof _index.Value);
          desc.value = _singletons.Join.joinValuesAsConditional(this.$Realm, cond, d1Value, d2Value);
        }
        return desc;
      } else if (this.kind === "widened") {
        // This abstract object was created by repeated assignments of freshly allocated objects to the same binding inside a loop
        var _args2 = _slicedToArray(this.args, 2),
            _ob = _args2[0],
            _ob2 = _args2[1]; // ob1: summary of iterations 1...n, ob2: summary of iteration n+1


        (0, _invariant2.default)(_ob instanceof _index.ObjectValue);
        (0, _invariant2.default)(_ob2 instanceof _index.ObjectValue);
        var _d = _ob.$GetOwnProperty(P);
        var _d2 = _ob2.$GetOwnProperty(P);
        if (_d === undefined || _d2 === undefined || !(0, _index3.equalDescriptors)(_d, _d2)) {
          // We do not handle the case where different loop iterations result in different kinds of propperties
          _index.AbstractValue.reportIntrospectionError(this, P);
          throw new _errors.FatalError();
        }
        var _desc = (0, _index3.cloneDescriptor)(_d);
        (0, _invariant2.default)(_desc !== undefined);
        if ((0, _index3.IsDataDescriptor)(this.$Realm, _desc)) {
          // Values may be different, i.e. values may be loop variant, so the widened value summarizes the entire loop
          var _d1Value = _d.value;
          (0, _invariant2.default)(_d1Value === undefined || _d1Value instanceof _index.Value);
          var _d2Value = _d2.value;
          (0, _invariant2.default)(_d2Value === undefined || _d2Value instanceof _index.Value);
          _desc.value = _singletons.Widen.widenValues(this.$Realm, _d1Value, _d2Value);
        } else {
          // In this case equalDescriptors guarantees exact equality betwee d1 and d2.
          // Inlining the accessors will eventually bring in data properties if the accessors have loop variant behavior
        }
        return _desc;
      } else {
        var hasProp = false;
        var doesNotHaveProp = false;
        var _desc2 = void 0;
        var _iteratorNormalCompletion8 = true;
        var _didIteratorError8 = false;
        var _iteratorError8 = undefined;

        try {
          for (var _iterator8 = elements[Symbol.iterator](), _step8; !(_iteratorNormalCompletion8 = (_step8 = _iterator8.next()).done); _iteratorNormalCompletion8 = true) {
            var _cv = _step8.value;

            (0, _invariant2.default)(_cv instanceof _index.ObjectValue);
            var d = _cv.$GetOwnProperty(P);
            if (d === undefined) doesNotHaveProp = true;else {
              hasProp = true;
              if (_desc2 === undefined) {
                _desc2 = (0, _index3.cloneDescriptor)(d);
                (0, _invariant2.default)(_desc2 !== undefined);
                if (!(0, _index3.IsDataDescriptor)(this.$Realm, d)) continue;
              } else {
                if (!(0, _index3.equalDescriptors)(d, _desc2)) {
                  _index.AbstractValue.reportIntrospectionError(this, P);
                  throw new _errors.FatalError();
                }
                if (!(0, _index3.IsDataDescriptor)(this.$Realm, _desc2)) continue;
                // values may be different
                var _cond = _index.AbstractValue.createFromBinaryOp(this.$Realm, "===", this, _cv, this.expressionLocation);
                _desc2.value = _singletons.Join.joinValuesAsConditional(this.$Realm, _cond, d.value, _desc2.value);
              }
            }
          }
        } catch (err) {
          _didIteratorError8 = true;
          _iteratorError8 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion8 && _iterator8.return) {
              _iterator8.return();
            }
          } finally {
            if (_didIteratorError8) {
              throw _iteratorError8;
            }
          }
        }

        if (hasProp && doesNotHaveProp) {
          _index.AbstractValue.reportIntrospectionError(this, P);
          throw new _errors.FatalError();
        }
        return _desc2;
      }
    }

    // ECMA262 9.1.6

  }, {
    key: "$DefineOwnProperty",
    value: function $DefineOwnProperty(P, Desc) {
      if (P instanceof _index.StringValue) P = P.value;
      if (this.values.isTop()) {
        _index.AbstractValue.reportIntrospectionError(this, P);
        throw new _errors.FatalError();
      }

      var elements = this.values.getElements();
      if (elements.size === 1) {
        var _iteratorNormalCompletion9 = true;
        var _didIteratorError9 = false;
        var _iteratorError9 = undefined;

        try {
          for (var _iterator9 = elements[Symbol.iterator](), _step9; !(_iteratorNormalCompletion9 = (_step9 = _iterator9.next()).done); _iteratorNormalCompletion9 = true) {
            var cv = _step9.value;

            (0, _invariant2.default)(cv instanceof _index.ObjectValue);
            return cv.$DefineOwnProperty(P, Desc);
          }
        } catch (err) {
          _didIteratorError9 = true;
          _iteratorError9 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion9 && _iterator9.return) {
              _iterator9.return();
            }
          } finally {
            if (_didIteratorError9) {
              throw _iteratorError9;
            }
          }
        }

        (0, _invariant2.default)(false);
      } else {
        if (!(0, _index3.IsDataDescriptor)(this.$Realm, Desc)) {
          _index.AbstractValue.reportIntrospectionError(this, P);
          throw new _errors.FatalError();
        }
        var desc = {
          value: "value" in Desc ? Desc.value : this.$Realm.intrinsics.undefined,
          writable: "writable" in Desc ? Desc.writable : false,
          enumerable: "enumerable" in Desc ? Desc.enumerable : false,
          configurable: "configurable" in Desc ? Desc.configurable : false
        };
        var new_val = desc.value;
        (0, _invariant2.default)(new_val instanceof _index.Value);
        var sawTrue = false;
        var sawFalse = false;
        var _iteratorNormalCompletion10 = true;
        var _didIteratorError10 = false;
        var _iteratorError10 = undefined;

        try {
          for (var _iterator10 = elements[Symbol.iterator](), _step10; !(_iteratorNormalCompletion10 = (_step10 = _iterator10.next()).done); _iteratorNormalCompletion10 = true) {
            var _cv2 = _step10.value;

            (0, _invariant2.default)(_cv2 instanceof _index.ObjectValue);
            var d = _cv2.$GetOwnProperty(P);
            if (d !== undefined && !(0, _index3.equalDescriptors)(d, desc)) {
              _index.AbstractValue.reportIntrospectionError(this, P);
              throw new _errors.FatalError();
            }
            var dval = d === undefined || d.vale === undefined ? this.$Realm.intrinsics.empty : d.value;
            (0, _invariant2.default)(dval instanceof _index.Value);
            var cond = _index.AbstractValue.createFromBinaryOp(this.$Realm, "===", this, _cv2, this.expressionLocation);
            desc.value = _singletons.Join.joinValuesAsConditional(this.$Realm, cond, new_val, dval);
            if (_cv2.$DefineOwnProperty(P, desc)) {
              sawTrue = true;
            } else sawFalse = true;
          }
        } catch (err) {
          _didIteratorError10 = true;
          _iteratorError10 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion10 && _iterator10.return) {
              _iterator10.return();
            }
          } finally {
            if (_didIteratorError10) {
              throw _iteratorError10;
            }
          }
        }

        if (sawTrue && sawFalse) {
          _index.AbstractValue.reportIntrospectionError(this, P);
          throw new _errors.FatalError();
        }
        return sawTrue;
      }
    }

    // ECMA262 9.1.7

  }, {
    key: "$HasProperty",
    value: function $HasProperty(P) {
      if (P instanceof _index.StringValue) P = P.value;
      if (this.values.isTop()) {
        _index.AbstractValue.reportIntrospectionError(this, P);
        throw new _errors.FatalError();
      }

      var elements = this.values.getElements();
      if (elements.size === 1) {
        var _iteratorNormalCompletion11 = true;
        var _didIteratorError11 = false;
        var _iteratorError11 = undefined;

        try {
          for (var _iterator11 = elements[Symbol.iterator](), _step11; !(_iteratorNormalCompletion11 = (_step11 = _iterator11.next()).done); _iteratorNormalCompletion11 = true) {
            var cv = _step11.value;

            (0, _invariant2.default)(cv instanceof _index.ObjectValue);
            return cv.$HasProperty(P, cv);
          }
        } catch (err) {
          _didIteratorError11 = true;
          _iteratorError11 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion11 && _iterator11.return) {
              _iterator11.return();
            }
          } finally {
            if (_didIteratorError11) {
              throw _iteratorError11;
            }
          }
        }

        (0, _invariant2.default)(false);
      } else {
        var hasProp = false;
        var doesNotHaveProp = false;
        var _iteratorNormalCompletion12 = true;
        var _didIteratorError12 = false;
        var _iteratorError12 = undefined;

        try {
          for (var _iterator12 = elements[Symbol.iterator](), _step12; !(_iteratorNormalCompletion12 = (_step12 = _iterator12.next()).done); _iteratorNormalCompletion12 = true) {
            var _cv3 = _step12.value;

            (0, _invariant2.default)(_cv3 instanceof _index.ObjectValue);
            if (_cv3.$HasProperty(P)) hasProp = true;else doesNotHaveProp = true;
          }
        } catch (err) {
          _didIteratorError12 = true;
          _iteratorError12 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion12 && _iterator12.return) {
              _iterator12.return();
            }
          } finally {
            if (_didIteratorError12) {
              throw _iteratorError12;
            }
          }
        }

        if (hasProp && doesNotHaveProp) {
          _index.AbstractValue.reportIntrospectionError(this, P);
          throw new _errors.FatalError();
        }
        return hasProp;
      }
    }

    // ECMA262 9.1.8

  }, {
    key: "$Get",
    value: function $Get(P, Receiver) {
      if (P instanceof _index.StringValue) P = P.value;
      if (this.values.isTop()) {
        if (this.isSimpleObject() && this.isIntrinsic()) {
          var type = _index.Value;
          if (P === "length" && _index.Value.isTypeCompatibleWith(this.getType(), _index.ArrayValue)) type = _NumberValue2.default;
          return _index.AbstractValue.createTemporalFromBuildFunction(this.$Realm, type, [this], function (_ref) {
            var _ref2 = _slicedToArray(_ref, 1),
                o = _ref2[0];

            (0, _invariant2.default)(typeof P === "string");
            return t.memberExpression(o, t.identifier(P));
          }, {
            skipInvariant: true
          });
        }
        _index.AbstractValue.reportIntrospectionError(this, P);
        throw new _errors.FatalError();
      }

      var elements = this.values.getElements();
      if (elements.size === 1) {
        var _iteratorNormalCompletion13 = true;
        var _didIteratorError13 = false;
        var _iteratorError13 = undefined;

        try {
          for (var _iterator13 = elements[Symbol.iterator](), _step13; !(_iteratorNormalCompletion13 = (_step13 = _iterator13.next()).done); _iteratorNormalCompletion13 = true) {
            var cv = _step13.value;

            (0, _invariant2.default)(cv instanceof _index.ObjectValue);
            return cv.$Get(P, Receiver);
          }
        } catch (err) {
          _didIteratorError13 = true;
          _iteratorError13 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion13 && _iterator13.return) {
              _iterator13.return();
            }
          } finally {
            if (_didIteratorError13) {
              throw _iteratorError13;
            }
          }
        }

        (0, _invariant2.default)(false);
      } else if (this.kind === "conditional") {
        // this is the join of two concrete objects
        var _args3 = _slicedToArray(this.args, 3),
            cond = _args3[0],
            ob1 = _args3[1],
            ob2 = _args3[2];

        (0, _invariant2.default)(cond instanceof _index.AbstractValue);
        (0, _invariant2.default)(ob1 instanceof _index.ObjectValue);
        (0, _invariant2.default)(ob2 instanceof _index.ObjectValue);
        var d1 = ob1.$GetOwnProperty(P);
        var d1val = d1 === undefined ? this.$Realm.intrinsics.undefined : (0, _index3.IsDataDescriptor)(this.$Realm, d1) ? d1.value : undefined;
        var d2 = ob2.$GetOwnProperty(P);
        var d2val = d2 === undefined ? this.$Realm.intrinsics.undefined : (0, _index3.IsDataDescriptor)(this.$Realm, d2) ? d2.value : undefined;
        if (d1val === undefined || d2val === undefined) {
          _index.AbstractValue.reportIntrospectionError(this, P);
          throw new _errors.FatalError();
        }
        (0, _invariant2.default)(d1val instanceof _index.Value);
        (0, _invariant2.default)(d2val instanceof _index.Value);
        return _singletons.Join.joinValuesAsConditional(this.$Realm, cond, d1val, d2val);
      } else {
        var result = void 0;
        var _iteratorNormalCompletion14 = true;
        var _didIteratorError14 = false;
        var _iteratorError14 = undefined;

        try {
          for (var _iterator14 = elements[Symbol.iterator](), _step14; !(_iteratorNormalCompletion14 = (_step14 = _iterator14.next()).done); _iteratorNormalCompletion14 = true) {
            var _cv4 = _step14.value;

            (0, _invariant2.default)(_cv4 instanceof _index.ObjectValue);
            var d = _cv4.$GetOwnProperty(P);
            // We do not currently join property getters
            if (d !== undefined && !(0, _index3.IsDataDescriptor)(this.$Realm, d)) {
              _index.AbstractValue.reportIntrospectionError(this, P);
              throw new _errors.FatalError();
            }
            var cvVal = d === undefined ? this.$Realm.intrinsics.undefined : d.value;
            if (result === undefined) result = cvVal;else {
              var _cond2 = _index.AbstractValue.createFromBinaryOp(this.$Realm, "===", this, _cv4, this.expressionLocation);
              result = _singletons.Join.joinValuesAsConditional(this.$Realm, _cond2, cvVal, result);
            }
          }
        } catch (err) {
          _didIteratorError14 = true;
          _iteratorError14 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion14 && _iterator14.return) {
              _iterator14.return();
            }
          } finally {
            if (_didIteratorError14) {
              throw _iteratorError14;
            }
          }
        }

        (0, _invariant2.default)(result !== undefined);
        return result;
      }
    }
  }, {
    key: "$GetPartial",
    value: function $GetPartial(P, Receiver) {
      if (!(P instanceof _index.AbstractValue)) return this.$Get(P, Receiver);
      (0, _invariant2.default)(this === Receiver, "TODO #1021");
      if (this.values.isTop()) {
        if (this.isSimpleObject() && this.isIntrinsic()) {
          return _index.AbstractValue.createTemporalFromBuildFunction(this.$Realm, _index.Value, [this, P], function (_ref3) {
            var _ref4 = _slicedToArray(_ref3, 2),
                o = _ref4[0],
                p = _ref4[1];

            return t.memberExpression(o, p, true);
          });
        }
        _index.AbstractValue.reportIntrospectionError(this);
        throw new _errors.FatalError();
      }

      var elements = this.values.getElements();
      if (elements.size === 1) {
        var _iteratorNormalCompletion15 = true;
        var _didIteratorError15 = false;
        var _iteratorError15 = undefined;

        try {
          for (var _iterator15 = elements[Symbol.iterator](), _step15; !(_iteratorNormalCompletion15 = (_step15 = _iterator15.next()).done); _iteratorNormalCompletion15 = true) {
            var cv = _step15.value;

            return cv.$GetPartial(P, cv);
          }
        } catch (err) {
          _didIteratorError15 = true;
          _iteratorError15 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion15 && _iterator15.return) {
              _iterator15.return();
            }
          } finally {
            if (_didIteratorError15) {
              throw _iteratorError15;
            }
          }
        }

        (0, _invariant2.default)(false);
      } else {
        var result = void 0;
        var _iteratorNormalCompletion16 = true;
        var _didIteratorError16 = false;
        var _iteratorError16 = undefined;

        try {
          for (var _iterator16 = elements[Symbol.iterator](), _step16; !(_iteratorNormalCompletion16 = (_step16 = _iterator16.next()).done); _iteratorNormalCompletion16 = true) {
            var _cv5 = _step16.value;

            var cvVal = _cv5.$GetPartial(P, _cv5);
            if (result === undefined) result = cvVal;else {
              var cond = _index.AbstractValue.createFromBinaryOp(this.$Realm, "===", this, _cv5, this.expressionLocation);
              result = _singletons.Join.joinValuesAsConditional(this.$Realm, cond, cvVal, result);
            }
          }
        } catch (err) {
          _didIteratorError16 = true;
          _iteratorError16 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion16 && _iterator16.return) {
              _iterator16.return();
            }
          } finally {
            if (_didIteratorError16) {
              throw _iteratorError16;
            }
          }
        }

        (0, _invariant2.default)(result !== undefined);
        return result;
      }
    }

    // ECMA262 9.1.9

  }, {
    key: "$Set",
    value: function $Set(P, V, Receiver) {
      if (P instanceof _index.StringValue) P = P.value;
      (0, _invariant2.default)(this === Receiver, "TODO #1021");
      if (this.values.isTop()) {
        _index.AbstractValue.reportIntrospectionError(this, P);
        throw new _errors.FatalError();
      }

      var elements = this.values.getElements();
      if (elements.size === 1) {
        var _iteratorNormalCompletion17 = true;
        var _didIteratorError17 = false;
        var _iteratorError17 = undefined;

        try {
          for (var _iterator17 = elements[Symbol.iterator](), _step17; !(_iteratorNormalCompletion17 = (_step17 = _iterator17.next()).done); _iteratorNormalCompletion17 = true) {
            var cv = _step17.value;

            (0, _invariant2.default)(cv instanceof _index.ObjectValue);
            return cv.$Set(P, V, cv);
          }
        } catch (err) {
          _didIteratorError17 = true;
          _iteratorError17 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion17 && _iterator17.return) {
              _iterator17.return();
            }
          } finally {
            if (_didIteratorError17) {
              throw _iteratorError17;
            }
          }
        }

        (0, _invariant2.default)(false);
      } else {
        var sawTrue = false;
        var sawFalse = false;
        var _iteratorNormalCompletion18 = true;
        var _didIteratorError18 = false;
        var _iteratorError18 = undefined;

        try {
          for (var _iterator18 = elements[Symbol.iterator](), _step18; !(_iteratorNormalCompletion18 = (_step18 = _iterator18.next()).done); _iteratorNormalCompletion18 = true) {
            var _cv6 = _step18.value;

            (0, _invariant2.default)(_cv6 instanceof _index.ObjectValue);
            var d = _cv6.$GetOwnProperty(P);
            if (d !== undefined && !(0, _index3.IsDataDescriptor)(this.$Realm, d)) {
              _index.AbstractValue.reportIntrospectionError(this, P);
              throw new _errors.FatalError();
            }
            var oldVal = d === undefined ? this.$Realm.intrinsics.empty : d.value;
            var cond = _index.AbstractValue.createFromBinaryOp(this.$Realm, "===", this, _cv6, this.expressionLocation);
            var v = _singletons.Join.joinValuesAsConditional(this.$Realm, cond, V, oldVal);
            if (_cv6.$Set(P, v, _cv6)) sawTrue = true;else sawFalse = true;
          }
        } catch (err) {
          _didIteratorError18 = true;
          _iteratorError18 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion18 && _iterator18.return) {
              _iterator18.return();
            }
          } finally {
            if (_didIteratorError18) {
              throw _iteratorError18;
            }
          }
        }

        if (sawTrue && sawFalse) {
          _index.AbstractValue.reportIntrospectionError(this, P);
          throw new _errors.FatalError();
        }
        return sawTrue;
      }
    }
  }, {
    key: "$SetPartial",
    value: function $SetPartial(P, V, Receiver) {
      if (!(P instanceof _index.AbstractValue)) return this.$Set(P, V, Receiver);
      (0, _invariant2.default)(this === Receiver, "TODO #1021");
      if (this.values.isTop()) {
        _index.AbstractValue.reportIntrospectionError(this);
        throw new _errors.FatalError();
      }

      var elements = this.values.getElements();
      if (elements.size === 1) {
        var _iteratorNormalCompletion19 = true;
        var _didIteratorError19 = false;
        var _iteratorError19 = undefined;

        try {
          for (var _iterator19 = elements[Symbol.iterator](), _step19; !(_iteratorNormalCompletion19 = (_step19 = _iterator19.next()).done); _iteratorNormalCompletion19 = true) {
            var cv = _step19.value;

            (0, _invariant2.default)(cv instanceof _index.ObjectValue);
            return cv.$SetPartial(P, V, cv);
          }
        } catch (err) {
          _didIteratorError19 = true;
          _iteratorError19 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion19 && _iterator19.return) {
              _iterator19.return();
            }
          } finally {
            if (_didIteratorError19) {
              throw _iteratorError19;
            }
          }
        }

        (0, _invariant2.default)(false);
      } else {
        var _iteratorNormalCompletion20 = true;
        var _didIteratorError20 = false;
        var _iteratorError20 = undefined;

        try {
          for (var _iterator20 = elements[Symbol.iterator](), _step20; !(_iteratorNormalCompletion20 = (_step20 = _iterator20.next()).done); _iteratorNormalCompletion20 = true) {
            var _cv7 = _step20.value;

            (0, _invariant2.default)(_cv7 instanceof _index.ObjectValue);
            var oldVal = this.$GetPartial(P, Receiver);
            var cond = _index.AbstractValue.createFromBinaryOp(this.$Realm, "===", this, _cv7, this.expressionLocation);
            var v = _singletons.Join.joinValuesAsConditional(this.$Realm, cond, V, oldVal);
            _cv7.$SetPartial(P, v, _cv7);
          }
        } catch (err) {
          _didIteratorError20 = true;
          _iteratorError20 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion20 && _iterator20.return) {
              _iterator20.return();
            }
          } finally {
            if (_didIteratorError20) {
              throw _iteratorError20;
            }
          }
        }

        return true;
      }
    }

    // ECMA262 9.1.10

  }, {
    key: "$Delete",
    value: function $Delete(P) {
      if (P instanceof _index.StringValue) P = P.value;
      if (this.values.isTop()) {
        _index.AbstractValue.reportIntrospectionError(this, P);
        throw new _errors.FatalError();
      }

      var elements = this.values.getElements();
      if (elements.size === 1) {
        var _iteratorNormalCompletion21 = true;
        var _didIteratorError21 = false;
        var _iteratorError21 = undefined;

        try {
          for (var _iterator21 = elements[Symbol.iterator](), _step21; !(_iteratorNormalCompletion21 = (_step21 = _iterator21.next()).done); _iteratorNormalCompletion21 = true) {
            var cv = _step21.value;

            (0, _invariant2.default)(cv instanceof _index.ObjectValue);
            return cv.$Delete(P);
          }
        } catch (err) {
          _didIteratorError21 = true;
          _iteratorError21 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion21 && _iterator21.return) {
              _iterator21.return();
            }
          } finally {
            if (_didIteratorError21) {
              throw _iteratorError21;
            }
          }
        }

        (0, _invariant2.default)(false);
      } else {
        var sawTrue = false;
        var sawFalse = false;
        var _iteratorNormalCompletion22 = true;
        var _didIteratorError22 = false;
        var _iteratorError22 = undefined;

        try {
          for (var _iterator22 = elements[Symbol.iterator](), _step22; !(_iteratorNormalCompletion22 = (_step22 = _iterator22.next()).done); _iteratorNormalCompletion22 = true) {
            var _cv8 = _step22.value;

            (0, _invariant2.default)(_cv8 instanceof _index.ObjectValue);
            var d = _cv8.$GetOwnProperty(P);
            if (d === undefined) continue;
            if (!(0, _index3.IsDataDescriptor)(this.$Realm, d)) {
              _index.AbstractValue.reportIntrospectionError(this, P);
              throw new _errors.FatalError();
            }
            var cond = _index.AbstractValue.createFromBinaryOp(this.$Realm, "===", this, _cv8, this.expressionLocation);
            var v = _singletons.Join.joinValuesAsConditional(this.$Realm, cond, this.$Realm.intrinsics.empty, d.value);
            if (_cv8.$Set(P, v, _cv8)) sawTrue = true;else sawFalse = true;
          }
        } catch (err) {
          _didIteratorError22 = true;
          _iteratorError22 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion22 && _iterator22.return) {
              _iterator22.return();
            }
          } finally {
            if (_didIteratorError22) {
              throw _iteratorError22;
            }
          }
        }

        if (sawTrue && sawFalse) {
          _index.AbstractValue.reportIntrospectionError(this, P);
          throw new _errors.FatalError();
        }
        return sawTrue;
      }
    }
  }, {
    key: "$OwnPropertyKeys",
    value: function $OwnPropertyKeys() {
      if (this.values.isTop()) {
        _index.AbstractValue.reportIntrospectionError(this);
        throw new _errors.FatalError();
      }
      var elements = this.values.getElements();
      if (elements.size === 1) {
        var _iteratorNormalCompletion23 = true;
        var _didIteratorError23 = false;
        var _iteratorError23 = undefined;

        try {
          for (var _iterator23 = elements[Symbol.iterator](), _step23; !(_iteratorNormalCompletion23 = (_step23 = _iterator23.next()).done); _iteratorNormalCompletion23 = true) {
            var cv = _step23.value;

            (0, _invariant2.default)(cv instanceof _index.ObjectValue);
            return cv.$OwnPropertyKeys();
          }
        } catch (err) {
          _didIteratorError23 = true;
          _iteratorError23 = err;
        } finally {
          try {
            if (!_iteratorNormalCompletion23 && _iterator23.return) {
              _iterator23.return();
            }
          } finally {
            if (_didIteratorError23) {
              throw _iteratorError23;
            }
          }
        }

        (0, _invariant2.default)(false);
      } else {
        _index.AbstractValue.reportIntrospectionError(this);
        throw new _errors.FatalError();
      }
    }
  }]);

  return AbstractObjectValue;
}(_index.AbstractValue);

exports.default = AbstractObjectValue;
//# sourceMappingURL=AbstractObjectValue.js.map