vendor/assets/polyfill/es5.js

   1 /* Polyfill service v3.27.1
   2  * For detailed credits and licence information see https://github.com/financial-times/polyfill-service.
   3  *
   4  * Features requested: es5
   5  *
   6  * - Object.defineProperty, License: CC0 (required by "es5", "Object.defineProperties", "Object.create", "_ESAbstract.CreateMethodProperty", "Array.isArray", "Array.prototype.every", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "Function.prototype.bind", "Object.freeze", "Object.getOwnPropertyDescriptor", "Object.getOwnPropertyNames", "Object.getPrototypeOf", "String.prototype.trim", "_ESAbstract.CreateDataProperty", "_ESAbstract.CreateDataPropertyOrThrow", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "_ESAbstract.ArraySpeciesCreate")
   7  * - _ESAbstract.CreateMethodProperty, License: CC0 (required by "Array.isArray", "es5", "Array.prototype.every", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "Function.prototype.bind", "Object.create", "Object.defineProperties", "Object.freeze", "Object.getOwnPropertyDescriptor", "Object.getOwnPropertyNames", "Object.getPrototypeOf", "String.prototype.trim")
   8  * - _ESAbstract.IsArray, License: CC0 (required by "Array.isArray", "es5", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "Array.prototype.map")
   9  * - Array.isArray, License: CC0 (required by "es5")
  10  * - _ESAbstract.ToObject, License: CC0 (required by "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "Object.defineProperties", "Object.create", "_ESAbstract.GetV", "_ESAbstract.GetMethod", "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "String.prototype.trim", "_ESAbstract.IsConstructor", "_ESAbstract.ArraySpeciesCreate")
  11  * - _ESAbstract.ToInteger, License: CC0 (required by "Array.prototype.indexOf", "es5", "Array.prototype.lastIndexOf", "_ESAbstract.ToLength", "Array.prototype.every", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some")
  12  * - _ESAbstract.ToLength, License: CC0 (required by "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some")
  13  * - _ESAbstract.Get, License: CC0 (required by "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "Object.defineProperties", "Object.create", "_ESAbstract.ArraySpeciesCreate", "_ESAbstract.OrdinaryToPrimitive", "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "String.prototype.trim", "_ESAbstract.GetPrototypeFromConstructor", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct")
  14  * - _ESAbstract.IsCallable, License: CC0 (required by "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "Function.prototype.bind", "_ESAbstract.GetMethod", "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "String.prototype.trim", "_ESAbstract.IsConstructor", "_ESAbstract.ArraySpeciesCreate", "_ESAbstract.OrdinaryToPrimitive")
  15  * - _ESAbstract.Call, License: CC0 (required by "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "String.prototype.trim", "_ESAbstract.OrdinaryToPrimitive")
  16  * - _ESAbstract.GetV, License: CC0 (required by "_ESAbstract.GetMethod", "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "String.prototype.trim", "_ESAbstract.IsConstructor", "_ESAbstract.ArraySpeciesCreate")
  17  * - _ESAbstract.GetMethod, License: CC0 (required by "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "String.prototype.trim", "_ESAbstract.IsConstructor", "_ESAbstract.ArraySpeciesCreate")
  18  * - _ESAbstract.Type, License: CC0 (required by "Object.create", "es5", "Object.defineProperties", "_ESAbstract.ToString", "Array.prototype.every", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "String.prototype.trim", "_ESAbstract.ArraySpeciesCreate", "_ESAbstract.ToPrimitive", "_ESAbstract.IsConstructor", "_ESAbstract.OrdinaryToPrimitive", "_ESAbstract.GetPrototypeFromConstructor", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct")
  19  * - _ESAbstract.OrdinaryToPrimitive, License: CC0 (required by "_ESAbstract.ToPrimitive", "_ESAbstract.ToString", "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "String.prototype.trim")
  20  * - _ESAbstract.ToPrimitive, License: CC0 (required by "_ESAbstract.ToString", "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "String.prototype.trim")
  21  * - _ESAbstract.ToString, License: CC0 (required by "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some", "String.prototype.trim")
  22  * - _ESAbstract.HasProperty, License: CC0 (required by "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.forEach", "Array.prototype.indexOf", "Array.prototype.lastIndexOf", "Array.prototype.map", "Array.prototype.reduce", "Array.prototype.reduceRight", "Array.prototype.some")
  23  * - _ESAbstract.ToBoolean, License: CC0 (required by "Array.prototype.every", "es5", "Array.prototype.filter", "Array.prototype.some")
  24  * - Array.prototype.every, License: CC0 (required by "es5")
  25  * - _ESAbstract.ArrayCreate, License: CC0 (required by "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "es5", "Array.prototype.map")
  26  * - _ESAbstract.IsConstructor, License: CC0 (required by "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "es5", "Array.prototype.map", "_ESAbstract.Construct")
  27  * - _ESAbstract.GetPrototypeFromConstructor, License: CC0 (required by "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "es5", "Array.prototype.map")
  28  * - Object.keys, License: MIT (required by "es5", "Object.defineProperties", "Object.create")
  29  * - Function.prototype.bind, License: MIT (required by "es5", "Object.getOwnPropertyDescriptor", "Object.defineProperties", "Object.create", "_ESAbstract.Construct", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "Array.prototype.map")
  30  * - Object.getOwnPropertyDescriptor, License: CC0 (required by "es5", "Object.defineProperties", "Object.create")
  31  * - Object.defineProperties, License: CC0 (required by "es5", "Object.create")
  32  * - Object.create, License: CC0 (required by "es5", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "Array.prototype.map")
  33  * - Object.getPrototypeOf, License: CC0 (required by "es5", "_ESAbstract.OrdinaryCreateFromConstructor", "_ESAbstract.Construct", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "Array.prototype.map")
  34  * - _ESAbstract.OrdinaryCreateFromConstructor, License: CC0 (required by "_ESAbstract.Construct", "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "es5", "Array.prototype.map")
  35  * - _ESAbstract.Construct, License: CC0 (required by "_ESAbstract.ArraySpeciesCreate", "Array.prototype.filter", "es5", "Array.prototype.map")
  36  * - _ESAbstract.ArraySpeciesCreate, License: CC0 (required by "Array.prototype.filter", "es5", "Array.prototype.map")
  37  * - _ESAbstract.CreateDataProperty, License: CC0 (required by "_ESAbstract.CreateDataPropertyOrThrow", "Array.prototype.filter", "es5", "Array.prototype.map")
  38  * - _ESAbstract.CreateDataPropertyOrThrow, License: CC0 (required by "Array.prototype.filter", "es5", "Array.prototype.map")
  39  * - Array.prototype.filter, License: CC0 (required by "es5")
  40  * - Array.prototype.forEach, License: CC0 (required by "es5")
  41  * - Array.prototype.indexOf, License: CC0 (required by "es5")
  42  * - Array.prototype.lastIndexOf, License: CC0 (required by "es5")
  43  * - Array.prototype.map, License: CC0 (required by "es5")
  44  * - Array.prototype.reduce, License: CC0 (required by "es5")
  45  * - Array.prototype.reduceRight, License: CC0 (required by "es5")
  46  * - Array.prototype.some, License: CC0 (required by "es5")
  47  * - Date.now, License: CC0 (required by "es5")
  48  * - Date.prototype.toISOString, License: CC0 (required by "es5")
  49  * - Object.freeze, License: CC0 (required by "es5")
  50  * - Object.getOwnPropertyNames, License: CC0 (required by "es5")
  51  * - _ESAbstract.RequireObjectCoercible, License: CC0 (required by "String.prototype.trim", "es5")
  52  * - String.prototype.trim, License: CC0 (required by "es5") */
  53
  54 (function(undefined) {
  55 if (!(// In IE8, defineProperty could only act on DOM elements, so full support
  56 // for the feature requires the ability to set a property on an arbitrary object
  57 'defineProperty' in Object && (function() {
  58         try {
  59                 var a = {};
  60                 Object.defineProperty(a, 'test', {value:42});
  61                 return true;
  62         } catch(e) {
  63                 return false
  64         }
  65 }()))) {
  66
  67 // Object.defineProperty
  68 (function (nativeDefineProperty) {
  69
  70         var supportsAccessors = Object.prototype.hasOwnProperty('__defineGetter__');
  71         var ERR_ACCESSORS_NOT_SUPPORTED = 'Getters & setters cannot be defined on this javascript engine';
  72         var ERR_VALUE_ACCESSORS = 'A property cannot both have accessors and be writable or have a value';
  73
  74         // Polyfill.io - This does not use CreateMethodProperty because our CreateMethodProperty function uses Object.defineProperty.
  75         Object['defineProperty'] = function defineProperty(object, property, descriptor) {
  76
  77                 // Where native support exists, assume it
  78                 if (nativeDefineProperty && (object === window || object === document || object === Element.prototype || object instanceof Element)) {
  79                         return nativeDefineProperty(object, property, descriptor);
  80                 }
  81
  82                 if (object === null || !(object instanceof Object || typeof object === 'object')) {
  83                         throw new TypeError('Object.defineProperty called on non-object');
  84                 }
  85
  86                 if (!(descriptor instanceof Object)) {
  87                         throw new TypeError('Property description must be an object');
  88                 }
  89
  90                 var propertyString = String(property);
  91                 var hasValueOrWritable = 'value' in descriptor || 'writable' in descriptor;
  92                 var getterType = 'get' in descriptor && typeof descriptor.get;
  93                 var setterType = 'set' in descriptor && typeof descriptor.set;
  94
  95                 // handle descriptor.get
  96                 if (getterType) {
  97                         if (getterType !== 'function') {
  98                                 throw new TypeError('Getter must be a function');
  99                         }
 100                         if (!supportsAccessors) {
 101                                 throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
 102                         }
 103                         if (hasValueOrWritable) {
 104                                 throw new TypeError(ERR_VALUE_ACCESSORS);
 105                         }
 106                         Object.__defineGetter__.call(object, propertyString, descriptor.get);
 107                 } else {
 108                         object[propertyString] = descriptor.value;
 109                 }
 110
 111                 // handle descriptor.set
 112                 if (setterType) {
 113                         if (setterType !== 'function') {
 114                                 throw new TypeError('Setter must be a function');
 115                         }
 116                         if (!supportsAccessors) {
 117                                 throw new TypeError(ERR_ACCESSORS_NOT_SUPPORTED);
 118                         }
 119                         if (hasValueOrWritable) {
 120                                 throw new TypeError(ERR_VALUE_ACCESSORS);
 121                         }
 122                         Object.__defineSetter__.call(object, propertyString, descriptor.set);
 123                 }
 124
 125                 // OK to define value unconditionally - if a getter has been specified as well, an error would be thrown above
 126                 if ('value' in descriptor) {
 127                         object[propertyString] = descriptor.value;
 128                 }
 129
 130                 return object;
 131         };
 132 }(Object.defineProperty));
 133
 134 }
 135
 136
 137 // _ESAbstract.CreateMethodProperty
 138 // 7.3.5. CreateMethodProperty ( O, P, V )
 139 function CreateMethodProperty(O, P, V) { // eslint-disable-line no-unused-vars
 140         // 1. Assert: Type(O) is Object.
 141         // 2. Assert: IsPropertyKey(P) is true.
 142         // 3. Let newDesc be the PropertyDescriptor{[[Value]]: V, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: true}.
 143         var newDesc = {
 144                 value: V,
 145                 writable: true,
 146                 enumerable: false,
 147                 configurable: true
 148         };
 149         // 4. Return ? O.[[DefineOwnProperty]](P, newDesc).
 150         Object.defineProperty(O, P, newDesc);
 151 }
 152
 153 // _ESAbstract.IsArray
 154 // 7.2.2. IsArray ( argument )
 155 function IsArray(argument) { // eslint-disable-line no-unused-vars
 156         // 1. If Type(argument) is not Object, return false.
 157         // 2. If argument is an Array exotic object, return true.
 158         // 3. If argument is a Proxy exotic object, then
 159                 // a. If argument.[[ProxyHandler]] is null, throw a TypeError exception.
 160                 // b. Let target be argument.[[ProxyTarget]].
 161                 // c. Return ? IsArray(target).
 162         // 4. Return false.
 163
 164         // Polyfill.io - We can skip all the above steps and check the string returned from Object.prototype.toString().
 165         return Object.prototype.toString.call(argument) === '[object Array]';
 166 }
 167 if (!('isArray' in Array)) {
 168
 169 // Array.isArray
 170 /* global CreateMethodProperty, IsArray */
 171 // 22.1.2.2. Array.isArray ( arg )
 172 CreateMethodProperty(Array, 'isArray', function isArray(arg) {
 173         // 1. Return ? IsArray(arg).
 174         return IsArray(arg);
 175 });
 176
 177 }
 178
 179
 180 // _ESAbstract.ToObject
 181 // 7.1.13 ToObject ( argument )
 182 // The abstract operation ToObject converts argument to a value of type Object according to Table 12:
 183 // Table 12: ToObject Conversions
 184 /*
 185 |----------------------------------------------------------------------------------------------------------------------------------------------------|
 186 | Argument Type | Result                                                                                                                             |
 187 |----------------------------------------------------------------------------------------------------------------------------------------------------|
 188 | Undefined     | Throw a TypeError exception.                                                                                                       |
 189 | Null          | Throw a TypeError exception.                                                                                                       |
 190 | Boolean       | Return a new Boolean object whose [[BooleanData]] internal slot is set to argument. See 19.3 for a description of Boolean objects. |
 191 | Number        | Return a new Number object whose [[NumberData]] internal slot is set to argument. See 20.1 for a description of Number objects.    |
 192 | String        | Return a new String object whose [[StringData]] internal slot is set to argument. See 21.1 for a description of String objects.    |
 193 | Symbol        | Return a new Symbol object whose [[SymbolData]] internal slot is set to argument. See 19.4 for a description of Symbol objects.    |
 194 | Object        | Return argument.                                                                                                                   |
 195 |----------------------------------------------------------------------------------------------------------------------------------------------------|
 196 */
 197 function ToObject(argument) { // eslint-disable-line no-unused-vars
 198         if (argument === null || argument === undefined) {
 199                 throw TypeError();
 200         }
 201   return Object(argument);
 202 }
 203
 204 // _ESAbstract.ToInteger
 205 // 7.1.4. ToInteger ( argument )
 206 function ToInteger(argument) { // eslint-disable-line no-unused-vars
 207         // 1. Let number be ? ToNumber(argument).
 208         var number = Number(argument);
 209         // 2. If number is NaN, return +0.
 210         if (isNaN(number)) {
 211                 return 0;
 212         }
 213         // 3. If number is +0, -0, +∞, or -∞, return number.
 214         if (1/number === Infinity || 1/number === -Infinity || number === Infinity || number === -Infinity) {
 215                 return number;
 216         }
 217         // 4. Return the number value that is the same sign as number and whose magnitude is floor(abs(number)).
 218         return ((number < 0) ? -1 : 1) * Math.floor(Math.abs(number));
 219 }
 220
 221 // _ESAbstract.ToLength
 222 /* global ToInteger */
 223 // 7.1.15. ToLength ( argument )
 224 function ToLength(argument) { // eslint-disable-line no-unused-vars
 225         // 1. Let len be ? ToInteger(argument).
 226         var len = ToInteger(argument);
 227         // 2. If len ≤ +0, return +0.
 228         if (len <= 0) {
 229                 return 0;
 230         }
 231         // 3. Return min(len, 253-1).
 232         return Math.min(len, Math.pow(2, 53) -1);
 233 }
 234
 235 // _ESAbstract.Get
 236 // 7.3.1. Get ( O, P )
 237 function Get(O, P) { // eslint-disable-line no-unused-vars
 238         // 1. Assert: Type(O) is Object.
 239         // 2. Assert: IsPropertyKey(P) is true.
 240         // 3. Return ? O.[[Get]](P, O).
 241         return O[P];
 242 }
 243
 244 // _ESAbstract.IsCallable
 245 // 7.2.3. IsCallable ( argument )
 246 function IsCallable(argument) { // eslint-disable-line no-unused-vars
 247         // 1. If Type(argument) is not Object, return false.
 248         // 2. If argument has a [[Call]] internal method, return true.
 249         // 3. Return false.
 250
 251         // Polyfill.io - Only function objects have a [[Call]] internal method. This means we can simplify this function to check that the argument has a type of function.
 252         return typeof argument === 'function';
 253 }
 254
 255 // _ESAbstract.Call
 256 /* global IsCallable */
 257 // 7.3.12. Call ( F, V [ , argumentsList ] )
 258 function Call(F, V /* [, argumentsList] */) { // eslint-disable-line no-unused-vars
 259         // 1. If argumentsList is not present, set argumentsList to a new empty List.
 260         var argumentsList = arguments.length > 2 ? arguments[2] : [];
 261         // 2. If IsCallable(F) is false, throw a TypeError exception.
 262         if (IsCallable(F) === false) {
 263                 throw new TypeError(Object.prototype.toString.call(F) + 'is not a function.');
 264         }
 265         // 3. Return ? F.[[Call]](V, argumentsList).
 266         return F.apply(V, argumentsList);
 267 }
 268
 269 // _ESAbstract.GetV
 270 /* global ToObject */
 271 // 7.3.2 GetV (V, P)
 272 function GetV(v, p) { // eslint-disable-line no-unused-vars
 273         // 1. Assert: IsPropertyKey(P) is true.
 274         // 2. Let O be ? ToObject(V).
 275         var o = ToObject(v);
 276         // 3. Return ? O.[[Get]](P, V).
 277         return o[p];
 278 }
 279
 280 // _ESAbstract.GetMethod
 281 /* global GetV, IsCallable */
 282 // 7.3.9. GetMethod ( V, P )
 283 function GetMethod(V, P) { // eslint-disable-line no-unused-vars
 284         // 1. Assert: IsPropertyKey(P) is true.
 285         // 2. Let func be ? GetV(V, P).
 286         var func = GetV(V, P);
 287         // 3. If func is either undefined or null, return undefined.
 288         if (func === null || func === undefined) {
 289                 return undefined;
 290         }
 291         // 4. If IsCallable(func) is false, throw a TypeError exception.
 292         if (IsCallable(func) === false) {
 293                 throw new TypeError('Method not callable: ' + P);
 294         }
 295         // 5. Return func.
 296         return func;
 297 }
 298
 299 // _ESAbstract.Type
 300 // "Type(x)" is used as shorthand for "the type of x"...
 301 function Type(x) { // eslint-disable-line no-unused-vars
 302         switch (typeof x) {
 303                 case 'undefined':
 304                         return 'undefined';
 305                 case 'boolean':
 306                         return 'boolean';
 307                 case 'number':
 308                         return 'number';
 309                 case 'string':
 310                         return 'string';
 311                 case 'symbol':
 312                         return 'symbol';
 313                 default:
 314                         // typeof null is 'object'
 315                         if (x === null) return 'null';
 316                         // Polyfill.io - This is here because a Symbol polyfill will have a typeof `object`.
 317                         if ('Symbol' in this && x instanceof this.Symbol) return 'symbol';
 318                         return 'object';
 319         }
 320 }
 321
 322 // _ESAbstract.OrdinaryToPrimitive
 323 /* global Get, IsCallable, Call, Type */
 324 // 7.1.1.1. OrdinaryToPrimitive ( O, hint )
 325 function OrdinaryToPrimitive(O, hint) { // eslint-disable-line no-unused-vars
 326         // 1. Assert: Type(O) is Object.
 327         // 2. Assert: Type(hint) is String and its value is either "string" or "number".
 328         // 3. If hint is "string", then
 329         if (hint === 'string') {
 330                 // a. Let methodNames be « "toString", "valueOf" ».
 331                 var methodNames = ['toString', 'valueOf'];
 332                 // 4. Else,
 333         } else {
 334                 // a. Let methodNames be « "valueOf", "toString" ».
 335                 methodNames = ['valueOf', 'toString'];
 336         }
 337         // 5. For each name in methodNames in List order, do
 338         for (var i = 0; i < methodNames.length; ++i) {
 339                 var name = methodNames[i];
 340                 // a. Let method be ? Get(O, name).
 341                 var method = Get(O, name);
 342                 // b. If IsCallable(method) is true, then
 343                 if (IsCallable(method)) {
 344                         // i. Let result be ? Call(method, O).
 345                         var result = Call(method, O);
 346                         // ii. If Type(result) is not Object, return result.
 347                         if (Type(result) !== 'object') {
 348                                 return result;
 349                         }
 350                 }
 351         }
 352         // 6. Throw a TypeError exception.
 353         throw new TypeError('Cannot convert to primitive.');
 354 }
 355
 356 // _ESAbstract.ToPrimitive
 357 /* global Type, GetMethod, Call, OrdinaryToPrimitive */
 358 // 7.1.1. ToPrimitive ( input [ , PreferredType ] )
 359 function ToPrimitive(input /* [, PreferredType] */) { // eslint-disable-line no-unused-vars
 360         var PreferredType = arguments.length > 1 ? arguments[1] : undefined;
 361         // 1. Assert: input is an ECMAScript language value.
 362         // 2. If Type(input) is Object, then
 363         if (Type(input) === 'object') {
 364                 // a. If PreferredType is not present, let hint be "default".
 365                 if (arguments.length < 2) {
 366                         var hint = 'default';
 367                         // b. Else if PreferredType is hint String, let hint be "string".
 368                 } else if (PreferredType === String) {
 369                         hint = 'string';
 370                         // c. Else PreferredType is hint Number, let hint be "number".
 371                 } else if (PreferredType === Number) {
 372                         hint = 'number';
 373                 }
 374                 // d. Let exoticToPrim be ? GetMethod(input, @@toPrimitive).
 375                 var exoticToPrim = typeof this.Symbol === 'function' && typeof this.Symbol.toPrimitive === 'symbol' ? GetMethod(input, this.Symbol.toPrimitive) : undefined;
 376                 // e. If exoticToPrim is not undefined, then
 377                 if (exoticToPrim !== undefined) {
 378                         // i. Let result be ? Call(exoticToPrim, input, « hint »).
 379                         var result = Call(exoticToPrim, input, [hint]);
 380                         // ii. If Type(result) is not Object, return result.
 381                         if (Type(result) !== 'object') {
 382                                 return result;
 383                         }
 384                         // iii. Throw a TypeError exception.
 385                         throw new TypeError('Cannot convert exotic object to primitive.');
 386                 }
 387                 // f. If hint is "default", set hint to "number".
 388                 if (hint === 'default') {
 389                         hint = 'number';
 390                 }
 391                 // g. Return ? OrdinaryToPrimitive(input, hint).
 392                 return OrdinaryToPrimitive(input, hint);
 393         }
 394         // 3. Return input
 395         return input;
 396 }
 397
 398 // _ESAbstract.ToString
 399 /* global Type, ToPrimitive */
 400 // 7.1.12. ToString ( argument )
 401 // The abstract operation ToString converts argument to a value of type String according to Table 11:
 402 // Table 11: ToString Conversions
 403 /*
 404 |---------------|--------------------------------------------------------|
 405 | Argument Type | Result                                                 |
 406 |---------------|--------------------------------------------------------|
 407 | Undefined     | Return "undefined".                                    |
 408 |---------------|--------------------------------------------------------|
 409 | Null          | Return "null".                                         |
 410 |---------------|--------------------------------------------------------|
 411 | Boolean       | If argument is true, return "true".                    |
 412 |               | If argument is false, return "false".                  |
 413 |---------------|--------------------------------------------------------|
 414 | Number        | Return NumberToString(argument).                       |
 415 |---------------|--------------------------------------------------------|
 416 | String        | Return argument.                                       |
 417 |---------------|--------------------------------------------------------|
 418 | Symbol        | Throw a TypeError exception.                           |
 419 |---------------|--------------------------------------------------------|
 420 | Object        | Apply the following steps:                             |
 421 |               | Let primValue be ? ToPrimitive(argument, hint String). |
 422 |               | Return ? ToString(primValue).                          |
 423 |---------------|--------------------------------------------------------|
 424 */
 425 function ToString(argument) { // eslint-disable-line no-unused-vars
 426         switch(Type(argument)) {
 427                 case 'symbol':
 428                         throw new TypeError('Cannot convert a Symbol value to a string');
 429                         break;
 430                 case 'object':
 431                         var primValue = ToPrimitive(argument, 'string');
 432                         return ToString(primValue);
 433                 default:
 434                         return String(argument);
 435         }
 436 }
 437
 438 // _ESAbstract.HasProperty
 439 // 7.3.10. HasProperty ( O, P )
 440 function HasProperty(O, P) { // eslint-disable-line no-unused-vars
 441         // Assert: Type(O) is Object.
 442         // Assert: IsPropertyKey(P) is true.
 443         // Return ? O.[[HasProperty]](P).
 444         return P in O;
 445 }
 446
 447 // _ESAbstract.ToBoolean
 448 // 7.1.2. ToBoolean ( argument )
 449 // The abstract operation ToBoolean converts argument to a value of type Boolean according to Table 9:
 450 /*
 451 --------------------------------------------------------------------------------------------------------------
 452 | Argument Type | Result                                                                                     |
 453 --------------------------------------------------------------------------------------------------------------
 454 | Undefined     | Return false.                                                                              |
 455 | Null          | Return false.                                                                              |
 456 | Boolean       | Return argument.                                                                           |
 457 | Number        | If argument is +0, -0, or NaN, return false; otherwise return true.                        |
 458 | String        | If argument is the empty String (its length is zero), return false; otherwise return true. |
 459 | Symbol        | Return true.                                                                               |
 460 | Object        | Return true.                                                                               |
 461 --------------------------------------------------------------------------------------------------------------
 462 */
 463 function ToBoolean(argument) { // eslint-disable-line no-unused-vars
 464         return Boolean(argument);
 465 }
 466 if (!('every' in Array.prototype)) {
 467
 468 // Array.prototype.every
 469 /* global Call, CreateMethodProperty, Get, HasProperty, IsCallable, ToBoolean, ToLength, ToObject, ToString */
 470 // 22.1.3.5. Array.prototype.every ( callbackfn [ , thisArg ] )
 471 CreateMethodProperty(Array.prototype, 'every', function every(callbackfn /* [ , thisArg ] */) {
 472         // 1. Let O be ? ToObject(this value).
 473         var O = ToObject(this);
 474         // 2. Let len be ? ToLength(? Get(O, "length")).
 475         var len = ToLength(Get(O, "length"));
 476         // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
 477         if (IsCallable(callbackfn) === false) {
 478                 throw new TypeError(callbackfn + ' is not a function');
 479         }
 480         // 4. If thisArg is present, let T be thisArg; else let T be undefined.
 481         var T = arguments.length > 1 ? arguments[1] : undefined;
 482         // 5. Let k be 0.
 483         var k = 0;
 484         // 6. Repeat, while k < len
 485         while (k < len) {
 486                 // a. Let Pk be ! ToString(k).
 487                 var Pk = ToString(k);
 488                 // b. Let kPresent be ? HasProperty(O, Pk).
 489                 var kPresent = HasProperty(O, Pk);
 490                 // c. If kPresent is true, then
 491                 if (kPresent) {
 492                         // i. Let kValue be ? Get(O, Pk).
 493                         var kValue = Get(O, Pk);
 494                         // ii. Let testResult be ToBoolean(? Call(callbackfn, T, « kValue, k, O »)).
 495                         var testResult = ToBoolean(Call(callbackfn, T, [kValue, k, O]));
 496                         // iii. If testResult is false, return false.
 497                         if (testResult === false) {
 498                                 return false;
 499                         }
 500                 }
 501                 // d. Increase k by 1.
 502                 var k = k + 1;
 503         }
 504         // 7. Return true.
 505         return true;
 506 });
 507
 508 }
 509
 510
 511 // _ESAbstract.ArrayCreate
 512 // 9.4.2.2. ArrayCreate ( length [ , proto ] )
 513 function ArrayCreate(length /* [, proto] */) { // eslint-disable-line no-unused-vars
 514         // 1. Assert: length is an integer Number ≥ 0.
 515         // 2. If length is -0, set length to +0.
 516         if (1 / length === -Infinity) {
 517                 length = 0;
 518         }
 519         // 3. If length>2^32-1, throw a RangeError exception.
 520         if (length > (Math.pow(2, 32) - 1)) {
 521                 throw new RangeError('Invalid array length');
 522         }
 523         // 4. If proto is not present, set proto to the intrinsic object %ArrayPrototype%.
 524         // 5. Let A be a newly created Array exotic object.
 525         var A = [];
 526         // 6. Set A's essential internal methods except for [[DefineOwnProperty]] to the default ordinary object definitions specified in 9.1.
 527         // 7. Set A.[[DefineOwnProperty]] as specified in 9.4.2.1.
 528         // 8. Set A.[[Prototype]] to proto.
 529         // 9. Set A.[[Extensible]] to true.
 530         // 10. Perform ! OrdinaryDefineOwnProperty(A, "length", PropertyDescriptor{[[Value]]: length, [[Writable]]: true, [[Enumerable]]: false, [[Configurable]]: false}).
 531         A.length = length;
 532         // 11. Return A.
 533         return A;
 534 }
 535
 536 // _ESAbstract.IsConstructor
 537 /* global Type */
 538 // 7.2.4. IsConstructor ( argument )
 539 function IsConstructor(argument) { // eslint-disable-line no-unused-vars
 540         // 1. If Type(argument) is not Object, return false.
 541         if (Type(argument) !== 'object') {
 542                 return false;
 543         }
 544         // 2. If argument has a [[Construct]] internal method, return true.
 545         // 3. Return false.
 546
 547         // Polyfill.io - `new argument` is the only way  to truly test if a function is a constructor.
 548         // We choose to not use`new argument` because the argument could have side effects when called.
 549         // Instead we check to see if the argument is a function and if it has a prototype.
 550         // Arrow functions do not have a [[Construct]] internal method, nor do they have a prototype.
 551         return typeof argument === 'function' && !!argument.prototype;
 552 }
 553
 554 // _ESAbstract.GetPrototypeFromConstructor
 555 /* global Get, Type */
 556 // 9.1.14. GetPrototypeFromConstructor ( constructor, intrinsicDefaultProto )
 557 function GetPrototypeFromConstructor(constructor, intrinsicDefaultProto) { // eslint-disable-line no-unused-vars
 558         // 1. Assert: intrinsicDefaultProto is a String value that is this specification's name of an intrinsic object. The corresponding object must be an intrinsic that is intended to be used as the [[Prototype]] value of an object.
 559         // 2. Assert: IsCallable(constructor) is true.
 560         // 3. Let proto be ? Get(constructor, "prototype").
 561         var proto = Get(constructor, "prototype");
 562         // 4. If Type(proto) is not Object, then
 563         if (Type(proto) !== 'object') {
 564                 // a. Let realm be ? GetFunctionRealm(constructor).
 565                 // b. Set proto to realm's intrinsic object named intrinsicDefaultProto.
 566                 proto = intrinsicDefaultProto;
 567         }
 568         // 5. Return proto.
 569         return proto;
 570 }
 571 if (!('keys' in Object && (function () {
 572         // Safari 5.0 bug where Object.keys doesn't work with arguments
 573         return (Object.keys(arguments)).length === 2;
 574 }(1, 2)) && (function () {
 575         try {
 576                 // In ES6 Object.keys works on all object except `null` and `undefined`.
 577                 Object.keys('');
 578                 return true;
 579         } catch (e) {
 580                 return false;
 581         }
 582 }()))) {
 583
 584 // Object.keys
 585 Object.keys = (function() {
 586         'use strict';
 587
 588         // modified from https://github.com/es-shims/object-keys
 589
 590         var has = Object.prototype.hasOwnProperty;
 591         var toStr = Object.prototype.toString;
 592         var isEnumerable = Object.prototype.propertyIsEnumerable;
 593         var hasDontEnumBug = !isEnumerable.call({ toString: null }, 'toString');
 594         var hasProtoEnumBug = isEnumerable.call(function () {}, 'prototype');
 595         var dontEnums = [
 596                 'toString',
 597                 'toLocaleString',
 598                 'valueOf',
 599                 'hasOwnProperty',
 600                 'isPrototypeOf',
 601                 'propertyIsEnumerable',
 602                 'constructor'
 603         ];
 604         var equalsConstructorPrototype = function (o) {
 605                 var ctor = o.constructor;
 606                 return ctor && ctor.prototype === o;
 607         };
 608         var excludedKeys = {
 609                 $console: true,
 610                 $external: true,
 611                 $frame: true,
 612                 $frameElement: true,
 613                 $frames: true,
 614                 $innerHeight: true,
 615                 $innerWidth: true,
 616                 $outerHeight: true,
 617                 $outerWidth: true,
 618                 $pageXOffset: true,
 619                 $pageYOffset: true,
 620                 $parent: true,
 621                 $scrollLeft: true,
 622                 $scrollTop: true,
 623                 $scrollX: true,
 624                 $scrollY: true,
 625                 $self: true,
 626                 $webkitIndexedDB: true,
 627                 $webkitStorageInfo: true,
 628                 $window: true
 629         };
 630         var hasAutomationEqualityBug = (function () {
 631                 /* global window */
 632                 if (typeof window === 'undefined') { return false; }
 633                 for (var k in window) {
 634                         try {
 635                                 if (!excludedKeys['$' + k] && has.call(window, k) && window[k] !== null && typeof window[k] === 'object') {
 636                                         try {
 637                                                 equalsConstructorPrototype(window[k]);
 638                                         } catch (e) {
 639                                                 return true;
 640                                         }
 641                                 }
 642                         } catch (e) {
 643                                 return true;
 644                         }
 645                 }
 646                 return false;
 647         }());
 648         var equalsConstructorPrototypeIfNotBuggy = function (o) {
 649                 /* global window */
 650                 if (typeof window === 'undefined' || !hasAutomationEqualityBug) {
 651                         return equalsConstructorPrototype(o);
 652                 }
 653                 try {
 654                         return equalsConstructorPrototype(o);
 655                 } catch (e) {
 656                         return false;
 657                 }
 658         };
 659
 660         function isArgumentsObject(value) {
 661                 var str = toStr.call(value);
 662                 var isArgs = str === '[object Arguments]';
 663                 if (!isArgs) {
 664                         isArgs = str !== '[object Array]' &&
 665                                 value !== null &&
 666                                 typeof value === 'object' &&
 667                                 typeof value.length === 'number' &&
 668                                 value.length >= 0 &&
 669                                 toStr.call(value.callee) === '[object Function]';
 670                 }
 671                 return isArgs;
 672         }
 673
 674         return function keys(object) {
 675                 var isFunction = toStr.call(object) === '[object Function]';
 676                 var isArguments = isArgumentsObject(object);
 677                 var isString = toStr.call(object) === '[object String]';
 678                 var theKeys = [];
 679
 680                 if (object === undefined || object === null) {
 681                         throw new TypeError('Cannot convert undefined or null to object');
 682                 }
 683
 684                 var skipProto = hasProtoEnumBug && isFunction;
 685                 if (isString && object.length > 0 && !has.call(object, 0)) {
 686                         for (var i = 0; i < object.length; ++i) {
 687                                 theKeys.push(String(i));
 688                         }
 689                 }
 690
 691                 if (isArguments && object.length > 0) {
 692                         for (var j = 0; j < object.length; ++j) {
 693                                 theKeys.push(String(j));
 694                         }
 695                 } else {
 696                         for (var name in object) {
 697                                 if (!(skipProto && name === 'prototype') && has.call(object, name)) {
 698                                         theKeys.push(String(name));
 699                                 }
 700                         }
 701                 }
 702
 703                 if (hasDontEnumBug) {
 704                         var skipConstructor = equalsConstructorPrototypeIfNotBuggy(object);
 705
 706                         for (var k = 0; k < dontEnums.length; ++k) {
 707                                 if (!(skipConstructor && dontEnums[k] === 'constructor') && has.call(object, dontEnums[k])) {
 708                                         theKeys.push(dontEnums[k]);
 709                                 }
 710                         }
 711                 }
 712                 return theKeys;
 713         };
 714 }());
 715
 716 }
 717
 718 if (!('bind' in Function.prototype)) {
 719
 720 // Function.prototype.bind
 721 /* global CreateMethodProperty, IsCallable */
 722 // 19.2.3.2. Function.prototype.bind ( thisArg, ...args )
 723 // https://github.com/es-shims/es5-shim/blob/d6d7ff1b131c7ba14c798cafc598bb6780d37d3b/es5-shim.js#L182
 724 CreateMethodProperty(Function.prototype, 'bind', function bind(that) { // .length is 1
 725         // add necessary es5-shim utilities
 726         var $Array = Array;
 727         var $Object = Object;
 728         var ArrayPrototype = $Array.prototype;
 729         var Empty = function Empty() { };
 730         var array_slice = ArrayPrototype.slice;
 731         var array_concat = ArrayPrototype.concat;
 732         var array_push = ArrayPrototype.push;
 733         var max = Math.max;
 734         // /add necessary es5-shim utilities
 735
 736         // 1. Let Target be the this value.
 737         var target = this;
 738         // 2. If IsCallable(Target) is false, throw a TypeError exception.
 739         if (!IsCallable(target)) {
 740                 throw new TypeError('Function.prototype.bind called on incompatible ' + target);
 741         }
 742         // 3. Let A be a new (possibly empty) internal list of all of the
 743         //   argument values provided after thisArg (arg1, arg2 etc), in order.
 744         // XXX slicedArgs will stand in for "A" if used
 745         var args = array_slice.call(arguments, 1); // for normal call
 746         // 4. Let F be a new native ECMAScript object.
 747         // 11. Set the [[Prototype]] internal property of F to the standard
 748         //   built-in Function prototype object as specified in 15.3.3.1.
 749         // 12. Set the [[Call]] internal property of F as described in
 750         //   15.3.4.5.1.
 751         // 13. Set the [[Construct]] internal property of F as described in
 752         //   15.3.4.5.2.
 753         // 14. Set the [[HasInstance]] internal property of F as described in
 754         //   15.3.4.5.3.
 755         var bound;
 756         var binder = function () {
 757
 758                 if (this instanceof bound) {
 759                         // 15.3.4.5.2 [[Construct]]
 760                         // When the [[Construct]] internal method of a function object,
 761                         // F that was created using the bind function is called with a
 762                         // list of arguments ExtraArgs, the following steps are taken:
 763                         // 1. Let target be the value of F's [[TargetFunction]]
 764                         //   internal property.
 765                         // 2. If target has no [[Construct]] internal method, a
 766                         //   TypeError exception is thrown.
 767                         // 3. Let boundArgs be the value of F's [[BoundArgs]] internal
 768                         //   property.
 769                         // 4. Let args be a new list containing the same values as the
 770                         //   list boundArgs in the same order followed by the same
 771                         //   values as the list ExtraArgs in the same order.
 772                         // 5. Return the result of calling the [[Construct]] internal
 773                         //   method of target providing args as the arguments.
 774
 775                         var result = target.apply(
 776                                 this,
 777                                 array_concat.call(args, array_slice.call(arguments))
 778                         );
 779                         if ($Object(result) === result) {
 780                                 return result;
 781                         }
 782                         return this;
 783
 784                 } else {
 785                         // 15.3.4.5.1 [[Call]]
 786                         // When the [[Call]] internal method of a function object, F,
 787                         // which was created using the bind function is called with a
 788                         // this value and a list of arguments ExtraArgs, the following
 789                         // steps are taken:
 790                         // 1. Let boundArgs be the value of F's [[BoundArgs]] internal
 791                         //   property.
 792                         // 2. Let boundThis be the value of F's [[BoundThis]] internal
 793                         //   property.
 794                         // 3. Let target be the value of F's [[TargetFunction]] internal
 795                         //   property.
 796                         // 4. Let args be a new list containing the same values as the
 797                         //   list boundArgs in the same order followed by the same
 798                         //   values as the list ExtraArgs in the same order.
 799                         // 5. Return the result of calling the [[Call]] internal method
 800                         //   of target providing boundThis as the this value and
 801                         //   providing args as the arguments.
 802
 803                         // equiv: target.call(this, ...boundArgs, ...args)
 804                         return target.apply(
 805                                 that,
 806                                 array_concat.call(args, array_slice.call(arguments))
 807                         );
 808
 809                 }
 810
 811         };
 812
 813         // 15. If the [[Class]] internal property of Target is "Function", then
 814         //     a. Let L be the length property of Target minus the length of A.
 815         //     b. Set the length own property of F to either 0 or L, whichever is
 816         //       larger.
 817         // 16. Else set the length own property of F to 0.
 818
 819         var boundLength = max(0, target.length - args.length);
 820
 821         // 17. Set the attributes of the length own property of F to the values
 822         //   specified in 15.3.5.1.
 823         var boundArgs = [];
 824         for (var i = 0; i < boundLength; i++) {
 825                 array_push.call(boundArgs, '$' + i);
 826         }
 827
 828         // XXX Build a dynamic function with desired amount of arguments is the only
 829         // way to set the length property of a function.
 830         // In environments where Content Security Policies enabled (Chrome extensions,
 831         // for ex.) all use of eval or Function costructor throws an exception.
 832         // However in all of these environments Function.prototype.bind exists
 833         // and so this code will never be executed.
 834         bound = Function('binder', 'return function (' + boundArgs.join(',') + '){ return binder.apply(this, arguments); }')(binder);
 835
 836         if (target.prototype) {
 837                 Empty.prototype = target.prototype;
 838                 bound.prototype = new Empty();
 839                 // Clean up dangling references.
 840                 Empty.prototype = null;
 841         }
 842
 843         // TODO
 844         // 18. Set the [[Extensible]] internal property of F to true.
 845
 846         // TODO
 847         // 19. Let thrower be the [[ThrowTypeError]] function Object (13.2.3).
 848         // 20. Call the [[DefineOwnProperty]] internal method of F with
 849         //   arguments "caller", PropertyDescriptor {[[Get]]: thrower, [[Set]]:
 850         //   thrower, [[Enumerable]]: false, [[Configurable]]: false}, and
 851         //   false.
 852         // 21. Call the [[DefineOwnProperty]] internal method of F with
 853         //   arguments "arguments", PropertyDescriptor {[[Get]]: thrower,
 854         //   [[Set]]: thrower, [[Enumerable]]: false, [[Configurable]]: false},
 855         //   and false.
 856
 857         // TODO
 858         // NOTE Function objects created using Function.prototype.bind do not
 859         // have a prototype property or the [[Code]], [[FormalParameters]], and
 860         // [[Scope]] internal properties.
 861         // XXX can't delete prototype in pure-js.
 862
 863         // 22. Return F.
 864         return bound;
 865 });
 866
 867 }
 868
 869 if (!('getOwnPropertyDescriptor' in Object && typeof Object.getOwnPropertyDescriptor === 'function' && (function() {
 870     try {
 871         var object = {};
 872         object.test = 0;
 873         return Object.getOwnPropertyDescriptor(
 874             object,
 875             "test"
 876         ).value === 0;
 877     } catch (exception) {
 878         return false
 879     }
 880 }()))) {
 881
 882 // Object.getOwnPropertyDescriptor
 883 /* global CreateMethodProperty */
 884 (function () {
 885         var call = Function.prototype.call;
 886         var prototypeOfObject = Object.prototype;
 887         var owns = call.bind(prototypeOfObject.hasOwnProperty);
 888
 889         var lookupGetter;
 890         var lookupSetter;
 891         var supportsAccessors;
 892         if ((supportsAccessors = owns(prototypeOfObject, "__defineGetter__"))) {
 893             lookupGetter = call.bind(prototypeOfObject.__lookupGetter__);
 894             lookupSetter = call.bind(prototypeOfObject.__lookupSetter__);
 895         }
 896         function doesGetOwnPropertyDescriptorWork(object) {
 897             try {
 898                 object.sentinel = 0;
 899                 return Object.getOwnPropertyDescriptor(
 900                     object,
 901                     "sentinel"
 902                 ).value === 0;
 903             } catch (exception) {
 904                 // returns falsy
 905             }
 906         }
 907         // check whether getOwnPropertyDescriptor works if it's given. Otherwise,
 908         // shim partially.
 909         if (Object.defineProperty) {
 910             var getOwnPropertyDescriptorWorksOnObject =
 911                 doesGetOwnPropertyDescriptorWork({});
 912             var getOwnPropertyDescriptorWorksOnDom = typeof document == "undefined" ||
 913                 doesGetOwnPropertyDescriptorWork(document.createElement("div"));
 914             if (!getOwnPropertyDescriptorWorksOnDom ||
 915                 !getOwnPropertyDescriptorWorksOnObject
 916             ) {
 917                 var getOwnPropertyDescriptorFallback = Object.getOwnPropertyDescriptor;
 918             }
 919         }
 920
 921         if (!Object.getOwnPropertyDescriptor || getOwnPropertyDescriptorFallback) {
 922             var ERR_NON_OBJECT = "Object.getOwnPropertyDescriptor called on a non-object: ";
 923
 924             CreateMethodProperty(Object, 'getOwnPropertyDescriptor', function getOwnPropertyDescriptor(object, property) {
 925                 if ((typeof object != "object" && typeof object != "function") || object === null) {
 926                     throw new TypeError(ERR_NON_OBJECT + object);
 927                 }
 928
 929                 // make a valiant attempt to use the real getOwnPropertyDescriptor
 930                 // for I8's DOM elements.
 931                 if (getOwnPropertyDescriptorFallback) {
 932                     try {
 933                         return getOwnPropertyDescriptorFallback.call(Object, object, property);
 934                     } catch (exception) {
 935                         // try the shim if the real one doesn't work
 936                     }
 937                 }
 938
 939                 // If object does not owns property return undefined immediately.
 940                 if (!owns(object, property)) {
 941                     return;
 942                 }
 943
 944                 // If object has a property then it's for sure both `enumerable` and
 945                 // `configurable`.
 946                 var descriptor = { enumerable: true, configurable: true };
 947
 948                 // If JS engine supports accessor properties then property may be a
 949                 // getter or setter.
 950                 if (supportsAccessors) {
 951                     // Unfortunately `__lookupGetter__` will return a getter even
 952                     // if object has own non getter property along with a same named
 953                     // inherited getter. To avoid misbehavior we temporary remove
 954                     // `__proto__` so that `__lookupGetter__` will return getter only
 955                     // if it's owned by an object.
 956                     var prototype = object.__proto__;
 957                     object.__proto__ = prototypeOfObject;
 958
 959                     var getter = lookupGetter(object, property);
 960                     var setter = lookupSetter(object, property);
 961
 962                     // Once we have getter and setter we can put values back.
 963                     object.__proto__ = prototype;
 964
 965                     if (getter || setter) {
 966                         if (getter) {
 967                             descriptor.get = getter;
 968                         }
 969                         if (setter) {
 970                             descriptor.set = setter;
 971                         }
 972                         // If it was accessor property we're done and return here
 973                         // in order to avoid adding `value` to the descriptor.
 974                         return descriptor;
 975                     }
 976                 }
 977
 978                 // If we got this far we know that object has an own property that is
 979                 // not an accessor so we set it as a value and return descriptor.
 980                 descriptor.value = object[property];
 981                         descriptor.writable = true;
 982                 return descriptor;
 983             });
 984         }
 985 }());
 986
 987 }
 988
 989 if (!('defineProperties' in Object)) {
 990
 991 // Object.defineProperties
 992 /* global CreateMethodProperty, Get, ToObject, Type */
 993 // 19.1.2.3. Object.defineProperties ( O, Properties )
 994 CreateMethodProperty(Object, 'defineProperties', function defineProperties(O, Properties) {
 995         // 1. If Type(O) is not Object, throw a TypeError exception.
 996         if (Type(O) !== 'object') {
 997                 throw new TypeError('Object.defineProperties called on non-object');
 998         }
 999         // 2. Let props be ? ToObject(Properties).
1000         var props = ToObject(Properties);
1001         // 3. Let keys be ? props.[[OwnPropertyKeys]]().
1002         /*
1003                 Polyfill.io - This step in our polyfill is not complying with the specification.
1004                 [[OwnPropertyKeys]] is meant to return ALL keys, including non-enumerable and symbols.
1005                 TODO: When we have Reflect.ownKeys, use that instead as it is the userland equivalent of [[OwnPropertyKeys]].
1006         */
1007         var keys = Object.keys(props);
1008         // 4. Let descriptors be a new empty List.
1009         var descriptors = [];
1010         // 5. For each element nextKey of keys in List order, do
1011         for (var i = 0; i < keys.length; i++) {
1012                 var nextKey = keys[i];
1013                 // a. Let propDesc be ? props.[[GetOwnProperty]](nextKey).
1014                 var propDesc = Object.getOwnPropertyDescriptor(props, nextKey);
1015                 // b. If propDesc is not undefined and propDesc.[[Enumerable]] is true, then
1016                 if (propDesc !== undefined && propDesc.enumerable) {
1017                         // i. Let descObj be ? Get(props, nextKey).
1018                         var descObj = Get(props, nextKey);
1019                         // ii. Let desc be ? ToPropertyDescriptor(descObj).
1020                         // Polyfill.io - We skip this step because Object.defineProperty deals with it.
1021                         // TODO: Implement this step?
1022                         var desc = descObj;
1023                         // iii. Append the pair (a two element List) consisting of nextKey and desc to the end of descriptors.
1024                         descriptors.push([nextKey, desc]);
1025                 }
1026         }
1027         // 6. For each pair from descriptors in list order, do
1028         for (var i = 0; i < descriptors.length; i++){
1029                 // a. Let P be the first element of pair.
1030                 var P = descriptors[i][0];
1031                 // b. Let desc be the second element of pair.
1032                 var desc = descriptors[i][1];
1033                 // c. Perform ? DefinePropertyOrThrow(O, P, desc).
1034                 Object.defineProperty(O, P, desc);
1035         }
1036         // 7. Return O.
1037         return O;
1038 });
1039
1040 }
1041
1042 if (!('create' in Object)) {
1043
1044 // Object.create
1045 /* global CreateMethodProperty, Type */
1046 CreateMethodProperty(Object, 'create', function create(O, properties) {
1047         // 1. If Type(O) is neither Object nor Null, throw a TypeError exception.
1048         if (Type(O) !== 'object' && Type(O) !== 'null') {
1049                 throw new TypeError('Object prototype may only be an Object or null');
1050         }
1051         // 2. Let obj be ObjectCreate(O).
1052         var obj = new Function('e', 'function Object() {}Object.prototype=e;return new Object')(O);
1053
1054         obj.constructor.prototype = O;
1055
1056         // 3. If Properties is not undefined, then
1057         if (1 in arguments) {
1058                 // a. Return ? ObjectDefineProperties(obj, Properties).
1059                 return Object.defineProperties(obj, properties);
1060         }
1061
1062         return obj;
1063 });
1064
1065 }
1066
1067 if (!('getPrototypeOf' in Object)) {
1068
1069 // Object.getPrototypeOf
1070 /* global CreateMethodProperty */
1071 // Based on: https://github.com/es-shims/es5-shim/blob/master/es5-sham.js
1072
1073 // https://github.com/es-shims/es5-shim/issues#issue/2
1074 // http://ejohn.org/blog/objectgetprototypeof/
1075 // recommended by fschaefer on github
1076 //
1077 // sure, and webreflection says ^_^
1078 // ... this will nerever possibly return null
1079 // ... Opera Mini breaks here with infinite loops
1080 CreateMethodProperty(Object, 'getPrototypeOf', function getPrototypeOf(object) {
1081         if (object !== Object(object)) {
1082                 throw new TypeError('Object.getPrototypeOf called on non-object');
1083         }
1084         var proto = object.__proto__;
1085         if (proto || proto === null) {
1086                 return proto;
1087         } else if (typeof object.constructor == 'function' && object instanceof object.constructor) {
1088     return object.constructor.prototype;
1089   } else if (object instanceof Object) {
1090                 return Object.prototype;
1091         } else {
1092                 // Correctly return null for Objects created with `Object.create(null)`
1093                 // (shammed or native) or `{ __proto__: null}`.  Also returns null for
1094                 // cross-realm objects on browsers that lack `__proto__` support (like
1095                 // IE <11), but that's the best we can do.
1096                 return null;
1097         }
1098 });
1099
1100 }
1101
1102
1103 // _ESAbstract.OrdinaryCreateFromConstructor
1104 /* global GetPrototypeFromConstructor */
1105 // 9.1.13. OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] )
1106 function OrdinaryCreateFromConstructor(constructor, intrinsicDefaultProto) { // eslint-disable-line no-unused-vars
1107         var internalSlotsList = arguments[2] || {};
1108         // 1. Assert: intrinsicDefaultProto is a String value that is this specification's name of an intrinsic object.
1109         // The corresponding object must be an intrinsic that is intended to be used as the[[Prototype]] value of an object.
1110
1111         // 2. Let proto be ? GetPrototypeFromConstructor(constructor, intrinsicDefaultProto).
1112         var proto = GetPrototypeFromConstructor(constructor, intrinsicDefaultProto);
1113
1114         // 3. Return ObjectCreate(proto, internalSlotsList).
1115         // Polyfill.io - We do not pass internalSlotsList to Object.create because Object.create does not use the default ordinary object definitions specified in 9.1.
1116         var obj = Object.create(proto);
1117         for (var name in internalSlotsList) {
1118                 if (Object.prototype.hasOwnProperty.call(internalSlotsList, name)) {
1119                         Object.defineProperty(obj, name, {
1120                                 configurable: true,
1121                                 enumerable: false,
1122                                 writable: true,
1123                                 value: internalSlotsList[name]
1124                         });
1125                 }
1126         }
1127         return obj;
1128 }
1129
1130 // _ESAbstract.Construct
1131 /* global IsConstructor, OrdinaryCreateFromConstructor, Call */
1132 // 7.3.13. Construct ( F [ , argumentsList [ , newTarget ]] )
1133 function Construct(F /* [ , argumentsList [ , newTarget ]] */) { // eslint-disable-line no-unused-vars
1134         // 1. If newTarget is not present, set newTarget to F.
1135         var newTarget = arguments.length > 2 ? arguments[2] : F;
1136
1137         // 2. If argumentsList is not present, set argumentsList to a new empty List.
1138         var argumentsList = arguments.length > 1 ? arguments[1] : [];
1139
1140         // 3. Assert: IsConstructor(F) is true.
1141         if (!IsConstructor(F)) {
1142                 throw new TypeError('F must be a constructor.');
1143         }
1144
1145         // 4. Assert: IsConstructor(newTarget) is true.
1146         if (!IsConstructor(newTarget)) {
1147                 throw new TypeError('newTarget must be a constructor.');
1148         }
1149
1150         // 5. Return ? F.[[Construct]](argumentsList, newTarget).
1151         // Polyfill.io - If newTarget is the same as F, it is equivalent to new F(...argumentsList).
1152         if (newTarget === F) {
1153                 return new (Function.prototype.bind.apply(F, [null].concat(argumentsList)))();
1154         } else {
1155                 // Polyfill.io - This is mimicking section 9.2.2 step 5.a.
1156                 var obj = OrdinaryCreateFromConstructor(newTarget, Object.prototype);
1157                 return Call(F, obj, argumentsList);
1158         }
1159 }
1160
1161 // _ESAbstract.ArraySpeciesCreate
1162 /* global IsArray, ArrayCreate, Get, Type, IsConstructor, Construct */
1163 // 9.4.2.3. ArraySpeciesCreate ( originalArray, length )
1164 function ArraySpeciesCreate(originalArray, length) { // eslint-disable-line no-unused-vars
1165         // 1. Assert: length is an integer Number ≥ 0.
1166         // 2. If length is -0, set length to +0.
1167         if (1/length === -Infinity) {
1168                 length = 0;
1169         }
1170
1171         // 3. Let isArray be ? IsArray(originalArray).
1172         var isArray = IsArray(originalArray);
1173
1174         // 4. If isArray is false, return ? ArrayCreate(length).
1175         if (isArray === false) {
1176                 return ArrayCreate(length);
1177         }
1178
1179         // 5. Let C be ? Get(originalArray, "constructor").
1180         var C = Get(originalArray, 'constructor');
1181
1182         // Polyfill.io - We skip this section as not sure how to make a cross-realm normal Array, a same-realm Array.
1183         // 6. If IsConstructor(C) is true, then
1184         // if (IsConstructor(C)) {
1185                 // a. Let thisRealm be the current Realm Record.
1186                 // b. Let realmC be ? GetFunctionRealm(C).
1187                 // c. If thisRealm and realmC are not the same Realm Record, then
1188                         // i. If SameValue(C, realmC.[[Intrinsics]].[[%Array%]]) is true, set C to undefined.
1189         // }
1190         // 7. If Type(C) is Object, then
1191         if (Type(C) === 'object') {
1192                 // a. Set C to ? Get(C, @@species).
1193                 C = 'Symbol' in this && 'species' in this.Symbol ? Get(C, this.Symbol.species) : undefined;
1194                 // b. If C is null, set C to undefined.
1195                 if (C === null) {
1196                         C = undefined;
1197                 }
1198         }
1199         // 8. If C is undefined, return ? ArrayCreate(length).
1200         if (C === undefined) {
1201                 return ArrayCreate(length);
1202         }
1203         // 9. If IsConstructor(C) is false, throw a TypeError exception.
1204         if (!IsConstructor(C)) {
1205                 throw new TypeError('C must be a constructor');
1206         }
1207         // 10. Return ? Construct(C, « length »).
1208         return Construct(C, [length]);
1209 }
1210
1211 // _ESAbstract.CreateDataProperty
1212 // 7.3.4. CreateDataProperty ( O, P, V )
1213 // NOTE
1214 // This abstract operation creates a property whose attributes are set to the same defaults used for properties created by the ECMAScript language assignment operator.
1215 // Normally, the property will not already exist. If it does exist and is not configurable or if O is not extensible, [[DefineOwnProperty]] will return false.
1216 function CreateDataProperty(O, P, V) { // eslint-disable-line no-unused-vars
1217         // 1. Assert: Type(O) is Object.
1218         // 2. Assert: IsPropertyKey(P) is true.
1219         // 3. Let newDesc be the PropertyDescriptor{ [[Value]]: V, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true }.
1220         var newDesc = {
1221                 value: V,
1222                 writable: true,
1223                 enumerable: true,
1224                 configurable: true
1225         };
1226         // 4. Return ? O.[[DefineOwnProperty]](P, newDesc).
1227         try {
1228                 Object.defineProperty(O, P, newDesc);
1229                 return true;
1230         } catch (e) {
1231                 return false;
1232         }
1233 }
1234
1235 // _ESAbstract.CreateDataPropertyOrThrow
1236 /* global CreateDataProperty */
1237 // 7.3.6. CreateDataPropertyOrThrow ( O, P, V )
1238 function CreateDataPropertyOrThrow(O, P, V) { // eslint-disable-line no-unused-vars
1239         // 1. Assert: Type(O) is Object.
1240         // 2. Assert: IsPropertyKey(P) is true.
1241         // 3. Let success be ? CreateDataProperty(O, P, V).
1242         var success = CreateDataProperty(O, P, V);
1243         // 4. If success is false, throw a TypeError exception.
1244         if (!success) {
1245                 throw new TypeError('Cannot assign value `' + Object.prototype.toString.call(V) + '` to property `' + Object.prototype.toString.call(P) + '` on object `' + Object.prototype.toString.call(O) + '`');
1246         }
1247         // 5. Return success.
1248         return success;
1249 }
1250 if (!('filter' in Array.prototype)) {
1251
1252 // Array.prototype.filter
1253 /* global CreateMethodProperty, ToObject, ToLength, Get, IsCallable, ArraySpeciesCreate, ToString, HasProperty, ToBoolean, Call, CreateDataPropertyOrThrow */
1254 // 22.1.3.7. Array.prototype.filter ( callbackfn [ , thisArg ] )
1255 CreateMethodProperty(Array.prototype, 'filter', function filter(callbackfn /* [ , thisArg ] */) {
1256         // 1. Let O be ? ToObject(this value).
1257         var O = ToObject(this);
1258         // 2. Let len be ? ToLength(? Get(O, "length")).
1259         var len = ToLength(Get(O, "length"));
1260         // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
1261         if (IsCallable(callbackfn) === false) {
1262                 throw new TypeError(callbackfn + ' is not a function');
1263         }
1264         // 4. If thisArg is present, let T be thisArg; else let T be undefined.
1265         var T = arguments.length > 1 ? arguments[1] : undefined;
1266         // 5. Let A be ? ArraySpeciesCreate(O, 0).
1267         var A = ArraySpeciesCreate(O, 0);
1268         // 6. Let k be 0.
1269         var k = 0;
1270         // 7. Let to be 0.
1271         var to = 0;
1272         // 8. Repeat, while k < len
1273         while (k < len) {
1274                 // a. Let Pk be ! ToString(k).
1275                 var Pk = ToString(k);
1276                 // b. Let kPresent be ? HasProperty(O, Pk).
1277                 var kPresent = HasProperty(O, Pk);
1278                 // c. If kPresent is true, then
1279                 if (kPresent) {
1280                         // i. Let kValue be ? Get(O, Pk).
1281                         var kValue = Get(O, Pk);
1282                         // ii. Let selected be ToBoolean(? Call(callbackfn, T, « kValue, k, O »)).
1283                         var selected = ToBoolean(Call(callbackfn, T, [kValue, k, O]));
1284                         // iii. If selected is true, then
1285                         if (selected) {
1286                                 // 1. Perform ? CreateDataPropertyOrThrow(A, ! ToString(to), kValue)
1287                                 CreateDataPropertyOrThrow(A, ToString(to), kValue);
1288                                 // 2. Increase to by 1.
1289                                 to = to + 1;
1290                         }
1291
1292                 }
1293                 // d. Increase k by 1.
1294                 k = k + 1;
1295         }
1296         // 9. Return A.
1297         return A;
1298 });
1299
1300 }
1301
1302 if (!('forEach' in Array.prototype)) {
1303
1304 // Array.prototype.forEach
1305 /* global Call, CreateMethodProperty, Get, HasProperty, IsCallable, ToLength, ToObject, ToString */
1306 // 22.1.3.10. Array.prototype.forEach ( callbackfn [ , thisArg ] )
1307 CreateMethodProperty(Array.prototype, 'forEach', function forEach(callbackfn /* [ , thisArg ] */) {
1308         // 1. Let O be ? ToObject(this value).
1309         var O = ToObject(this);
1310         // Polyfill.io - If O is a String object, split it into an array in order to iterate correctly.
1311         // We will use arrayLike in place of O when we are iterating through the list.
1312         var arraylike = O instanceof String ? O.split('') : O;
1313         // 2. Let len be ? ToLength(? Get(O, "length")).
1314         var len = ToLength(Get(O, "length"));
1315         // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
1316         if (IsCallable(callbackfn) === false) {
1317                 throw new TypeError(callbackfn + ' is not a function');
1318         }
1319         // 4. If thisArg is present, let T be thisArg; else let T be undefined.
1320         var T = arguments.length > 1 ? arguments[1] : undefined;
1321         // 5. Let k be 0.
1322         var k = 0;
1323         // 6. Repeat, while k < len
1324         while (k < len) {
1325                 // a. Let Pk be ! ToString(k).
1326                 var Pk = ToString(k);
1327                 // b. Let kPresent be ? HasProperty(O, Pk).
1328                 var kPresent = HasProperty(arraylike, Pk);
1329                 // c. If kPresent is true, then
1330                 if (kPresent) {
1331                         // i. Let kValue be ? Get(O, Pk).
1332                         var kValue = Get(arraylike, Pk);
1333                         // ii. Perform ? Call(callbackfn, T, « kValue, k, O »).
1334                         Call(callbackfn, T, [kValue, k, O]);
1335                 }
1336                 // d. Increase k by 1.
1337                 k = k + 1;
1338         }
1339         // 7. Return undefined.
1340         return undefined;
1341 });
1342
1343 }
1344
1345 if (!('indexOf' in Array.prototype)) {
1346
1347 // Array.prototype.indexOf
1348 /* global CreateMethodProperty, Get, HasProperty, ToInteger, ToLength, ToObject, ToString */
1349 // 22.1.3.12. Array.prototype.indexOf ( searchElement [ , fromIndex ] )
1350 CreateMethodProperty(Array.prototype, 'indexOf', function indexOf(searchElement /* [ , fromIndex ] */) {
1351         // 1. Let O be ? ToObject(this value).
1352         var O = ToObject(this);
1353         // 2. Let len be ? ToLength(? Get(O, "length")).
1354         var len = ToLength(Get(O, "length"));
1355         // 3. If len is 0, return -1.
1356         if (len === 0) {
1357                 return -1;
1358         }
1359         // 4. Let n be ? ToInteger(fromIndex). (If fromIndex is undefined, this step produces the value 0.)
1360         var n = ToInteger(arguments[1]);
1361         // 5. If n ≥ len, return -1.
1362         if (n >= len) {
1363                 return -1;
1364         }
1365         // 6. If n ≥ 0, then
1366         if (n >= 0) {
1367                 // a. If n is -0, let k be +0; else let k be n.
1368                 var k = n === -0 ? 0 : n;
1369                 // 7. Else n < 0,
1370         } else {
1371                 // a. Let k be len + n.
1372                 var k = len + n;
1373                 // b. If k < 0, let k be 0.
1374                 if (k < 0) {
1375                         k = 0;
1376                 }
1377         }
1378         // 8. Repeat, while k < len
1379         while (k < len) {
1380                 // a. Let kPresent be ? HasProperty(O, ! ToString(k)).
1381                 var kPresent = HasProperty(O, ToString(k));
1382                 // b. If kPresent is true, then
1383                 if (kPresent) {
1384                         // i. Let elementK be ? Get(O, ! ToString(k)).
1385                         var elementK = Get(O, ToString(k));
1386                         // ii. Let same be the result of performing Strict Equality Comparison searchElement === elementK.
1387                         var same = searchElement === elementK;
1388                         // iii. If same is true, return k.
1389                         if (same) {
1390                                 return k;
1391                         }
1392                 }
1393                 // c. Increase k by 1.
1394                 k = k + 1;
1395         }
1396         // 9. Return -1.
1397         return -1;
1398 });
1399
1400 }
1401
1402 if (!('lastIndexOf' in Array.prototype)) {
1403
1404 // Array.prototype.lastIndexOf
1405 /* global CreateMethodProperty, Get, HasProperty, ToInteger, ToLength, ToObject, ToString */
1406 // 22.1.3.15. Array.prototype.lastIndexOf ( searchElement [ , fromIndex ] )
1407 CreateMethodProperty(Array.prototype, 'lastIndexOf', function lastIndexOf(searchElement /* [ , fromIndex ] */) {
1408         // 1. Let O be ? ToObject(this value).
1409         var O = ToObject(this);
1410         // 2. Let len be ? ToLength(? Get(O, "length")).
1411         var len = ToLength(Get(O, "length"));
1412         // 3. If len is 0, return -1.
1413         if (len === 0) {
1414                 return -1;
1415         }
1416         // 4. If fromIndex is present, let n be ? ToInteger(fromIndex); else let n be len-1.
1417         var n = arguments.length > 1 ? ToInteger(arguments[1]) : len - 1;
1418         // 5. If n ≥ 0, then
1419         if (n >= 0) {
1420                 // a. If n is -0, let k be +0; else let k be min(n, len - 1).
1421                 var k = n === -0 ? 0 : Math.min(n, len - 1);
1422                 // 6. Else n < 0,
1423         } else {
1424                 // a. Let k be len + n.
1425                 k = len + n;
1426         }
1427         // 7. Repeat, while k ≥ 0
1428         while (k >= 0) {
1429                 // a. Let kPresent be ? HasProperty(O, ! ToString(k)).
1430                 var kPresent = HasProperty(O, ToString(k));
1431                 // b. If kPresent is true, then
1432                 if (kPresent) {
1433                         // i. Let elementK be ? Get(O, ! ToString(k)).
1434                         var elementK = Get(O, ToString(k));
1435                         // ii. Let same be the result of performing Strict Equality Comparison searchElement === elementK.
1436                         var same = searchElement === elementK;
1437                         // iii. If same is true, return k.
1438                         if (same) {
1439                                 return k;
1440                         }
1441                 }
1442                 // c. Decrease k by 1.
1443                 k = k - 1;
1444         }
1445         // 9. Return -1.
1446         return -1;
1447 });
1448
1449 }
1450
1451 if (!('map' in Array.prototype)) {
1452
1453 // Array.prototype.map
1454 /* global ArraySpeciesCreate, Call, CreateDataPropertyOrThrow, CreateMethodProperty, Get, HasProperty, IsCallable, ToLength, ToObject, ToString */
1455 /* global CreateMethodProperty, ToObject, ToLength, Get, ArraySpeciesCreate, ToString, HasProperty, Call, CreateDataPropertyOrThrow */
1456 // 22.1.3.16. Array.prototype.map ( callbackfn [ , thisArg ] )
1457 CreateMethodProperty(Array.prototype, 'map', function map(callbackfn /* [ , thisArg ] */) {
1458         // 1. Let O be ? ToObject(this value).
1459         var O = ToObject(this);
1460         // 2. Let len be ? ToLength(? Get(O, "length")).
1461         var len = ToLength(Get(O, "length"));
1462         // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
1463         if (IsCallable(callbackfn) === false) {
1464                 throw new TypeError(callbackfn + ' is not a function');
1465         }
1466         // 4. If thisArg is present, let T be thisArg; else let T be undefined.
1467         var T = arguments.length > 1 ? arguments[1] : undefined;
1468         // 5. Let A be ? ArraySpeciesCreate(O, len).
1469         var A = ArraySpeciesCreate(O, len);
1470         // 6. Let k be 0.
1471         var k = 0;
1472         // 7. Repeat, while k < len
1473         while (k < len) {
1474                 // a. Let Pk be ! ToString(k).
1475                 var Pk = ToString(k);
1476                 // b. Let kPresent be ? HasProperty(O, Pk).
1477                 var kPresent = HasProperty(O, Pk);
1478                 // c. If kPresent is true, then
1479                 if (kPresent) {
1480                         // i. Let kValue be ? Get(O, Pk).
1481                         var kValue = Get(O, Pk);
1482                         // ii. Let mappedValue be ? Call(callbackfn, T, « kValue, k, O »).
1483                         var mappedValue = Call(callbackfn, T, [kValue, k, O]);
1484                         // iii. Perform ? CreateDataPropertyOrThrow(A, Pk, mappedValue).
1485                         CreateDataPropertyOrThrow(A, Pk, mappedValue);
1486                 }
1487                 // d. Increase k by 1.
1488                 k = k + 1;
1489         }
1490         // 8. Return A.
1491         return A;
1492 });
1493
1494 }
1495
1496 if (!('reduce' in Array.prototype)) {
1497
1498 // Array.prototype.reduce
1499 /* global Call, CreateMethodProperty, Get, HasProperty, IsCallable, ToLength, ToObject, ToString */
1500 // 22.1.3.19. Array.prototype.reduce ( callbackfn [ , initialValue ] )
1501 CreateMethodProperty(Array.prototype, 'reduce', function reduce(callbackfn /* [ , initialValue ] */) {
1502         // 1. Let O be ? ToObject(this value).
1503         var O = ToObject(this);
1504         // Polyfill.io - If O is a String object, split it into an array in order to iterate correctly.
1505         // We will use arrayLike in place of O when we are iterating through the list.
1506         var arraylike = O instanceof String ? O.split('') : O;
1507         // 2. Let len be ? ToLength(? Get(O, "length")).
1508         var len = ToLength(Get(arraylike, "length"));
1509         // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
1510         if (IsCallable(callbackfn) === false) {
1511                 throw new TypeError(callbackfn + ' is not a function');
1512         }
1513         // 4. If len is 0 and initialValue is not present, throw a TypeError exception.
1514         var initialValue = arguments.length > 1 ? arguments[1] : undefined;
1515         if (len === 0 && arguments.length < 2) {
1516                 throw new TypeError('Reduce of empty array with no initial value');
1517         }
1518         // 5. Let k be 0.
1519         var k = 0;
1520         // 6. Let accumulator be undefined.
1521         var accumulator = undefined;
1522         // 7. If initialValue is present, then
1523         if (arguments.length > 1) {
1524                 // a. Set accumulator to initialValue.
1525                 accumulator = initialValue;
1526                 // 8. Else initialValue is not present,
1527         } else {
1528                 // a. Let kPresent be false.
1529                 var kPresent = false;
1530                 // b. Repeat, while kPresent is false and k < len
1531                 while (kPresent === false && k < len) {
1532                         // i. Let Pk be ! ToString(k).
1533                         var Pk = ToString(k);
1534                         // ii. Let kPresent be ? HasProperty(O, Pk).
1535                         var kPresent = HasProperty(arraylike, Pk);
1536                         // iii. If kPresent is true, then
1537                         if (kPresent) {
1538                                 // 1. Set accumulator to ? Get(O, Pk).
1539                                 var accumulator = Get(arraylike, Pk);
1540                         }
1541                         // iv. Increase k by 1.
1542                         k = k + 1;
1543                 }
1544                 // c. If kPresent is false, throw a TypeError exception.
1545                 if (kPresent === false) {
1546                         throw new TypeError('Reduce of empty array with no initial value');
1547                 }
1548         }
1549         // 9. Repeat, while k < len
1550         while (k < len) {
1551                 // a. Let Pk be ! ToString(k).
1552                 var Pk = ToString(k);
1553                 // b. Let kPresent be ? HasProperty(O, Pk).
1554                 var kPresent = HasProperty(arraylike, Pk);
1555                 // c. If kPresent is true, then
1556                 if (kPresent) {
1557                         // i. Let kValue be ? Get(O, Pk).
1558                         var kValue = Get(arraylike, Pk);
1559                         // ii. Set accumulator to ? Call(callbackfn, undefined, « accumulator, kValue, k, O »).
1560                         accumulator = Call(callbackfn, undefined, [accumulator, kValue, k, O]);
1561                 }
1562                 // d. Increase k by 1.
1563                 k = k + 1;
1564         }
1565         // 10. Return accumulator.
1566         return accumulator;
1567 });
1568
1569 }
1570
1571 if (!('reduceRight' in Array.prototype)) {
1572
1573 // Array.prototype.reduceRight
1574 /* global Call, CreateMethodProperty, Get, HasProperty, IsCallable, ToLength, ToObject, ToString */
1575 // 22.1.3.20. Array.prototype.reduceRight ( callbackfn [ , initialValue ] )
1576 CreateMethodProperty(Array.prototype, 'reduceRight', function reduceRight(callbackfn /* [ , initialValue ] */) {
1577         // 1. Let O be ? ToObject(this value).
1578         var O = ToObject(this);
1579         // Polyfill.io - If O is a String object, split it into an array in order to iterate correctly.
1580         // We will use arrayLike in place of O when we are iterating through the list.
1581         var arraylike = O instanceof String ? O.split('') : O;
1582         // 2. Let len be ? ToLength(? Get(O, "length")).
1583         var len = ToLength(Get(arraylike, "length"));
1584         // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
1585         if (IsCallable(callbackfn) === false) {
1586                 throw new TypeError(callbackfn + ' is not a function');
1587         }
1588         // 4. If len is 0 and initialValue is not present, throw a TypeError exception.
1589         var initialValue = arguments.length > 1 ? arguments[1] : undefined;
1590         if (len === 0 && arguments.length < 2) {
1591                 throw new TypeError('Reduce of empty array with no initial value');
1592         }
1593         // 5. Let k be len-1.
1594         var k = len - 1;
1595         // 6. Let accumulator be undefined.
1596         var accumulator = undefined;
1597         // 7. If initialValue is present, then
1598         if (arguments.length > 1) {
1599                 // a. Set accumulator to initialValue.
1600                 accumulator = initialValue;
1601                 // 8.Else initialValue is not present,
1602         } else {
1603                 // a. Let kPresent be false.
1604                 var kPresent = false;
1605                 // b. Repeat, while kPresent is false and k ≥ 0
1606                 while (kPresent === false && k >= 0) {
1607                         // i. Let Pk be ! ToString(k).
1608                         var Pk = ToString(k);
1609                         // ii. Let kPresent be ? HasProperty(O, Pk).
1610                         var kPresent = HasProperty(arraylike, Pk);
1611                         // iii. If kPresent is true, then
1612                         if (kPresent) {
1613                                 // 1. Set accumulator to ? Get(O, Pk).
1614                                 accumulator = Get(arraylike, Pk);
1615                         }
1616                         // iv. Decrease k by 1.
1617                         k = k - 1;
1618                 }
1619                 // c. If kPresent is false, throw a TypeError exception.
1620                 if (kPresent === false) {
1621                         throw new TypeError('Reduce of empty array with no initial value');
1622                 }
1623         }
1624         // 9. Repeat, while k ≥ 0
1625         while (k >= 0) {
1626                 // a. Let Pk be ! ToString(k).
1627                 var Pk = ToString(k);
1628                 // b. Let kPresent be ? HasProperty(O, Pk).
1629                 var kPresent = HasProperty(arraylike, Pk);
1630                 // c. If kPresent is true, then
1631                 if (kPresent) {
1632                         // i. Let kValue be ? Get(O, Pk).
1633                         var kValue = Get(arraylike, Pk);
1634                         // ii. Set accumulator to ? Call(callbackfn, undefined, « accumulator, kValue, k, O »).
1635                         accumulator = Call(callbackfn, undefined, [accumulator, kValue, k, O]);
1636                 }
1637                 // d. Decrease k by 1.
1638                 k = k - 1;
1639         }
1640         // 10 Return accumulator.
1641         return accumulator;
1642 });
1643
1644 }
1645
1646 if (!('some' in Array.prototype)) {
1647
1648 // Array.prototype.some
1649 /* global Call, CreateMethodProperty, Get, HasProperty, IsCallable, ToBoolean, ToLength, ToObject, ToString */
1650 // 22.1.3.24. Array.prototype.some ( callbackfn [ , thisArg ] )
1651 CreateMethodProperty(Array.prototype, 'some', function some(callbackfn /* [ , thisArg ] */) {
1652         // 1. Let O be ? ToObject(this value).
1653         var O = ToObject(this);
1654         // 2. Let len be ? ToLength(? Get(O, "length")).
1655         var len = ToLength(Get(O, "length"));
1656         // 3. If IsCallable(callbackfn) is false, throw a TypeError exception.
1657         if (IsCallable(callbackfn) === false) {
1658                 throw new TypeError(callbackfn + ' is not a function');
1659         }
1660         // 4. If thisArg is present, let T be thisArg; else let T be undefined.
1661         var T = arguments.length > 1 ? arguments[1] : undefined;
1662         // 5. Let k be 0.
1663         var k = 0;
1664         // 6. Repeat, while k < len
1665         while (k < len) {
1666                 // a. Let Pk be ! ToString(k).
1667                 var Pk = ToString(k);
1668                 // b. Let kPresent be ? HasProperty(O, Pk).
1669                 var kPresent = HasProperty(O, Pk);
1670                 // c. If kPresent is true, then
1671                 if (kPresent) {
1672                         // i. Let kValue be ? Get(O, Pk).
1673                         var kValue = Get(O, Pk);
1674                         // ii. Let testResult be ToBoolean(? Call(callbackfn, T, « kValue, k, O »)).
1675                         var testResult = ToBoolean(Call(callbackfn, T, [kValue, k, O]));
1676                         // iii. If testResult is true, return true.
1677                         if (testResult) {
1678                                 return true;
1679                         }
1680                 }
1681                 // d. Increase k by 1.
1682                 k = k + 1;
1683         }
1684         // 7. Return false.
1685         return false;
1686 });
1687
1688 }
1689
1690 if (!('Date' in this && 'now' in this.Date && 'getTime' in this.Date.prototype)) {
1691
1692 // Date.now
1693 Date.now = function now() {
1694         return new Date().getTime();
1695 };
1696
1697 }
1698
1699 if (!('Date' in this && 'toISOString' in Date.prototype)) {
1700
1701 // Date.prototype.toISOString
1702 Date.prototype.toISOString = function toISOString() {
1703         var date = this;
1704
1705         function pad(str, len) {
1706                 var pad = "0000";
1707                 str = '' + str;
1708                 return pad.substr(0, len - str.length) + str;
1709         }
1710
1711         var y = date.getUTCFullYear(),
1712         m = pad(date.getUTCMonth() + 1, 2),
1713         d = pad(date.getUTCDate(), 2),
1714         h = pad(date.getUTCHours(), 2),
1715         i = pad(date.getUTCMinutes(), 2),
1716         s = pad(date.getUTCSeconds(), 2),
1717         ms = pad(date.getUTCMilliseconds(), 3);
1718
1719         return y +'-'+ m +'-'+ d + 'T' + h +':'+ i +':'+ s +'.'+ ms +'Z';
1720 };
1721
1722 }
1723
1724 if (!('freeze' in Object)) {
1725
1726 // Object.freeze
1727 /* global CreateMethodProperty */
1728 // 19.1.2.6. Object.freeze ( O )
1729 CreateMethodProperty(Object, 'freeze', function freeze(O) {
1730         // This feature cannot be implemented fully as a polyfill.
1731         // We choose to silently fail which allows "securable" code
1732         // to "gracefully" degrade to working but insecure code.
1733         return O;
1734 });
1735
1736 }
1737
1738 if (!('getOwnPropertyNames' in Object)) {
1739
1740 // Object.getOwnPropertyNames
1741 /* global CreateMethodProperty */
1742
1743 var toString = ({}).toString;
1744 var split = ''.split;
1745
1746 CreateMethodProperty(Object, 'getOwnPropertyNames', function getOwnPropertyNames(object) {
1747         var buffer = [];
1748         var key;
1749
1750         // Non-enumerable properties cannot be discovered but can be checked for by name.
1751         // Define those used internally by JS to allow an incomplete solution
1752         var commonProps = ['length', "name", "arguments", "caller", "prototype", "observe", "unobserve"];
1753
1754         if (typeof object === 'undefined' || object === null) {
1755                 throw new TypeError('Cannot convert undefined or null to object');
1756         }
1757
1758         // Polyfill.io fallback for non-array-like strings which exist in some ES3 user-agents (IE 8)
1759         object = toString.call(object) == '[object String]' ? split.call(object, '') : Object(object);
1760
1761         // Enumerable properties only
1762         for (key in object) {
1763                 if (Object.prototype.hasOwnProperty.call(object, key)) {
1764                         buffer.push(key);
1765                 }
1766         }
1767
1768         // Check for and add the common non-enumerable properties
1769         for (var i=0, s=commonProps.length; i<s; i++) {
1770                 if (commonProps[i] in object) buffer.push(commonProps[i]);
1771         }
1772
1773         return buffer;
1774 });
1775
1776 }
1777
1778
1779 // _ESAbstract.RequireObjectCoercible
1780 // 7.2.1. RequireObjectCoercible ( argument )
1781 // The abstract operation ToObject converts argument to a value of type Object according to Table 12:
1782 // Table 12: ToObject Conversions
1783 /*
1784 |----------------------------------------------------------------------------------------------------------------------------------------------------|
1785 | Argument Type | Result                                                                                                                             |
1786 |----------------------------------------------------------------------------------------------------------------------------------------------------|
1787 | Undefined     | Throw a TypeError exception.                                                                                                       |
1788 | Null          | Throw a TypeError exception.                                                                                                       |
1789 | Boolean       | Return argument.                                                                                                                   |
1790 | Number        | Return argument.                                                                                                                   |
1791 | String        | Return argument.                                                                                                                   |
1792 | Symbol        | Return argument.                                                                                                                   |
1793 | Object        | Return argument.                                                                                                                   |
1794 |----------------------------------------------------------------------------------------------------------------------------------------------------|
1795 */
1796 function RequireObjectCoercible(argument) { // eslint-disable-line no-unused-vars
1797         if (argument === null || argument === undefined) {
1798                 throw TypeError();
1799         }
1800   return argument;
1801 }
1802 if (!('trim' in String.prototype)) {
1803
1804 // String.prototype.trim
1805 /* global CreateMethodProperty, RequireObjectCoercible, ToString */
1806 // 21.1.3.27. String.prototype.trim ( )
1807 CreateMethodProperty(String.prototype, 'trim', function trim() {
1808         // 1. Let O be ? RequireObjectCoercible(this value).
1809         var O = RequireObjectCoercible(this);
1810         // 2. Let S be ? ToString(O).
1811         var S = ToString(O);
1812         // 3. Let T be the String value that is a copy of S with both leading and trailing white space removed. The definition of white space is the union of WhiteSpace and LineTerminator. When determining whether a Unicode code point is in Unicode general category “Space_Separator” (“Zs”), code unit sequences are interpreted as UTF-16 encoded code point sequences as specified in 6.1.4.
1813         var T = String.prototype.replace.call(S, /^[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+|[\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF]+$/g, '');
1814         // 4. Return T.
1815         return T;
1816 });
1817
1818 }
1819
1820 })
1821 .call('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});