text: 'use strict';
  
  var trimStart = require('string.prototype.trimleft');
  var trimEnd = require('string.prototype.trimright');
  var inspect = require('object-inspect');
  
  var ES2018 = require('./es2018');
  var assign = require('./helpers/assign');
  var MAX_SAFE_INTEGER = require('./helpers/maxSafeInteger');
  
  var GetIntrinsic = require('./GetIntrinsic');
  
  var $TypeError = GetIntrinsic('%TypeError%');
  
  var ES2019 = assign(assign({}, ES2018), {
  	// https://tc39.es/ecma262/#sec-add-entries-from-iterable
  	AddEntriesFromIterable: function AddEntriesFromIterable(target, iterable, adder) {
  		if (!this.IsCallable(adder)) {
  			throw new $TypeError('Assertion failed: `adder` is not callable');
  		}
  		if (iterable == null) {
  			throw new $TypeError('Assertion failed: `iterable` is present, and not nullish');
  		}
  		var iteratorRecord = this.GetIterator(iterable);
  		while (true) { // eslint-disable-line no-constant-condition
  			var next = this.IteratorStep(iteratorRecord);
  			if (!next) {
  				return target;
  			}
  			var nextItem = this.IteratorValue(next);
  			if (this.Type(nextItem) !== 'Object') {
  				var error = new $TypeError('iterator next must return an Object, got ' + inspect(nextItem));
  				return this.IteratorClose(
  					iteratorRecord,
  					function () { throw error; } // eslint-disable-line no-loop-func
  				);
  			}
  			try {
  				var k = this.Get(nextItem, '0');
  				var v = this.Get(nextItem, '1');
  				this.Call(adder, target, [k, v]);
  			} catch (e) {
  				return this.IteratorClose(
  					iteratorRecord,
  					function () { throw e; } // eslint-disable-line no-loop-func
  				);
  			}
  		}
  	},
  
  	// https://ecma-international.org/ecma-262/10.0/#sec-flattenintoarray
  	// eslint-disable-next-line max-params, max-statements
  	FlattenIntoArray: function FlattenIntoArray(target, source, sourceLen, start, depth) {
  		var mapperFunction;
  		if (arguments.length > 5) {
  			mapperFunction = arguments[5];
  		}
  
  		var targetIndex = start;
  		var sourceIndex = 0;
  		while (sourceIndex < sourceLen) {
  			var P = this.ToString(sourceIndex);
  			var exists = this.HasProperty(source, P);
  			if (exists === true) {
  				var element = this.Get(source, P);
  				if (typeof mapperFunction !== 'undefined') {
  					if (arguments.length <= 6) {
  						throw new $TypeError('Assertion failed: thisArg is required when mapperFunction is provided');
  					}
  					element = this.Call(mapperFunction, arguments[6], [element, sourceIndex, source]);
  				}
  				var shouldFlatten = false;
  				if (depth > 0) {
  					shouldFlatten = this.IsArray(element);
  				}
  				if (shouldFlatten) {
  					var elementLen = this.ToLength(this.Get(element, 'length'));
  					targetIndex = this.FlattenIntoArray(target, element, elementLen, targetIndex, depth - 1);
  				} else {
  					if (targetIndex >= MAX_SAFE_INTEGER) {
  						throw new $TypeError('index too large');
  					}
  					this.CreateDataPropertyOrThrow(target, this.ToString(targetIndex), element);
  					targetIndex += 1;
  				}
  			}
  			sourceIndex += 1;
  		}
  
  		return targetIndex;
  	},
  
  	// https://ecma-international.org/ecma-262/10.0/#sec-trimstring
  	TrimString: function TrimString(string, where) {
  		var str = this.RequireObjectCoercible(string);
  		var S = this.ToString(str);
  		var T;
  		if (where === 'start') {
  			T = trimStart(S);
  		} else if (where === 'end') {
  			T = trimEnd(S);
  		} else if (where === 'start+end') {
  			T = trimStart(trimEnd(S));
  		} else {
  			throw new $TypeError('Assertion failed: invalid `where` value; must be "start", "end", or "start+end"');
  		}
  		return T;
  	}
  });
  
  module.exports = ES2019;
  