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