src/js/polyfill.es6.js

   1 // From
   2 // https://raw.githubusercontent.com/inexorabletash/polyfill/a6bc6ced78160c994f76a909b6ff6bbbab3d43de/es6.js
   3 // Required for ethereumjs-utils.js when run in phantomjs-2.1.1
   4 // but is not required in any modern browsers.
   5 // For more information, see
   6 // https://www.bountysource.com/issues/38485709-error-rendering-plot-with-phantomjs
   7
   8 //----------------------------------------------------------------------
   9 //
  10 // ECMAScript 2015 Polyfills
  11 //
  12 //----------------------------------------------------------------------
  13
  14 (function (global) {
  15   "use strict";
  16
  17   // Set this to always override native implementations, for testing
  18   // the polyfill in browsers with partial/full ES2015 support.
  19   var OVERRIDE_NATIVE_FOR_TESTING = false;
  20
  21   var undefined = (void 0); // Paranoia
  22
  23   // Helpers
  24
  25   function strict(o) {
  26     return o === global ? undefined : o;
  27   }
  28
  29   function hook(o, p, f) {
  30     var op = o[p];
  31     console.assert(typeof op === 'function', 'Hooking a non-function');
  32     o[p] = function() {
  33       var o = strict(this);
  34       var r = f.apply(o, arguments);
  35       return r !== undefined ? r : op.apply(o, arguments);
  36     };
  37   }
  38
  39   function isSymbol(s) {
  40     return (typeof s === 'symbol') || ('Symbol' in global && s instanceof global.Symbol);
  41   }
  42
  43   function getPropertyDescriptor(target, name) {
  44     var desc = Object.getOwnPropertyDescriptor(target, name);
  45     var proto = Object.getPrototypeOf(target);
  46     while (!desc && proto) {
  47       desc = Object.getOwnPropertyDescriptor(proto, name);
  48       proto = Object.getPrototypeOf(proto);
  49     }
  50     return desc;
  51   }
  52
  53   var enqueue = (function(nativePromise, nativeSetImmediate) {
  54     if (nativePromise)
  55       return function(job) { nativePromise.resolve().then(function() { job(); }); };
  56     if (nativeSetImmediate)
  57       return function(job) { nativeSetImmediate(job); };
  58     return function(job) { setTimeout(job, 0); };
  59   }(global['Promise'], global['setImmediate']));
  60
  61   function define(o, p, v, override) {
  62     if (p in o && !override && !OVERRIDE_NATIVE_FOR_TESTING)
  63       return;
  64
  65     if (typeof v === 'function') {
  66       // Sanity check that functions are appropriately named (where possible)
  67       console.assert(isSymbol(p) || !('name' in v) || v.name === p || v.name === p + '_', 'Expected function name "' + p.toString() + '", was "' + v.name + '"');
  68       Object.defineProperty(o, p, {
  69         value: v,
  70         configurable: true,
  71         enumerable: false,
  72         writable: true
  73       });
  74     } else {
  75       Object.defineProperty(o, p, {
  76         value: v,
  77         configurable: false,
  78         enumerable: false,
  79         writable: false
  80       });
  81     }
  82   }
  83
  84   function set_internal(o, p, v) {
  85     Object.defineProperty(o, p, {
  86       value: v,
  87       configurable: false,
  88       enumerable: false,
  89       writable: true
  90     });
  91   }
  92
  93   // Snapshot intrinsic functions
  94   var $isNaN = global.isNaN,
  95       $parseInt = global.parseInt,
  96       $parseFloat = global.parseFloat;
  97
  98   var E = Math.E,
  99       LOG10E = Math.LOG10E,
 100       LOG2E = Math.LOG2E,
 101       abs = Math.abs,
 102       ceil = Math.ceil,
 103       exp = Math.exp,
 104       floor = Math.floor,
 105       log = Math.log,
 106       max = Math.max,
 107       min = Math.min,
 108       pow = Math.pow,
 109       random = Math.random,
 110       sqrt = Math.sqrt;
 111
 112   var orig_match = String.prototype.match,
 113       orig_replace = String.prototype.replace,
 114       orig_search = String.prototype.search,
 115       orig_split = String.prototype.split;
 116
 117   // These are used for implementing the polyfills, but not exported.
 118
 119   // Inspired by https://gist.github.com/1638059
 120   /** @constructor */
 121   function EphemeronTable() {
 122     var secretKey = ObjectCreate(null);
 123
 124     function conceal(o) {
 125       var oValueOf = o.valueOf, secrets = ObjectCreate(null);
 126       Object.defineProperty(o, 'valueOf', {
 127           value: (function(secretKey) {
 128             return function (k) {
 129               return (k === secretKey) ? secrets : oValueOf.apply(o, arguments);
 130             };
 131           }(secretKey)),
 132         configurable: true,
 133         writeable: true,
 134         enumerable: false
 135         });
 136       return secrets;
 137     }
 138
 139     function reveal(o) {
 140       var v = typeof o.valueOf === 'function' && o.valueOf(secretKey);
 141       return v === o ? null : v;
 142     }
 143
 144     return {
 145       clear: function() {
 146         secretKey = ObjectCreate(null);
 147       },
 148       remove: function(key) {
 149         var secrets = reveal(key);
 150         if (secrets && HasOwnProperty(secrets, 'value')) {
 151           delete secrets.value;
 152           return true;
 153         }
 154         return false;
 155       },
 156       get: function(key, defaultValue) {
 157         var secrets = reveal(key);
 158         return (secrets && HasOwnProperty(secrets, 'value')) ? secrets.value : defaultValue;
 159       },
 160       has: function(key) {
 161         var secrets = reveal(key);
 162         return Boolean(secrets && HasOwnProperty(secrets, 'value'));
 163       },
 164       set: function(key, value) {
 165         var secrets = reveal(key) || conceal(key);
 166         secrets.value = value;
 167       }
 168     };
 169   }
 170
 171   var empty = Object.create(null);
 172
 173   //----------------------------------------------------------------------
 174   //
 175   // ECMAScript 2015
 176   // http://www.ecma-international.org/ecma-262/6.0/
 177   //
 178   //----------------------------------------------------------------------
 179
 180   // ---------------------------------------
 181   // 19.4 Symbol Objects
 182   // ---------------------------------------
 183
 184   // NOTE: Symbols are defined here - out of spec order - since we need the
 185   // properties and prototype to be populated for other polyfills.
 186
 187   // NOTE: Not secure, nor is obj[$$symbol] hidden from Object.keys()
 188
 189   var symbolForKey;
 190   (function() {
 191     var secret = Object.create(null);
 192     var symbolMap = {};
 193     symbolForKey = function(k) {
 194       return symbolMap[k];
 195     };
 196
 197     var GlobalSymbolRegistry = [];
 198
 199     function unique(bits) {
 200       return Array(bits + 1).join('x').replace(/x/g, function() {
 201         return random() < 0.5 ? '\u200C' : '\u200D'; // JWNJ / ZWJ
 202       });
 203     }
 204
 205     // 19.4.1 The Symbol Constructor
 206     // 19.4.1.1 Symbol ( description=undefined )
 207     function Symbol(description) {
 208       if (!(this instanceof Symbol)) return new Symbol(description, secret);
 209       if (this instanceof Symbol && arguments[1] !== secret) throw TypeError();
 210
 211       var descString = description === undefined ? undefined : String(description);
 212
 213       set_internal(this, '[[SymbolData]]', unique(128));
 214       set_internal(this, '[[Description]]', descString);
 215
 216       symbolMap[this] = this;
 217       return this;
 218     }
 219
 220     if (!('Symbol' in global) || OVERRIDE_NATIVE_FOR_TESTING)
 221       global.Symbol = Symbol;
 222
 223     // 19.4.2 Properties of the Symbol Constructor
 224
 225     // 19.4.2.1 Symbol.for (key)
 226     define(Symbol, 'for', function for_(key) {
 227       var stringKey = String(key);
 228       for (var i = 0; i < GlobalSymbolRegistry.length; ++i) {
 229         var e = GlobalSymbolRegistry[i];
 230         if (SameValue(e['[[key]]'], stringKey)) return e['[[symbol]]'];
 231       }
 232       var newSymbol = Symbol(key);
 233       GlobalSymbolRegistry.push({'[[key]]': stringKey, '[[symbol]]': newSymbol});
 234       return newSymbol;
 235     });
 236
 237     // 19.4.2.2 Symbol.hasInstance
 238     // 19.4.2.3 Symbol.isConcatSpreadable
 239
 240     // 19.4.2.4 Symbol.iterator
 241     define(global.Symbol, 'iterator', global.Symbol('Symbol.iterator'));
 242
 243     // 19.4.2.5 Symbol.keyFor (sym)
 244     define(Symbol, 'keyFor', function keyFor(sym) {
 245       if (!(sym instanceof Symbol)) throw TypeError();
 246       for (var i = 0; i < GlobalSymbolRegistry.length; ++i) {
 247         var e = GlobalSymbolRegistry[i];
 248         if (SameValue(e['[[symbol]]'], sym)) return e['[[key]]'];
 249       }
 250       return undefined;
 251     });
 252
 253     // 19.4.2.6 Symbol.match
 254     define(global.Symbol, 'match', global.Symbol('Symbol.match'));
 255
 256     // 19.4.2.7 Symbol.prototype
 257
 258     // 19.4.2.8 Symbol.replace
 259     define(global.Symbol, 'replace', global.Symbol('Symbol.replace'));
 260
 261     // 19.4.2.9 Symbol.search
 262     define(global.Symbol, 'search', global.Symbol('Symbol.search'));
 263
 264     // 19.4.2.10 Symbol.species
 265
 266     // 19.4.2.11 Symbol.search
 267     define(global.Symbol, 'split', global.Symbol('Symbol.split'));
 268
 269     // 19.4.2.12 Symbol.toPrimitive
 270
 271     // 19.4.2.13 Symbol.toStringTag
 272     define(global.Symbol, 'toStringTag', global.Symbol('Symbol.toStringTag'));
 273
 274     // 19.4.2.14 Symbol.unscopables
 275
 276     // 19.4.3 Properties of the Symbol Prototype Object
 277     // 19.4.3.1 Symbol.prototype.constructor
 278
 279     // 19.4.3.2 Symbol.prototype.toString ( )
 280     Object.defineProperty(Symbol.prototype, 'toString', {
 281       value: function toString() {
 282         var s = strict(this);
 283         var desc = s['[[Description]]'];
 284         return 'Symbol(' + (desc === undefined ? '' : desc) + s['[[SymbolData]]'] + ')';
 285       },
 286       configurable: true, writeable: true, enumerable: false });
 287
 288     // 19.4.3.3 Symbol.prototype.valueOf ( )
 289     Object.defineProperty(Symbol.prototype, 'valueOf', {
 290       value: function valueOf() {
 291         // To prevent automatic string conversion:
 292         throw TypeError();
 293
 294         // Spec has approximately the following:
 295         //var s = strict(this);
 296         //if (Type(s) === 'symbol') return s;
 297         //if (Type(s) !== 'object') throw TypeError();
 298         //if (!('[[SymbolData]]' in s)) throw TypeError();
 299         //return s['[[SymbolData]]'];
 300       },
 301       configurable: true, writeable: true, enumerable: false });
 302
 303     // 19.4.3.4 Symbol.prototype [ @@toStringTag ]
 304     // (Done later to polyfill partial implementations)
 305
 306     // 19.4.4 Properties of Symbol Instances
 307   }());
 308
 309   console.assert(typeof global.Symbol() === 'symbol' || symbolForKey(String(global.Symbol('x'))));
 310
 311   // Defined here so that other prototypes can reference it
 312   // 25.1.2 The %IteratorPrototype% Object
 313   var $IteratorPrototype$ = {};
 314
 315   //----------------------------------------
 316   // 6 ECMAScript Data Types and Values
 317   //----------------------------------------
 318
 319   // 6.1 ECMAScript Language Types
 320
 321   // "Type(x)" is used as shorthand for "the type of x"...
 322   function Type(v) {
 323     switch (typeof v) {
 324     case 'undefined': return 'undefined';
 325     case 'boolean': return 'boolean';
 326     case 'number': return 'number';
 327     case 'string': return 'string';
 328     case 'symbol': return 'symbol';
 329     default:
 330       if (v === null) return 'null';
 331       if (v instanceof global.Symbol) return 'symbol';
 332       return 'object';
 333     }
 334   }
 335
 336   // 6.1.5.1 Well-Known Symbols
 337   var $$iterator = global.Symbol.iterator,
 338       $$match = global.Symbol.match,
 339       $$replace = global.Symbol.replace,
 340       $$search = global.Symbol.search,
 341       $$split = global.Symbol.split,
 342       $$toStringTag = global.Symbol.toStringTag;
 343
 344   //----------------------------------------
 345   // 7 Abstract Operations
 346   //----------------------------------------
 347
 348   //----------------------------------------
 349   // 7.1 Type Conversion
 350   //----------------------------------------
 351
 352   // 7.1.1 ToPrimitive ( input [, PreferredType] )
 353   // just use valueOf()
 354
 355   // 7.1.2 ToBoolean ( argument )
 356   // just use Boolean()
 357
 358   // 7.1.3 ToNumber ( argument )
 359   // just use Number()
 360
 361   // 7.1.4 ToInteger ( argument )
 362   function ToInteger(n) {
 363     n = Number(n);
 364     if ($isNaN(n)) return 0;
 365     if (n === 0 || n === Infinity || n === -Infinity) return n;
 366     return ((n < 0) ? -1 : 1) * floor(abs(n));
 367   }
 368
 369   // 7.1.5 ToInt32 ( argument )
 370   function ToInt32(v) { return v >> 0; }
 371
 372   // 7.1.6 ToUint32 ( argument )
 373   function ToUint32(v) { return v >>> 0; }
 374
 375   // 7.1.7 ToInt16 ( argument )
 376   function ToInt16(v) { return (v << 16) >> 16; }
 377
 378   // 7.1.8 ToUint16 ( argument )
 379   function ToUint16(v) { return v & 0xFFFF; }
 380
 381   // 7.1.9 ToInt8 ( argument )
 382   function ToInt8(v) { return (v << 24) >> 24; }
 383
 384   // 7.1.10 ToUint8 ( argument )
 385   function ToUint8(v) { return v & 0xFF; }
 386
 387   // 7.1.11 ToUint8Clamp ( argument )
 388   function ToUint8Clamp(argument) {
 389     var number = Number(argument);
 390     if ($isNaN(number)) return 0;
 391     if (number <= 0) return 0;
 392     if (number >= 255) return 255;
 393     var f = floor(number);
 394     if ((f + 0.5) < number) return f + 1;
 395     if (number < (f + 0.5)) return f;
 396     if (f % 2) return f + 1;
 397     return f;
 398   }
 399
 400   // 7.1.12 ToString ( argument )
 401   // just use String()
 402
 403   // 7.1.13 ToObject ( argument )
 404   function ToObject(v) {
 405     if (v === null || v === undefined) throw TypeError();
 406     return Object(v);
 407   }
 408
 409   // 7.1.14 ToPropertyKey ( argument )
 410   function ToPropertyKey(v) {
 411     return String(v);
 412   }
 413
 414   // 7.1.15 ToLength ( argument )
 415   function ToLength(v) {
 416     var len = ToInteger(v);
 417     if (len <= 0) return 0;
 418     if (len === Infinity) return 0x20000000000000 - 1; // 2^53-1
 419     return min(len, 0x20000000000000 - 1); // 2^53-1
 420   }
 421
 422   // 7.1.16 CanonicalNumericIndexString ( argument )
 423
 424   //----------------------------------------
 425   // 7.2 Testing and Comparison Operations
 426   //----------------------------------------
 427
 428   // 7.2.1 RequireObjectCoercible ( argument )
 429   // 7.2.2 IsArray ( argument )
 430
 431   // 7.2.3 IsCallable ( argument )
 432   function IsCallable(o) { return typeof o === 'function'; }
 433
 434   // 7.2.4 IsConstructor ( argument )
 435   function IsConstructor(o) {
 436     // Hacks for Safari 7 TypedArray XXXConstructor objects
 437     if (/Constructor/.test(Object.prototype.toString.call(o))) return true;
 438     if (/Function/.test(Object.prototype.toString.call(o))) return true;
 439     // TODO: Can this be improved on?
 440     return typeof o === 'function';
 441   }
 442
 443   // 7.2.5 IsExtensible (O)
 444   // 7.2.6 IsInteger ( argument )
 445
 446   // 7.2.7 IsPropertyKey ( argument )
 447   function IsPropertyKey(argument) {
 448     if (Type(argument) === 'string') return true;
 449     if (Type(argument) === 'symbol') return true;
 450     return false;
 451   }
 452
 453   // 7.2.8 IsRegExp ( argument )
 454   // 7.2.5 IsConstructor ( argument )
 455
 456   // 7.2.9 SameValue(x, y)
 457   function SameValue(x, y) {
 458     if (typeof x !== typeof y) return false;
 459     switch (typeof x) {
 460     case 'undefined':
 461       return true;
 462     case 'number':
 463       if (x !== x && y !== y) return true;
 464       if (x === 0 && y === 0) return 1/x === 1/y;
 465       return x === y;
 466     case 'boolean':
 467     case 'string':
 468     case 'object':
 469     default:
 470       return x === y;
 471     }
 472   }
 473
 474   // 7.2.10 SameValueZero(x, y)
 475   function SameValueZero(x, y) {
 476     if (typeof x !== typeof y) return false;
 477     switch (typeof x) {
 478     case 'undefined':
 479       return true;
 480     case 'number':
 481       if (x !== x && y !== y) return true;
 482       return x === y;
 483     case 'boolean':
 484     case 'string':
 485     case 'object':
 486     default:
 487       return x === y;
 488     }
 489   }
 490
 491   //----------------------------------------
 492   // 7.3 Operations on Objects
 493   //----------------------------------------
 494
 495   // 7.3.1 Get (O, P)
 496   // - just use o.p or o[p]
 497
 498   // 7.3.2 GetV (V, P)
 499   function GetV(v, p) {
 500     var o = ToObject(v);
 501     return o[p];
 502   }
 503
 504   // 7.3.3 Set (O, P, V, Throw)
 505   // - just use o.p = v or o[p] = v
 506
 507
 508
 509
 510   // 7.3.9 GetMethod (O, P)
 511   function GetMethod(o, p) {
 512     var func = GetV(o, p);
 513     if (func === undefined || func === null) return undefined;
 514     if (!IsCallable(func)) throw TypeError();
 515     return func;
 516   }
 517
 518   // 7.3.10 HasProperty (O, P)
 519   function HasProperty(o, p) {
 520     while (o) {
 521       if (Object.prototype.hasOwnProperty.call(o, p)) return true;
 522       if (Type(o) !== 'object') return false;
 523       o = Object.getPrototypeOf(o);
 524     }
 525     return false;
 526   }
 527
 528   // 7.3.11 HasOwnProperty (O, P)
 529   function HasOwnProperty(o, p) {
 530     return Object.prototype.hasOwnProperty.call(o, p);
 531   }
 532
 533   //----------------------------------------
 534   // 7.4 Operations on Iterator Objects
 535   //----------------------------------------
 536
 537   // 7.4.1 GetIterator ( obj, method )
 538   function GetIterator(obj, method) {
 539     if (arguments.length < 2)
 540       method = GetMethod(obj, $$iterator);
 541     var iterator = method.call(obj);
 542     if (Type(iterator) !== 'object') throw TypeError();
 543     return iterator;
 544   }
 545
 546   // 7.4.2 IteratorNext ( iterator, value )
 547   function IteratorNext(iterator, value) {
 548     if (arguments.length < 2)
 549       var result = iterator.next();
 550     else
 551       result = iterator.next(value);
 552     if (Type(result) !== 'object') throw TypeError();
 553     return result;
 554   }
 555
 556   // 7.4.3 IteratorComplete ( iterResult )
 557   function IteratorComplete(iterResult) {
 558     console.assert(Type(iterResult) === 'object');
 559     return Boolean(iterResult.done);
 560   }
 561
 562   // 7.4.4 IteratorValue ( iterResult )
 563   function IteratorValue(iterResult) {
 564     console.assert(Type(iterResult) === 'object');
 565     return iterResult.value;
 566   }
 567
 568   // 7.4.5 IteratorStep ( iterator )
 569   function IteratorStep( iterator, value ) {
 570     var result = IteratorNext(iterator, value);
 571     var done = result['done'];
 572     if (Boolean(done) === true) return false;
 573     return result;
 574   }
 575
 576   // 7.4.6 IteratorClose( iterator, completion )
 577   function IteratorClose( iterator, completion ) {
 578     console.assert(Type(iterator) === 'object');
 579     var _return = GetMethod(iterator, 'return');
 580     if (_return === undefined) return completion;
 581     try {
 582       var innerResult = _return[iterator]();
 583     } catch (result) {
 584       // TODO: If completion.[[type]] is throw, return completion
 585       return result;
 586     }
 587     if (Type(innerResult) !== 'object') throw TypeError();
 588     return completion;
 589   }
 590
 591   // 7.4.7 CreateIterResultObject (value, done)
 592   function CreateIterResultObject(value, done) {
 593     console.assert(Type(done) === 'boolean');
 594     var obj = {};
 595     obj["value"] = value;
 596     obj["done"] = done;
 597     return obj;
 598   }
 599
 600   // 7.4.8 CreateListIterator (list)
 601   // 7.4.8.1 ListIterator next( )
 602   // 7.4.9 CreateCompoundIterator ( iterator1, iterator2 )
 603   // 7.4.9.1 CompoundIterator next( )
 604
 605   //----------------------------------------
 606   // 8 Executable Code and Execution Contexts
 607   //----------------------------------------
 608
 609   //----------------------------------------
 610   // 8.4 Jobs and Job Queues
 611   //----------------------------------------
 612
 613   // 8.4.1 EnqueueJob ( queueName, job, arguments)
 614   function EnqueueJob(queueName, job, args) {
 615     var fn = function() { job.apply(undefined, args); };
 616     enqueue(fn);
 617   }
 618
 619   // 8.4.2 NextJob result
 620   function NextJob(result) {
 621     // no-op
 622   }
 623
 624   //----------------------------------------
 625   // 9 Ordinary and Exotic Objects Behaviors
 626   //----------------------------------------
 627
 628   // 9.1.11 [[Enumerate]] ()
 629   function Enumerate(obj) {
 630     var e = [];
 631     if (Object(obj) !== obj) return e;
 632     var visited = new Set;
 633     while (obj !== null) {
 634       Object.getOwnPropertyNames(obj).forEach(function(name) {
 635         if (!visited.has(name)) {
 636           var desc = Object.getOwnPropertyDescriptor(obj, name);
 637           if (desc) {
 638             visited.add(name);
 639             if (desc.enumerable) e.push(name);
 640           }
 641         }
 642       });
 643       obj = Object.getPrototypeOf(obj);
 644     }
 645     return e[$$iterator]();
 646   }
 647
 648   // 9.1.12 [[OwnPropertyKeys]] ( )
 649   function OwnPropertyKeys(o) {
 650     return Object.getOwnPropertyNames(o);
 651   }
 652
 653   // 9.1.13 ObjectCreate(proto, internalSlotsList)
 654   function ObjectCreate(proto, internalSlotsList) {
 655     return Object.create(proto, internalSlotsList);
 656   }
 657
 658   // ---------------------------------------
 659   // 19 Fundamental Objects
 660   // ---------------------------------------
 661
 662   // ---------------------------------------
 663   // 19.1 Object Objects
 664   // ---------------------------------------
 665
 666   // 19.1.1 The Object Constructor
 667   // 19.1.1.1 Object ( [ value ] )
 668   // 19.1.2 Properties of the Object Constructor
 669   // 19.1.2.1 Object.assign ( target, ...sources )
 670   define(
 671     Object, 'assign',
 672     function assign(target, /*...*/sources) {
 673       var to = ToObject(target);
 674       if (arguments.length < 2) return to;
 675
 676       var sourcesIndex = 1;
 677       while (sourcesIndex < arguments.length) {
 678         var nextSource = arguments[sourcesIndex++];
 679         if (nextSource === undefined || nextSource === null) {
 680           var keys = [];
 681         } else {
 682           var from = ToObject(nextSource);
 683           keys = OwnPropertyKeys(from);
 684         }
 685         for (var keysIndex = 0; keysIndex < keys.length; ++keysIndex) {
 686           var nextKey = keys[keysIndex];
 687           var desc = Object.getOwnPropertyDescriptor(from, nextKey);
 688           if (desc !== undefined && desc.enumerable) {
 689             var propValue = from[nextKey];
 690             to[nextKey] = propValue;
 691           }
 692         }
 693       }
 694       return to;
 695     });
 696
 697   // 19.1.2.2 Object.create ( O [ , Properties ] )
 698   // 19.1.2.3 Object.defineProperties ( O, Properties )
 699   // 19.1.2.4 Object.defineProperty ( O, P, Attributes )
 700   // 19.1.2.5 Object.freeze ( O )
 701   // 19.1.2.6 Object.getOwnPropertyDescriptor ( O, P )
 702
 703   (function() {
 704     var nativeSymbols = (typeof global.Symbol() === 'symbol'),
 705         $getOwnPropertyNames = Object.getOwnPropertyNames,
 706         $keys = Object.keys,
 707         $window_names = (typeof window === 'object' ? $getOwnPropertyNames(window) : []);
 708
 709     function isStringKey(k) { return !symbolForKey(k); }
 710
 711     // 19.1.2.7 Object.getOwnPropertyNames ( O )
 712     define(
 713       Object, 'getOwnPropertyNames',
 714       function getOwnPropertyNames(o) {
 715         if (Object.prototype.toString.call(o) === '[object Window]') {
 716           // Workaround for cross-realm calling by IE itself.
 717           // https://github.com/inexorabletash/polyfill/issues/96
 718           try {
 719             return $getOwnPropertyNames(o).filter(isStringKey);
 720           } catch (_) {
 721             return $window_names.slice();
 722           }
 723         }
 724         return $getOwnPropertyNames(o).filter(isStringKey);
 725       }, !nativeSymbols);
 726
 727     // 19.1.2.8 Object.getOwnPropertySymbols ( O )
 728     define(
 729       Object, 'getOwnPropertySymbols',
 730       function getOwnPropertySymbols(o) {
 731         return $getOwnPropertyNames(o).filter(symbolForKey).map(symbolForKey);
 732       }, !nativeSymbols);
 733
 734     // 19.1.2.14 Object.keys ( O )
 735     define(
 736       Object, 'keys',
 737       function keys(o) {
 738         return $keys(o).filter(isStringKey);
 739       }, !nativeSymbols);
 740   }());
 741
 742   // 19.1.2.9 Object.getPrototypeOf ( O )
 743   // 19.1.2.10 Object.is ( value1, value2 )
 744   define(
 745     Object, 'is',
 746     function is(value1, value2) {
 747       return SameValue(value1, value2);
 748     });
 749
 750   // 19.1.2.11 Object.isExtensible ( O )
 751   // 19.1.2.12 Object.isFrozen ( O )
 752   // 19.1.2.13 Object.isSealed ( O )
 753
 754   // 19.1.2.14 Object.keys ( O )
 755   // see above
 756
 757   // 19.1.2.15 Object.preventExtensions ( O )
 758   // 19.1.2.16 Object.prototype
 759   // 19.1.2.17 Object.seal ( O )
 760
 761   // 19.1.2.18 Object.setPrototypeOf ( O, proto )
 762   define(
 763     Object, 'setPrototypeOf',
 764     function setPrototypeOf(o, proto) {
 765       if (Type(o) !== 'object') throw TypeError();
 766       if (Type(proto) !== 'object' && Type(proto) !== 'null') throw TypeError();
 767       o.__proto__ = proto;
 768       return o;
 769     }
 770   );
 771
 772   // 19.1.3 Properties of the Object Prototype Object
 773   // 19.1.3.1 Object.prototype.constructor
 774   // 19.1.3.2 Object.prototype.hasOwnProperty ( V )
 775   // 19.1.3.3 Object.prototype.isPrototypeOf ( V )
 776   // 19.1.3.4 Object.prototype.propertyIsEnumerable ( V )
 777   // 19.1.3.5 Object.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )
 778   // 19.1.3.6 Object.prototype.toString ( )
 779   hook(Object.prototype, 'toString',
 780        function() {
 781          var o = strict(this);
 782          if (o === Object(o) && $$toStringTag in o) {
 783            return '[object ' + o[$$toStringTag] + ']';
 784          }
 785          return undefined;
 786        });
 787
 788   // 19.1.3.7 Object.prototype.valueOf ( )
 789   // 19.1.4 Properties of Object Instances
 790
 791   // ---------------------------------------
 792   // 19.2 Function Objects
 793   // ---------------------------------------
 794
 795   // 19.2.1 The Function Constructor
 796   // 19.2.1.1 Function ( p1, p2, … , pn, body )
 797   // 19.2.2 Properties of the Function Constructor
 798   // 19.2.2.1 Function.length
 799   // 19.2.2.2 Function.prototype
 800   // 19.2.3 Properties of the Function Prototype Object
 801   // 19.2.3.1 Function.prototype.apply ( thisArg, argArray )
 802   // 19.2.3.2 Function.prototype.bind ( thisArg , ...args)
 803   // 19.2.3.3 Function.prototype.call (thisArg , ...args)
 804   // 19.2.3.4 Function.prototype.constructor
 805   // 19.2.3.5 Function.prototype.toString ( )
 806   // 19.2.3.6 Function.prototype[@@hasInstance] ( V )
 807   // 19.2.4 Function Instances
 808   // 19.2.4.1 length
 809   // 19.2.4.2 name
 810   // 19.2.4.3 prototype
 811
 812   // (No polyfillable changes from ES5)
 813
 814   // ---------------------------------------
 815   // 19.3 Boolean Objects
 816   // ---------------------------------------
 817
 818   // 19.3.1 The Boolean Constructor
 819   // 19.3.1.1 Boolean ( value )
 820   // 19.3.2 Properties of the Boolean Constructor
 821   // 19.3.2.1 Boolean.prototype
 822   // 19.3.3 Properties of the Boolean Prototype Object
 823   // 19.3.3.1 Boolean.prototype.constructor
 824   // 19.3.3.2 Boolean.prototype.toString ( )
 825   // 19.3.3.3 Boolean.prototype.valueOf ( )
 826   // 19.3.4 Properties of Boolean Instances
 827
 828   // (No polyfillable changes from ES5)
 829
 830   // ---------------------------------------
 831   // 19.4 Symbol Objects
 832   // ---------------------------------------
 833
 834   // Moved earlier in this script, so that other polyfills can depend on them.
 835
 836   // 19.4.3.4 Symbol.prototype [ @@toStringTag ]
 837   define(global.Symbol.prototype, global.Symbol.toStringTag, 'Symbol');
 838
 839   // ---------------------------------------
 840   // 19.5 Error Objects
 841   // ---------------------------------------
 842
 843   // 19.5.1 The Error Constructor
 844   // 19.5.1.1 Error ( message )
 845   // 19.5.1.2 new Error( ...argumentsList )
 846   // 19.5.2 Properties of the Error Constructor
 847   // 19.5.2.1 Error.prototype
 848   // 19.5.3 Properties of the Error Prototype Object
 849   // 19.5.3.1 Error.prototype.constructor
 850   // 19.5.3.2 Error.prototype.message
 851   // 19.5.3.3 Error.prototype.name
 852   // 19.5.3.4 Error.prototype.toString ( )
 853   // 19.5.4 Properties of Error Instances
 854   // 19.5.5 Native Error Types Used in This Standard
 855   // 19.5.5.1 EvalError
 856   // 19.5.5.2 RangeError
 857   // 19.5.5.3 ReferenceError
 858   // 19.5.5.4 SyntaxError
 859   // 19.5.5.5 TypeError
 860   // 19.5.5.6 URIError
 861   // 19.5.6 NativeError Object Structure
 862   // 19.5.6.1 NativeError Constructors
 863   // 19.5.6.1.1 NativeError ( message )
 864   // 19.5.6.1.2 new NativeError ( ...argumentsList )
 865   // 19.5.6.2 Properties of the NativeError Constructors
 866   // 19.5.6.2.1 NativeError.prototype
 867   // 19.5.6.3 Properties of the NativeError Prototype Objects
 868   // 19.5.6.4 Properties of NativeError Instances
 869
 870   // (No polyfillable changes from ES5)
 871
 872   // ---------------------------------------
 873   // 20 Numbers and Dates
 874   // ---------------------------------------
 875
 876   // ---------------------------------------
 877   // 20.1 Number Objects
 878   // ---------------------------------------
 879
 880   // 20.1.1 The Number Constructor
 881   // 20.1.1.1 Number ( [ value ] )
 882   // 20.1.1.2 new Number ( ...argumentsList )
 883   // 20.1.2 Properties of the Number Constructor
 884
 885   // 20.1.2.1 Number.EPSILON
 886   define(
 887     Number, 'EPSILON',
 888     (function () {
 889       var next, result;
 890       for (next = 1; 1 + next !== 1; next = next / 2)
 891         result = next;
 892       return result;
 893     }()));
 894
 895   // 20.1.2.2 Number.isFinite ( number )
 896   define(
 897     Number, 'isFinite',
 898     function isFinite(number) {
 899       if (Type(number) !== 'number') return false;
 900       if (number !== number || number === +Infinity || number === -Infinity) return false;
 901       return true;
 902     });
 903
 904   // 20.1.2.3 Number.isInteger ( number )
 905   define(
 906     Number, 'isInteger',
 907     function isInteger(number) {
 908       if (Type(number) !== 'number') return false;
 909       if (number !== number || number === +Infinity || number === -Infinity) return false;
 910       var integer = ToInteger(number);
 911       if (integer !== number) return false;
 912       return true;
 913     });
 914
 915   // 20.1.2.4 Number.isNaN ( number )
 916   define(
 917     Number, 'isNaN',
 918     function isNaN(number) {
 919       if (Type(number) !== 'number') return false;
 920       if (number !== number) return true;
 921       return false;
 922     });
 923
 924   // 20.1.2.5 Number.isSafeInteger ( number )
 925   define(
 926     Number, 'isSafeInteger',
 927     function isSafeInteger(number) {
 928       if (Type(number) !== 'number') return false;
 929       if (number !== number || number === +Infinity || number === -Infinity) return false;
 930       var integer = ToInteger(number);
 931       if (integer !== number) return false;
 932       if (abs(integer) <= (0x20000000000000 - 1)) // 2^53-1
 933         return true;
 934       return false;
 935     });
 936
 937   // 20.1.2.6 Number.MAX_SAFE_INTEGER
 938   define(
 939     Number, 'MAX_SAFE_INTEGER',
 940     9007199254740991); // 2^53-1
 941
 942   // 20.1.2.7 Number.MAX_VALUE
 943
 944   // 20.1.2.8 Number.MIN_SAFE_INTEGER
 945   define(
 946     Number, 'MIN_SAFE_INTEGER',
 947     -9007199254740991); // -2^53+1
 948
 949   // 20.1.2.9 Number.MIN_VALUE
 950   // 20.1.2.10 Number.NaN
 951   // 20.1.2.11 Number.NEGATIVE_INFINITY
 952
 953   // 20.1.2.12 Number.parseFloat ( string )
 954   define(Number, 'parseFloat', $parseFloat);
 955
 956   // 20.1.2.13 Number.parseInt ( string, radix )
 957   define(Number, 'parseInt', $parseInt);
 958
 959   // 20.1.2.14 Number.POSITIVE_INFINITY
 960   // 20.1.2.15 Number.prototype
 961
 962   // 20.1.3 Properties of the Number Prototype Object
 963   // 20.1.3.1 Number.prototype.constructor
 964   // 20.1.3.2 Number.prototype.toExponential ( fractionDigits )
 965   // 20.1.3.3 Number.prototype.toFixed ( fractionDigits )
 966   // 20.1.3.4 Number.prototype.toLocaleString( [ reserved1 [ , reserved2 ] ])
 967   // 20.1.3.5 Number.prototype.toPrecision ( precision )
 968   // 20.1.3.6 Number.prototype.toString ( [ radix ] )
 969   // 20.1.3.7 Number.prototype.valueOf ( )
 970   // 20.1.4 Properties of Number Instances
 971
 972   // ---------------------------------------
 973   // 20.2 The Math Object
 974   // ---------------------------------------
 975
 976   // 20.2.1 Value Properties of the Math Object
 977   // 20.2.1.1 Math.E
 978   // 20.2.1.2 Math.LN10
 979   // 20.2.1.3 Math.LN2
 980   // 20.2.1.4 Math.LOG10E
 981   // 20.2.1.5 Math.LOG2E
 982   // 20.2.1.6 Math.PI
 983   // 20.2.1.7 Math.SQRT1_2
 984   // 20.2.1.8 Math.SQRT2
 985
 986   // 20.2.1.9 Math [ @@toStringTag ]
 987   define(Math, $$toStringTag, 'Math');
 988
 989   // 20.2.2 Function Properties of the Math Object
 990   // 20.2.2.1 Math.abs ( x )
 991   // 20.2.2.2 Math.acos ( x )
 992
 993   // 20.2.2.3 Math.acosh(x)
 994   define(
 995     Math, 'acosh',
 996     function acosh(x) {
 997       x = Number(x);
 998       return log(x + sqrt(x * x - 1));
 999     });
1000
1001   // 20.2.2.4 Math.asin ( x )
1002
1003   // 20.2.2.5 Math.asinh( x )
1004   define(
1005     Math, 'asinh',
1006     function asinh(x) {
1007       x = Number(x);
1008       if (SameValue(x, -0)) {
1009         return x;
1010       }
1011       var s = sqrt(x * x + 1);
1012       return (s === -x) ? log(0) : log(x + s);
1013     });
1014
1015   // 20.2.2.6 Math.atan ( x )
1016
1017   // 20.2.2.7 Math.atanh( x )
1018   define(
1019     Math, 'atanh',
1020     function atanh(x) {
1021       x = Number(x);
1022       return (x === 0) ? x : log((1 + x) / (1 - x)) / 2;
1023     });
1024
1025   // 20.2.2.8 Math.atan2 ( y, x )
1026
1027   // 20.2.2.9 Math.cbrt ( x )
1028   define(
1029     Math, 'cbrt',
1030     function cbrt(x) {
1031       x = Number(x);
1032       if ($isNaN(x/x)) {
1033         return x;
1034       }
1035       var r = pow(abs(x), 1/3);
1036       var t = x/r/r;
1037       return r + (r * (t-r) / (2*r + t));
1038     });
1039
1040   // 20.2.2.10 Math.ceil ( x )
1041
1042   // 20.2.2.11 Math.clz32 ( x )
1043   define(
1044     Math, 'clz32',
1045     function clz32(x) {
1046       function clz8(x) {
1047         return (x & 0xf0) ? (x & 0x80 ? 0 : x & 0x40 ? 1 : x & 0x20 ? 2 : 3) :
1048         (x & 0x08 ? 4 : x & 0x04 ? 5 : x & 0x02 ? 6 : x & 0x01 ? 7 : 8);
1049       }
1050       x = ToUint32(x);
1051       return x & 0xff000000 ? clz8(x >> 24) :
1052         x & 0xff0000 ? clz8(x >> 16) + 8 :
1053         x & 0xff00 ? clz8(x >> 8) + 16 : clz8(x) + 24;
1054     });
1055
1056
1057
1058   // 20.2.2.12 Math.cos ( x )
1059
1060   // 20.2.2.13 Math.cosh ( x )
1061   define(
1062     Math, 'cosh',
1063     function cosh(x) {
1064       x = Number(x);
1065       return (pow(E, x) + pow(E, -x)) / 2;
1066     });
1067
1068   // 20.2.2.14 Math.exp ( x )
1069
1070   // 20.2.2.15 Math.expm1 ( x )
1071   define(
1072     Math, 'expm1',
1073     function expm1(x) {
1074       x = Number(x);
1075       // from: http://www.johndcook.com/cpp_log1p.html
1076       if (SameValue(x, -0)) {
1077         return -0;
1078       } else if (abs(x) < 1e-5) {
1079         return x + 0.5 * x * x; // two terms of Taylor expansion
1080       } else {
1081         return exp(x) - 1;
1082       }
1083     });
1084
1085   // 20.2.2.16 Math.floor ( x )
1086
1087   // 20.2.2.17 Math.fround ( x )
1088   define(
1089     Math, 'fround',
1090     function fround(x) {
1091       if ($isNaN(x)) {
1092         return NaN;
1093       }
1094       if (1/x === +Infinity || 1/x === -Infinity || x === +Infinity || x === -Infinity) {
1095         return x;
1096       }
1097       return (new Float32Array([x]))[0];
1098     });
1099
1100   // 20.2.2.18 Math.hypot ( value1 [, value2 [ ... ] ] )
1101   define(
1102     Math, 'hypot',
1103     function hypot() {
1104       var values = [];
1105       var m = 0, sawNaN = false;
1106       for (var i = 0; i < arguments.length; ++i) {
1107         var n = abs(Number(arguments[i]));
1108         if (n === Infinity) return n;
1109         if (n !== n) sawNaN = true;
1110         if (n > m) m = n;
1111         values[i] = n;
1112       }
1113       if (sawNaN) return NaN;
1114       if (m === 0) return +0;
1115       var sum = +0;
1116       for (i = 0; i < values.length; ++i) {
1117         var r = values[i] / m;
1118         sum = sum + r * r;
1119       }
1120       return m * sqrt(sum);
1121     });
1122
1123   // 20.2.2.19 Math.imul ( x, y )
1124   define(
1125     Math, 'imul',
1126     function imul(x, y) {
1127       var a = ToUint32(x);
1128       var b = ToUint32(y);
1129       // (slow but accurate)
1130       var ah  = (a >>> 16) & 0xffff;
1131       var al = a & 0xffff;
1132       var bh  = (b >>> 16) & 0xffff;
1133       var bl = b & 0xffff;
1134       return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0)|0);
1135     }, ('imul' in Math && Math.imul(1, 0x80000000) === 0) // Safari 7 bug
1136   );
1137
1138   // 20.2.2.20 Math.log ( x )
1139
1140   // 20.2.2.21 Math.log1p ( x )
1141   define(
1142     Math, 'log1p',
1143     function log1p(x) {
1144       x = Number(x);
1145       // from: http://www.johndcook.com/cpp_expm1.html
1146       if (x < -1) {
1147         return NaN;
1148       } else if (SameValue(x, -0)) {
1149         return -0;
1150       } else if (abs(x) > 1e-4) {
1151         return log(1 + x);
1152       } else {
1153         return (-0.5 * x + 1) * x;
1154       }
1155     });
1156
1157   // 20.2.2.22 Math.log10 ( x )
1158   define(
1159     Math, 'log10',
1160     function log10(x) {
1161       x = Number(x);
1162       return log(x) * LOG10E;
1163     });
1164
1165   // 20.2.2.23 Math.log2 ( x )
1166   define(
1167     Math, 'log2',
1168     function log2(x) {
1169       x = Number(x);
1170       return log(x) * LOG2E;
1171     });
1172
1173   // 20.2.2.24 Math.max ( value1, value2 , ...values )
1174   // 20.2.2.25 Math.min ( value1, value2 , ...values )
1175   // 20.2.2.26 Math.pow ( x, y )
1176   // 20.2.2.27 Math.random ( )
1177   // 20.2.2.28 Math.round ( x )
1178
1179   // 20.2.2.29 Math.sign(x)
1180   define(
1181     Math, 'sign',
1182     function sign(x) {
1183       x = Number(x);
1184       return x < 0 ? -1 : x > 0 ? 1 : x;
1185     });
1186
1187   // 20.2.2.30 Math.sin ( x )
1188
1189   // 20.2.2.31 Math.sinh( x )
1190   define(
1191     Math, 'sinh',
1192     function sinh(x) {
1193       x = Number(x);
1194       return SameValue(x, -0) ? x : (pow(E, x) - pow(E, -x)) / 2;
1195     });
1196
1197   // 20.2.2.32 Math.sqrt ( x )
1198   // 20.2.2.33 Math.tan ( x )
1199
1200   // 20.2.2.34 Math.tanh ( x )
1201   define(
1202     Math, 'tanh',
1203     function tanh(x) {
1204       x = Number(x);
1205       var n = pow(E, 2 * x) - 1,
1206           d = pow(E, 2 * x) + 1;
1207       if (SameValue(x, -0))
1208         return x;
1209       return (n === d) ? 1 : n / d; // Handle Infinity/Infinity
1210     });
1211
1212   // 20.2.2.35 Math.trunc ( x )
1213   define(
1214     Math, 'trunc',
1215     function trunc(x) {
1216       x = Number(x);
1217       return $isNaN(x) ? NaN :
1218         x < 0 ? ceil(x) : floor(x);
1219     });
1220
1221   // ---------------------------------------
1222   // 20.3 Date Objects
1223   // ---------------------------------------
1224
1225   // 20.3.1 Overview of Date Objects and Definitions of Abstract Operations
1226   // 20.3.1.1 Time Values and Time Range
1227   // 20.3.1.2 Day Number and Time within Day
1228   // 20.3.1.3 Year Number
1229   // 20.3.1.4 Month Number
1230   // 20.3.1.5 Date Number
1231   // 20.3.1.6 Week Day
1232   // 20.3.1.7 Local Time Zone Adjustment
1233   // 20.3.1.8 Daylight Saving Time Adjustment
1234   // 20.3.1.9 Local Time
1235   // 20.3.1.10 Hours, Minutes, Second, and Milliseconds
1236   // 20.3.1.11 MakeTime (hour, min, sec, ms)
1237   // 20.3.1.12 MakeDay (year, month, date)
1238   // 20.3.1.13 MakeDate (day, time)
1239   // 20.3.1.14 TimeClip (time)
1240   // 20.3.1.15 Date Time String Format
1241   // 20.3.1.15.1 Extended years
1242   // 20.3.2 The Date Constructor
1243   // 20.3.2.1 Date ( year, month [, date [ , hours [ , minutes [ , seconds [ , ms ] ] ] ] ] )
1244   // 20.3.2.2 Date ( value )
1245   // 20.3.2.3 Date ( )
1246   // 20.3.3 Properties of the Date Constructor
1247   // 20.3.3.1 Date.now ( )
1248   // 20.3.3.2 Date.parse (string)
1249   // 20.3.3.3 Date.prototype
1250   // 20.3.3.4 Date.UTC ( year, month [ , date [ , hours [ , minutes [ , seconds [ , ms ] ] ] ] ] )
1251   // 20.3.4 Properties of the Date Prototype Object
1252   // 20.3.4.1 Date.prototype.constructor
1253   // 20.3.4.2 Date.prototype.getDate ( )
1254   // 20.3.4.3 Date.prototype.getDay ( )
1255   // 20.3.4.4 Date.prototype.getFullYear ( )
1256   // 20.3.4.5 Date.prototype.getHours ( )
1257   // 20.3.4.6 Date.prototype.getMilliseconds ( )
1258   // 20.3.4.7 Date.prototype.getMinutes ( )
1259   // 20.3.4.8 Date.prototype.getMonth ( )
1260   // 20.3.4.9 Date.prototype.getSeconds ( )
1261   // 20.3.4.10 Date.prototype.getTime ( )
1262   // 20.3.4.11 Date.prototype.getTimezoneOffset ( )
1263   // 20.3.4.12 Date.prototype.getUTCDate ( )
1264   // 20.3.4.13 Date.prototype.getUTCDay ( )
1265   // 20.3.4.14 Date.prototype.getUTCFullYear ( )
1266   // 20.3.4.15 Date.prototype.getUTCHours ( )
1267   // 20.3.4.16 Date.prototype.getUTCMilliseconds ( )
1268   // 20.3.4.17 Date.prototype.getUTCMinutes ( )
1269   // 20.3.4.18 Date.prototype.getUTCMonth ( )
1270   // 20.3.4.19 Date.prototype.getUTCSeconds ( )
1271   // 20.3.4.20 Date.prototype.setDate ( date )
1272   // 20.3.4.21 Date.prototype.setFullYear ( year [ , month [ , date ] ] )
1273   // 20.3.4.22 Date.prototype.setHours ( hour [ , min [ , sec [ , ms ] ] ] )
1274   // 20.3.4.23 Date.prototype.setMilliseconds ( ms )
1275   // 20.3.4.24 Date.prototype.setMinutes ( min [ , sec [ , ms ] ] )
1276   // 20.3.4.25 Date.prototype.setMonth ( month [ , date ] )
1277   // 20.3.4.26 Date.prototype.setSeconds ( sec [ , ms ] )
1278   // 20.3.4.27 Date.prototype.setTime ( time )
1279   // 20.3.4.28 Date.prototype.setUTCDate ( date )
1280   // 20.3.4.29 Date.prototype.setUTCFullYear ( year [ , month [ , date ] ] )
1281   // 20.3.4.30 Date.prototype.setUTCHours ( hour [ , min [ , sec [ , ms ] ] ] )
1282   // 20.3.4.31 Date.prototype.setUTCMilliseconds ( ms )
1283   // 20.3.4.32 Date.prototype.setUTCMinutes ( min [ , sec [, ms ] ] )
1284   // 20.3.4.33 Date.prototype.setUTCMonth ( month [ , date ] )
1285   // 20.3.4.34 Date.prototype.setUTCSeconds ( sec [ , ms ] )
1286   // 20.3.4.35 Date.prototype.toDateString ( )
1287   // 20.3.4.36 Date.prototype.toISOString ( )
1288   // 20.3.4.37 Date.prototype.toJSON ( key )
1289   // 20.3.4.38 Date.prototype.toLocaleDateString ( [ reserved1 [ , reserved2 ] ] )
1290   // 20.3.4.39 Date.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )
1291   // 20.3.4.40 Date.prototype.toLocaleTimeString ( [ reserved1 [ , reserved2 ] ] )
1292   // 20.3.4.41 Date.prototype.toString ( )
1293   // 20.3.4.42 Date.prototype.toTimeString ( )
1294   // 20.3.4.43 Date.prototype.toUTCString ( )
1295   // 20.3.4.44 Date.prototype.valueOf ( )
1296   // 20.3.4.45 Date.prototype [ @@toPrimitive ] ( hint )
1297   // 20.3.5 Properties of Date Instances
1298
1299   // (No polyfillable changes from ES5)
1300
1301   // ---------------------------------------
1302   // 21 Text Processing
1303   // ---------------------------------------
1304
1305   var string_regexp_dispatch = (function() {
1306     var faux = {}, secret = Symbol();
1307     faux[Symbol.match] = function() { return secret; };
1308     return ("").match(faux) === secret;
1309   }());
1310
1311   // 21.1 String Objects
1312   // 21.1.1 The String Constructor
1313   // 21.1.1.1 String ( value )
1314   // 21.1.2 Properties of the String Constructor
1315   // 21.1.2.1 String.fromCharCode ( ...codeUnits )
1316
1317   // 21.1.2.2 String.fromCodePoint ( ...codePoints )
1318   define(
1319     String, 'fromCodePoint',
1320     function fromCodePoint(/*...codePoints*/) {
1321       var codePoints = arguments,
1322           length = codePoints.length,
1323           elements = [],
1324           nextIndex = 0;
1325       while (nextIndex < length) {
1326         var next = codePoints[nextIndex];
1327         var nextCP = Number(next);
1328         if (!SameValue(nextCP, ToInteger(nextCP)) ||
1329             nextCP < 0 || nextCP > 0x10FFFF) {
1330           throw RangeError('Invalid code point ' + nextCP);
1331         }
1332         if (nextCP < 0x10000) {
1333           elements.push(String.fromCharCode(nextCP));
1334         } else {
1335           nextCP -= 0x10000;
1336           elements.push(String.fromCharCode((nextCP >> 10) + 0xD800));
1337           elements.push(String.fromCharCode((nextCP % 0x400) + 0xDC00));
1338         }
1339         nextIndex += 1;
1340       }
1341       return elements.join('');
1342     });
1343
1344   // 21.1.2.3 String.prototype
1345
1346   // 21.1.2.4 String.raw ( template , ...substitutions )
1347   define(
1348     String, 'raw',
1349     function raw(template /*, ...substitutions*/) {
1350       var substitutions = [].slice.call(arguments, 1);
1351
1352       var cooked = Object(template);
1353       var rawValue = cooked['raw'];
1354       var raw = Object(rawValue);
1355       var len = raw['length'];
1356       var literalSegments = ToLength(len);
1357       if (literalSegments <= 0) return '';
1358       var stringElements = [];
1359       var nextIndex = 0;
1360       while (true) {
1361         var next = raw[nextIndex];
1362         var nextSeg = String(next);
1363         stringElements.push(nextSeg);
1364         if (nextIndex + 1 === literalSegments)
1365           return stringElements.join('');
1366         next = substitutions[nextIndex];
1367         var nextSub = String(next);
1368         stringElements.push(nextSub);
1369         nextIndex = nextIndex + 1;
1370       }
1371     });
1372
1373   // See https://githib.com/inexorabletash/uate for a more useful version.
1374
1375   // 21.1.3 Properties of the String Prototype Object
1376   // 21.1.3.1 String.prototype.charAt ( pos )
1377   // 21.1.3.2 String.prototype.charCodeAt ( pos )
1378
1379   // 21.1.3.3 String.prototype.codePointAt ( pos )
1380   define(
1381     String.prototype, 'codePointAt',
1382     function codePointAt(pos) {
1383       var o = strict(this);
1384       var s = String(o);
1385       var position = ToInteger(pos);
1386       var size = s.length;
1387       if (position < 0 || position >= size) return undefined;
1388       var first = s.charCodeAt(position);
1389       if (first < 0xD800 || first > 0xDBFF || position + 1 === size) return first;
1390       var second = s.charCodeAt(position + 1);
1391       if (second < 0xDC00 || second > 0xDFFF) return first;
1392       return ((first - 0xD800) * 1024) + (second - 0xDC00) + 0x10000;
1393     });
1394
1395   // 21.1.3.4 String.prototype.concat ( ...args )
1396   // 21.1.3.5 String.prototype.constructor
1397
1398   // 21.1.3.6 String.prototype.endsWith ( searchString [ , endPosition] )
1399   define(
1400     String.prototype, 'endsWith',
1401     function endsWith(searchString) {
1402       var endPosition = arguments[1];
1403
1404       var o = strict(this);
1405       var s = String(o);
1406       var searchStr = String(searchString);
1407       var len = s.length;
1408       var pos = (endPosition === undefined) ? len : ToInteger(endPosition);
1409       var end = min(max(pos, 0), len);
1410       var searchLength = searchStr.length;
1411       var start = end - searchLength;
1412       if (start < 0) return false;
1413       if (s.substring(start, start + searchLength) === searchStr) return true;
1414       return false;
1415     });
1416
1417   // 21.1.3.7 String.prototype.includes ( searchString [ , position ] )
1418   define(
1419     String.prototype, 'includes',
1420     function includes(searchString) {
1421       var position = arguments[1];
1422
1423       var o = strict(this);
1424       var s = String(o);
1425       var searchStr = String(searchString);
1426       var pos = ToInteger(position);
1427       var len = s.length;
1428       var start = min(max(pos, 0), len);
1429       return s.indexOf(searchStr, start) !== -1;
1430     });
1431
1432   // 21.1.3.8 String.prototype.indexOf ( searchString [ , position ] )
1433   // 21.1.3.9 String.prototype.lastIndexOf ( searchString [ , position ] )
1434   // 21.1.3.10 String.prototype.localeCompare ( that [, reserved1 [ , reserved2 ] ] )
1435   // 21.1.3.11 String.prototype.match ( regexp )
1436   define(
1437     String.prototype, 'match',
1438     function match(regexp) {
1439       var o = strict(this);
1440       var s = String(o);
1441       if (HasProperty(regexp, $$match)) var rx = regexp;
1442       else rx = new RegExp(regexp);
1443       return rx[$$match](s);
1444     }, !string_regexp_dispatch);
1445
1446   // 21.1.3.12 String.prototype.normalize ( [ form ] )
1447
1448   // Not practical due to table sizes; if needed, pull in:
1449   // https://github.com/walling/unorm/
1450
1451   // 21.1.3.13 String.prototype.repeat ( count )
1452   define(
1453     String.prototype, 'repeat',
1454     function repeat(count) {
1455       var o = strict(this);
1456       var s = String(o);
1457       var n = ToInteger(count);
1458       if (n < 0) throw RangeError();
1459       if (n === Infinity) throw RangeError();
1460       var t = new Array(n + 1).join(s);
1461       return t;
1462     });
1463
1464   // 21.1.3.14 String.prototype.replace (searchValue, replaceValue )
1465   define(
1466     String.prototype, 'replace',
1467     function replace(searchValue, replaceValue) {
1468       var o = strict(this);
1469       if (HasProperty(searchValue, $$replace))
1470         return searchValue[$$replace](o, replaceValue);
1471       return orig_replace.call(o, searchValue, replaceValue);
1472     }, !string_regexp_dispatch);
1473
1474   // 21.1.3.15 String.prototype.search ( regexp )
1475   define(
1476     String.prototype, 'search',
1477     function search(regexp) {
1478       var o = strict(this);
1479       var string = String(o);
1480       if (HasProperty(regexp, $$search)) var rx = regexp;
1481       else rx = new RegExp(regexp);
1482       return rx[$$search](string);
1483     }, !string_regexp_dispatch);
1484
1485   // 21.1.3.16 String.prototype.slice ( start, end )
1486   // 21.1.3.17 String.prototype.split ( separator, limit )
1487   define(
1488     String.prototype, 'split',
1489     function split(separator, limit) {
1490       var o = strict(this);
1491       if (HasProperty(separator, $$split))
1492         return separator[$$split](o, limit);
1493       return orig_split.call(o, separator, limit);
1494     }, !string_regexp_dispatch);
1495
1496   // 21.1.3.18 String.prototype.startsWith ( searchString [, position ] )
1497   define(
1498     String.prototype, 'startsWith',
1499     function startsWith(searchString) {
1500       var position = arguments[1];
1501
1502       var o = strict(this);
1503       var s = String(o);
1504       var searchStr = String(searchString);
1505       var pos = ToInteger(position);
1506       var len = s.length;
1507       var start = min(max(pos, 0), len);
1508       var searchLength = searchStr.length;
1509       if (searchLength + start > len) return false;
1510       if (s.substring(start, start + searchLength) === searchStr) return true;
1511       return false;
1512     });
1513
1514   // 21.1.3.19 String.prototype.substring ( start, end )
1515   // 21.1.3.20 String.prototype.toLocaleLowerCase ( [ reserved1 [ , reserved2 ] ] )
1516   // 21.1.3.21 String.prototype.toLocaleUpperCase ([ reserved1 [ , reserved2 ] ] )
1517   // 21.1.3.22 String.prototype.toLowerCase ( )
1518   // 21.1.3.23 String.prototype.toString ( )
1519   // 21.1.3.24 String.prototype.toUpperCase ( )
1520   // 21.1.3.25 String.prototype.trim ( )
1521   // 21.1.3.26 String.prototype.valueOf ( )
1522
1523   // 21.1.3.27 String.prototype [ @@iterator ]( )
1524   define(
1525     String.prototype, $$iterator,
1526     function entries() {
1527       return CreateStringIterator(this, 'value');
1528     });
1529
1530   // 21.1.4 Properties of String Instances
1531   // 21.1.4.1 length
1532
1533   // 21.1.5 String Iterator Objects
1534   /** @constructor */
1535   function StringIterator() {}
1536
1537   // 21.1.5.1 CreateStringIterator Abstract Operation
1538   function CreateStringIterator(string, kind) {
1539     var s = String(string);
1540     var iterator = new StringIterator;
1541     set_internal(iterator, '[[IteratedString]]', s);
1542     set_internal(iterator, '[[StringIteratorNextIndex]]', 0);
1543     set_internal(iterator, '[[StringIterationKind]]', kind);
1544     return iterator;
1545   }
1546
1547   // 21.1.5.2 The %StringIteratorPrototype% Object
1548   var $StringIteratorPrototype$ = Object.create($IteratorPrototype$);
1549   StringIterator.prototype = $StringIteratorPrototype$;
1550
1551   // 21.1.5.2.1 %StringIteratorPrototype%.next ( )
1552   define(
1553     $StringIteratorPrototype$, 'next',
1554     function next() {
1555       var o = ToObject(this);
1556       var s = String(o['[[IteratedString]]']),
1557           index = o['[[StringIteratorNextIndex]]'],
1558           len = s.length;
1559       if (index >= len) {
1560         set_internal(o, '[[StringIteratorNextIndex]]', Infinity);
1561         return CreateIterResultObject(undefined, true);
1562       }
1563       var cp = s.codePointAt(index);
1564       set_internal(o, '[[StringIteratorNextIndex]]', index + (cp > 0xFFFF ? 2 : 1));
1565       return CreateIterResultObject(String.fromCodePoint(cp), false);
1566     });
1567
1568   // 21.1.5.2.2 %StringIteratorPrototype% [ @@toStringTag ]
1569   define($StringIteratorPrototype$, $$toStringTag, 'String Iterator');
1570
1571   // 21.1.5.3 Properties of String Iterator Instances
1572
1573   // ---------------------------------------
1574   // 21.2 RegExp (Regular Expression) Objects
1575   // ---------------------------------------
1576
1577   // 21.2.1 Patterns
1578   // 21.2.2 Pattern Semantics
1579   // 21.2.2.1 Notation
1580   // 21.2.2.2 Pattern
1581   // 21.2.2.3 Disjunction
1582   // 21.2.2.4 Alternative
1583   // 21.2.2.5 Term
1584   // 21.2.2.6 Assertion
1585   // 21.2.2.7 Quantifier
1586   // 21.2.2.8 Atom
1587   // 21.2.2.9 AtomEscape
1588   // 21.2.2.10 CharacterEscape
1589   // 21.2.2.11 DecimalEscape
1590   // 21.2.2.12 CharacterClassEscape
1591   // 21.2.2.13 CharacterClass
1592   // 21.2.2.14 ClassRanges
1593   // 21.2.2.15 NonemptyClassRanges
1594   // 21.2.2.16 NonemptyClassRangesNoDash
1595   // 21.2.2.17 ClassAtom
1596   // 21.2.2.18 ClassAtomNoDash
1597   // 21.2.2.19 ClassEscape
1598   // 21.2.3 The RegExp Constructor
1599   // 21.2.3.1 RegExp ( pattern, flags )
1600   // 21.2.3.2 new RegExp( ...argumentsList )
1601   // 21.2.3.3 Abstract Operations for the RegExp Constructor
1602   // 21.2.4 Properties of the RegExp Constructor
1603   // 21.2.4.1 RegExp.prototype
1604   // 21.2.5 Properties of the RegExp Prototype Object
1605   // 21.2.5.1 RegExp.prototype.constructor
1606   // 21.2.5.2 RegExp.prototype.exec ( string )
1607
1608   // 21.2.5.3 get RegExp.prototype.flags
1609   if (!('flags' in RegExp.prototype)) {
1610     Object.defineProperty(
1611       RegExp.prototype, 'flags', {
1612         get: function() {
1613           var s = String(this);
1614           return s.substring(s.lastIndexOf('/') + 1);
1615         }
1616       });
1617   }
1618
1619   // 21.2.5.4 get RegExp.prototype.global
1620   // 21.2.5.5 get RegExp.prototype.ignoreCase
1621
1622   // 21.2.5.6 RegExp.prototype [ @@match ] ( string )
1623   define(RegExp.prototype, $$match, function(string) {
1624     var o = strict(this);
1625     return orig_match.call(string, o);
1626   });
1627
1628   // 21.2.5.7 get RegExp.prototype.multiline
1629
1630   // 21.2.5.8 RegExp.prototype [ @@replace ] ( string, replaceValue )
1631   define(RegExp.prototype, $$replace, function(string, replaceValue) {
1632     var o = strict(this);
1633     return orig_replace.call(string, o, replaceValue);
1634   });
1635
1636   // 21.2.5.9 RegExp.prototype [ @@search ] ( string )
1637   define(RegExp.prototype, $$search, function(string) {
1638     var o = strict(this);
1639     return orig_search.call(string, o);
1640   });
1641
1642   // 21.2.5.10 get RegExp.prototype.source
1643
1644   // 21.2.5.11 RegExp.prototype [ @@split ] ( string, limit )
1645   define(RegExp.prototype, $$split, function(string, limit) {
1646     var o = strict(this);
1647     return orig_split.call(string, o, limit);
1648   });
1649
1650   // 21.2.5.12 get RegExp.prototype.sticky
1651   // 21.2.5.13 RegExp.prototype.test( S )
1652   // 21.2.5.14 RegExp.prototype.toString ( )
1653   // 21.2.5.15 get RegExp.prototype.unicode
1654
1655   // 21.2.6 Properties of RegExp Instances
1656   // 21.2.6.1 lastIndex
1657
1658   // (No polyfillable changes from ES5)
1659
1660   // ---------------------------------------
1661   // 22 Indexed Collections
1662   // ---------------------------------------
1663
1664   // ---------------------------------------
1665   // 22.1 Array Objects
1666   // ---------------------------------------
1667
1668   // 22.1.1 The Array Constructor
1669   // 22.1.1.1 Array ( )
1670   // 22.1.1.2 Array (len)
1671   // 22.1.1.3 Array (...items )
1672
1673   // 22.1.2 Properties of the Array Constructor
1674
1675   // 22.1.2.1 Array.from ( items [ , mapfn [ , thisArg ] ] )
1676   define(
1677     Array, 'from',
1678     function from(items) {
1679       var mapfn = arguments[1];
1680       var thisArg = arguments[2];
1681
1682       var c = strict(this);
1683       if (mapfn === undefined) {
1684         var mapping = false;
1685       } else {
1686         if (!IsCallable(mapfn)) throw TypeError();
1687         var t = thisArg;
1688         mapping = true;
1689       }
1690       var usingIterator = GetMethod(items, $$iterator);
1691       if (usingIterator !== undefined) {
1692          if (IsConstructor(c)) {
1693           var a = new c();
1694         } else {
1695           a = new Array(0);
1696         }
1697         var iterator = GetIterator(items, usingIterator);
1698         var k = 0;
1699         while (true) {
1700           var next = IteratorStep(iterator);
1701           if (next === false) {
1702             a.length = k;
1703             return a;
1704           }
1705           var nextValue = IteratorValue(next);
1706           if (mapping)
1707             var mappedValue = mapfn.call(t, nextValue);
1708           else
1709             mappedValue = nextValue;
1710           a[k] = mappedValue;
1711           k += 1;
1712         }
1713       }
1714       var arrayLike = ToObject(items);
1715       var lenValue = arrayLike.length;
1716       var len = ToLength(lenValue);
1717       if (IsConstructor(c)) {
1718         a = new c(len);
1719       } else {
1720         a = new Array(len);
1721       }
1722       k = 0;
1723       while (k < len) {
1724         var kValue = arrayLike[k];
1725         if (mapping)
1726           mappedValue = mapfn.call(t, kValue, k);
1727         else
1728           mappedValue = kValue;
1729         a[k] = mappedValue;
1730         k += 1;
1731       }
1732       a.length = len;
1733       return a;
1734     });
1735
1736   // 22.1.2.2 Array.isArray ( arg )
1737
1738   // 22.1.2.3 Array.of ( ...items )
1739   define(
1740     Array, 'of',
1741     function of() {
1742       var items = arguments;
1743
1744       var lenValue = items.length;
1745       var len = ToUint32(lenValue);
1746       var c = strict(this), a;
1747       if (IsConstructor(c)) {
1748         a = new c(len);
1749         a = ToObject(a);
1750       } else {
1751         a = new Array(len);
1752       }
1753       var k = 0;
1754       while (k < len) {
1755         a[k] = items[k];
1756         k += 1;
1757       }
1758       a.length = len;
1759       return a;
1760     });
1761
1762   // 22.1.2.4 Array.prototype
1763   // 22.1.2.5 get Array [ @@species ]
1764   // 22.1.3 Properties of the Array Prototype Object
1765   // 22.1.3.1 Array.prototype.concat ( ...arguments )
1766   // 22.1.3.1.1 Runtime Semantics: IsConcatSpreadable ( O )
1767   // 22.1.3.2 Array.prototype.constructor
1768   // 22.1.3.3 Array.prototype.copyWithin (target, start [ , end ] )
1769   define(
1770     Array.prototype, 'copyWithin',
1771     function copyWithin(target, start/*, end*/) {
1772       var end = arguments[2];
1773
1774       var o = ToObject(this);
1775       var lenVal = o.length;
1776       var len = ToLength(lenVal);
1777       len = max(len, 0);
1778       var relativeTarget = ToInteger(target);
1779       var to;
1780       if (relativeTarget < 0)
1781         to = max(len + relativeTarget, 0);
1782       else
1783         to = min(relativeTarget, len);
1784       var relativeStart = ToInteger(start);
1785       var from;
1786       if (relativeStart < 0)
1787         from = max(len + relativeStart, 0);
1788       else
1789         from = min(relativeStart, len);
1790       var relativeEnd;
1791       if (end === undefined)
1792         relativeEnd = len;
1793       else
1794         relativeEnd = ToInteger(end);
1795       var final;
1796       if (relativeEnd < 0)
1797         final = max(len + relativeEnd, 0);
1798       else
1799         final = min(relativeEnd, len);
1800       var count = min(final - from, len - to);
1801       var direction;
1802       if (from < to && to < from + count) {
1803         direction = -1;
1804         from = from + count - 1;
1805         to = to + count - 1;
1806       } else {
1807         direction = 1;
1808       }
1809       while (count > 0) {
1810         var fromKey = String(from);
1811         var toKey = String(to);
1812         var fromPresent = HasProperty(o, fromKey);
1813         if (fromPresent) {
1814           var fromVal = o[fromKey];
1815           o[toKey] = fromVal;
1816         } else {
1817           delete o[toKey];
1818         }
1819         from = from + direction;
1820         to = to + direction;
1821         count = count - 1;
1822       }
1823       return o;
1824     });
1825
1826   // 22.1.3.4 Array.prototype.entries ( )
1827   var nativeArrayIteratorMethods =
1828         ('entries' in Array.prototype && 'next' in [].entries());
1829
1830   define(
1831     Array.prototype, 'entries',
1832     function entries() {
1833       return CreateArrayIterator(this, 'key+value');
1834     }, !nativeArrayIteratorMethods);
1835
1836   // 22.1.3.5 Array.prototype.every ( callbackfn [ , thisArg] )
1837
1838   // 22.1.3.6 Array.prototype.fill (value [ , start [ , end ] ] )
1839   define(
1840     Array.prototype, 'fill',
1841     function fill(value/*, start, end*/) {
1842       var start = arguments[1],
1843           end = arguments[2];
1844
1845       var o = ToObject(this);
1846       var lenVal = o.length;
1847       var len = ToLength(lenVal);
1848       len = max(len, 0);
1849       var relativeStart = ToInteger(start);
1850       var k;
1851       if (relativeStart < 0)
1852         k = max((len + relativeStart), 0);
1853       else
1854         k = min(relativeStart, len);
1855       var relativeEnd;
1856       if (end === undefined)
1857         relativeEnd = len;
1858       else
1859         relativeEnd = ToInteger(end);
1860       var final;
1861       if (relativeEnd < 0)
1862         final = max((len + relativeEnd), 0);
1863       else
1864         final = min(relativeEnd, len);
1865       while (k < final) {
1866         var pk = String(k);
1867         o[pk] = value;
1868         k += 1;
1869       }
1870       return o;
1871     });
1872
1873   // 22.1.3.7 Array.prototype.filter ( callbackfn [ , thisArg ] )
1874
1875   // 22.1.3.8 Array.prototype.find ( predicate [ , thisArg ] )
1876   define(
1877     Array.prototype, 'find',
1878     function find(predicate) {
1879       var o = ToObject(this);
1880       var lenValue = o.length;
1881       var len = ToInteger(lenValue);
1882       if (!IsCallable(predicate)) throw TypeError();
1883       var t = arguments.length > 1 ? arguments[1] : undefined;
1884       var k = 0;
1885       while (k < len) {
1886         var pk = String(k);
1887         var kPresent = HasProperty(o, pk);
1888         if (kPresent) {
1889           var kValue = o[pk];
1890           var testResult = predicate.call(t, kValue, k, o);
1891           if (Boolean(testResult)) {
1892             return kValue;
1893           }
1894         }
1895         ++k;
1896       }
1897       return undefined;
1898     });
1899
1900   // 22.1.3.9 Array.prototype.findIndex ( predicate [ , thisArg ] )
1901   define(
1902     Array.prototype, 'findIndex',
1903     function findIndex(predicate) {
1904       var o = ToObject(this);
1905       var lenValue = o.length;
1906       var len = ToLength(lenValue);
1907       if (!IsCallable(predicate)) throw TypeError();
1908       var t = arguments.length > 1 ? arguments[1] : undefined;
1909       var k = 0;
1910       while (k < len) {
1911         var pk = String(k);
1912         var kPresent = HasProperty(o, pk);
1913         if (kPresent) {
1914           var kValue = o[pk];
1915           var testResult = predicate.call(t, kValue, k, o);
1916           if (Boolean(testResult)) {
1917             return k;
1918           }
1919         }
1920         ++k;
1921       }
1922       return -1;
1923     });
1924
1925   // 22.1.3.10 Array.prototype.forEach ( callbackfn [ , thisArg ] )
1926   // 22.1.3.11 Array.prototype.indexOf ( searchElement [ , fromIndex ] )
1927   // 22.1.3.12 Array.prototype.join (separator)
1928
1929   // 22.1.3.13 Array.prototype.keys ( )
1930   define(
1931     Array.prototype, 'keys',
1932     function keys() {
1933       return CreateArrayIterator(this, 'key');
1934     }, !nativeArrayIteratorMethods);
1935
1936   // 22.1.3.14 Array.prototype.lastIndexOf ( searchElement [ , fromIndex ] )
1937   // 22.1.3.15 Array.prototype.map ( callbackfn [ , thisArg ] )
1938   // 22.1.3.16 Array.prototype.pop ( )
1939   // 22.1.3.17 Array.prototype.push ( ...items )
1940   // 22.1.3.18 Array.prototype.reduce ( callbackfn [ , initialValue ] )
1941   // 22.1.3.19 Array.prototype.reduceRight ( callbackfn [ , initialValue ] )
1942   // 22.1.3.20 Array.prototype.reverse ( )
1943   // 22.1.3.21 Array.prototype.shift ( )
1944   // 22.1.3.22 Array.prototype.slice (start, end)
1945   // 22.1.3.23 Array.prototype.some ( callbackfn [ , thisArg ] )
1946   // 22.1.3.24 Array.prototype.sort (comparefn)
1947   // 22.1.3.25 Array.prototype.splice (start, deleteCount , ...items )
1948   // 22.1.3.26 Array.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] )
1949   // 22.1.3.27 Array.prototype.toString ( )
1950   // 22.1.3.28 Array.prototype.unshift ( ...items )
1951
1952   // 22.1.3.29 Array.prototype.values ( )
1953   define(
1954     Array.prototype, 'values',
1955     function values() {
1956       return CreateArrayIterator(this, 'value');
1957     }, !nativeArrayIteratorMethods);
1958
1959   // 22.1.3.30 Array.prototype [ @@iterator ] ( )
1960   define(
1961     Array.prototype, $$iterator,
1962     Array.prototype.values
1963     );
1964
1965   // 22.1.3.31 Array.prototype [ @@unscopables ]
1966   // 22.1.4 Properties of Array Instances
1967   // 22.1.4.1 length
1968
1969   // 22.1.5 Array Iterator Objects
1970   function ArrayIterator() {}
1971
1972   // 22.1.5.1 CreateArrayIterator Abstract Operation
1973   function CreateArrayIterator(array, kind) {
1974     var o = ToObject(array);
1975     var iterator = new ArrayIterator;
1976     set_internal(iterator, '[[IteratedObject]]', o);
1977     set_internal(iterator, '[[ArrayIteratorNextIndex]]', 0);
1978     set_internal(iterator, '[[ArrayIterationKind]]', kind);
1979     return iterator;
1980   }
1981
1982   // 22.1.5.2 The %ArrayIteratorPrototype% Object
1983   var $ArrayIteratorPrototype$ = Object.create($IteratorPrototype$);
1984   ArrayIterator.prototype = $ArrayIteratorPrototype$;
1985
1986   // 22.1.5.2.1 %ArrayIteratorPrototype%. next( )
1987   define(
1988     $ArrayIteratorPrototype$, 'next',
1989     function next() {
1990       var o = strict(this);
1991       if (Type(o) !== 'object') throw TypeError();
1992       var a = o['[[IteratedObject]]'],
1993           index = o['[[ArrayIteratorNextIndex]]'],
1994           itemKind = o['[[ArrayIterationKind]]'],
1995           lenValue = a.length,
1996           len = ToUint32(lenValue),
1997           elementKey,
1998           elementValue;
1999       if (itemKind.indexOf('sparse') !== -1) {
2000         var found = false;
2001         while (!found && index < len) {
2002           elementKey = String(index);
2003           found = HasProperty(a, elementKey);
2004           if (!found) {
2005             index += 1;
2006           }
2007         }
2008       }
2009       if (index >= len) {
2010         set_internal(o, '[[ArrayIteratorNextIndex]]', Infinity);
2011         return CreateIterResultObject(undefined, true);
2012       }
2013       elementKey = index;
2014       set_internal(o, '[[ArrayIteratorNextIndex]]', index + 1);
2015       if (itemKind.indexOf('value') !== -1)
2016         elementValue = a[elementKey];
2017       if (itemKind.indexOf('key+value') !== -1)
2018         return CreateIterResultObject([elementKey, elementValue], false);
2019       if (itemKind.indexOf('key') !== -1)
2020         return CreateIterResultObject(elementKey, false);
2021       if (itemKind === 'value')
2022         return CreateIterResultObject(elementValue, false);
2023       throw Error('Internal error');
2024     });
2025
2026   // 22.1.5.2.2 %ArrayIteratorPrototype% [ @@toStringTag ]
2027   define($ArrayIteratorPrototype$, $$toStringTag, 'Array Iterator');
2028
2029   // 22.1.5.3 Properties of Array Iterator Instances
2030
2031
2032   // ---------------------------------------
2033   // 22.2 TypedArray Objects
2034   // ---------------------------------------
2035
2036   // See typedarray.js for TypedArray polyfill
2037
2038   ['Int8Array', 'Uint8Array', 'Uint8ClampedArray',
2039    'Int16Array', 'Uint16Array',
2040    'Int32Array', 'Uint32Array',
2041    'Float32Array', 'Float64Array'].forEach(function ($TypedArrayName$) {
2042      if (!($TypedArrayName$ in global))
2043        return;
2044      var $TypedArray$ = global[$TypedArrayName$];
2045
2046      // 22.2.1 The %TypedArray% Intrinsic Object
2047      // 22.2.1.1 %TypedArray% ( length )
2048      // 22.2.1.2 %TypedArray% ( typedArray )
2049      // 22.2.1.3 %TypedArray% ( object )
2050      // 22.2.1.4 %TypedArray% ( buffer [ , byteOffset [ , length ] ] )
2051      // 22.2.1.5 %TypedArray% ( all other argument combinations )
2052      // 22.2.2 Properties of the %TypedArray% Intrinsic Object
2053
2054      // 22.2.2.1 %TypedArray%.from ( source [ , mapfn [ , thisArg ] ] )
2055      define(
2056        $TypedArray$, 'from',
2057        function from(source) {
2058          var mapfn = arguments[1];
2059          var thisArg = arguments[2];
2060
2061          var c = strict(this);
2062          if (!IsConstructor(c)) throw TypeError();
2063          if (mapfn === undefined) {
2064            var mapping = false;
2065          } else {
2066            if (IsCallable(mapfn)) throw TypeError();
2067            var t = thisArg;
2068            mapping = true;
2069          }
2070          var usingIterator = GetMethod(source, $$iterator);
2071          if (usingIterator !== undefined) {
2072            var iterator = GetIterator(source, usingIterator);
2073            var values = [];
2074            var next = true;
2075            while (next !== false) {
2076              next = IteratorStep(iterator);
2077              if (next !== false) {
2078                var nextValue = IteratorValue(next);
2079                values.push(nextValue);
2080              }
2081            }
2082            var len = values.length;
2083            var newObj = new c(len);
2084            var k = 0;
2085            while (k < len) {
2086              var kValue = values.shift();
2087              if (mapping) {
2088                var mappedValue = mapfn.call(t, kValue);
2089              } else {
2090                mappedValue = kValue;
2091              }
2092              newObj[k] = mappedValue;
2093              ++k;
2094            }
2095            console.assert(values.length === 0);
2096            return newObj;
2097          }
2098          var arrayLike = ToObject(source);
2099          var lenValue = arrayLike.length;
2100          len = ToLength(lenValue);
2101          newObj = new c(len);
2102          k = 0;
2103          while (k < len) {
2104            kValue = arrayLike[k];
2105            if (mapping) {
2106              mappedValue = mapfn.call(t, kValue, k);
2107            } else {
2108              mappedValue = kValue;
2109            }
2110            newObj[k] = mappedValue;
2111            ++k;
2112          }
2113          return newObj;
2114        });
2115
2116      // 22.2.2.2 %TypedArray%.of ( ...items )
2117      define(
2118        $TypedArray$, 'of',
2119        function of() {
2120          var items = arguments;
2121
2122          var len = items.length;
2123          var c = strict(this);
2124          var newObj = new c(len);
2125          var k = 0;
2126          while (k < len) {
2127            newObj[k] = items[k];
2128            ++k;
2129          }
2130          return newObj;
2131        });
2132
2133      // 22.2.2.3 %TypedArray%.prototype
2134      // 22.2.2.4 get %TypedArray% [ @@species ]
2135      // 22.2.3 Properties of the %TypedArrayPrototype% Object
2136      // 22.2.3.1 get %TypedArray%.prototype.buffer
2137      // 22.2.3.2 get %TypedArray%.prototype.byteLength
2138      // 22.2.3.3 get %TypedArray%.prototype.byteOffset
2139      // 22.2.3.4 %TypedArray%.prototype.constructor
2140
2141      // 22.2.3.5 %TypedArray%.prototype.copyWithin (target, start [, end ] )
2142      define($TypedArray$.prototype, 'copyWithin', Array.prototype.copyWithin);
2143
2144      // 22.2.3.6 %TypedArray%.prototype.entries ( )
2145      define($TypedArray$.prototype, 'entries', Array.prototype.entries);
2146
2147      // 22.2.3.7 %TypedArray%.prototype.every ( callbackfn [ , thisArg ] )
2148      define($TypedArray$.prototype, 'every', Array.prototype.every);
2149
2150      // 22.2.3.8 %TypedArray%.prototype.fill (value [ , start [ , end ] ] )
2151      define(
2152        $TypedArray$.prototype, 'fill',
2153        //Array.prototype.fill // Doesn't work in Safari 7
2154        function fill(value/*, start, end*/) {
2155          var start = arguments[1],
2156              end = arguments[2];
2157
2158          var o = ToObject(this);
2159          var lenVal = o.length;
2160          var len = ToLength(lenVal);
2161          len = max(len, 0);
2162          var relativeStart = ToInteger(start);
2163          var k;
2164          if (relativeStart < 0) k = max((len + relativeStart), 0);
2165          else k = min(relativeStart, len);
2166          var relativeEnd;
2167          if (end === undefined) relativeEnd = len;
2168          else relativeEnd = ToInteger(end);
2169          var final;
2170          if (relativeEnd < 0) final = max((len + relativeEnd), 0);
2171          else final = min(relativeEnd, len);
2172          while (k < final) {
2173            var pk = String(k);
2174            o[pk] = value;
2175            k += 1;
2176          }
2177          return o;
2178        });
2179
2180      // 22.2.3.9 %TypedArray%.prototype.filter ( callbackfn [ , thisArg ] )
2181      define(
2182        $TypedArray$.prototype, 'filter',
2183        function filter(callbackfn) {
2184          var thisArg = arguments[1];
2185
2186          var o = ToObject(this);
2187          var lenVal = o.length;
2188          var len = ToLength(lenVal);
2189          if (!IsCallable(callbackfn)) throw TypeError();
2190          var t = thisArg;
2191          var c = o.constructor;
2192          var kept = [];
2193          var k = 0;
2194          var captured = 0;
2195          while (k < len) {
2196            var kValue = o[k];
2197            var selected = callbackfn.call(t, kValue, k, o);
2198            if (selected) {
2199              kept.push(kValue);
2200              ++captured;
2201            }
2202            ++k;
2203          }
2204          var a = new c(captured);
2205          var n = 0;
2206          for (var i = 0; i < kept.length; ++i) {
2207            var e = kept[i];
2208            a[n] = e;
2209            ++n;
2210          }
2211          return a;
2212        });
2213
2214      // 22.2.3.10 %TypedArray%.prototype.find (predicate [ , thisArg ] )
2215      define($TypedArray$.prototype, 'find', Array.prototype.find);
2216
2217      // 22.2.3.11 %TypedArray%.prototype.findIndex ( predicate [ , thisArg ] )
2218      define($TypedArray$.prototype, 'findIndex', Array.prototype.findIndex);
2219
2220      // 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] )
2221      define($TypedArray$.prototype, 'forEach', Array.prototype.forEach);
2222
2223      // 22.2.3.13 %TypedArray%.prototype.indexOf (searchElement [ , fromIndex ] )
2224      define($TypedArray$.prototype, 'indexOf', Array.prototype.indexOf);
2225
2226      // 22.2.3.14 %TypedArray%.prototype.join ( separator )
2227      define($TypedArray$.prototype, 'join', Array.prototype.join);
2228
2229      // 22.2.3.15 %TypedArray%.prototype.keys ( )
2230      define($TypedArray$.prototype, 'keys', Array.prototype.keys);
2231
2232      // 22.2.3.16 %TypedArray%.prototype.lastIndexOf ( searchElement [ , fromIndex ] )
2233      define($TypedArray$.prototype, 'lastIndexOf', Array.prototype.lastIndexOf);
2234
2235      // 22.2.3.17 get %TypedArray%.prototype.length
2236
2237      // 22.2.3.18 %TypedArray%.prototype.map ( callbackfn [ , thisArg ] )
2238      define(
2239        $TypedArray$.prototype, 'map',
2240        function map(callbackfn) {
2241          var thisArg = arguments[1];
2242
2243          var o = ToObject(this);
2244          var lenValue = o.length;
2245          var len = ToLength(lenValue);
2246          if (!IsCallable(callbackfn)) throw TypeError();
2247          var t = thisArg;
2248          var a = undefined;
2249          var c = o.constructor;
2250          if (IsConstructor(c))
2251            a = new c(len);
2252          if (a === undefined)
2253            a = new Array(len);
2254          var k = 0;
2255          while (k < len) {
2256            var kPresent = HasProperty(o, k);
2257            if (kPresent) {
2258              var kValue = o[k];
2259              var mappedValue = callbackfn.call(t, kValue, k, o);
2260              a[k] = mappedValue;
2261            }
2262            ++k;
2263          }
2264          return a;
2265        });
2266
2267      // 22.2.3.19 %TypedArray%.prototype.reduce ( callbackfn [, initialValue] )
2268      define($TypedArray$.prototype, 'reduce', Array.prototype.reduce);
2269
2270      // 22.2.3.20 %TypedArray%.prototype.reduceRight ( callbackfn [, initialValue] )
2271      define($TypedArray$.prototype, 'reduceRight', Array.prototype.reduceRight);
2272
2273      // 22.2.3.21 %TypedArray%.prototype.reverse ( )
2274      define($TypedArray$.prototype, 'reverse', Array.prototype.reverse);
2275
2276      // 22.2.3.22 %TypedArray%.prototype.set ( overloaded [ , offset ])
2277      // 22.2.3.22.1 %TypedArray%.prototype.set (array [ , offset ] )
2278      // 22.2.3.22.2 %TypedArray%.prototype.set(typedArray [, offset ] )
2279
2280      // 22.2.3.23 %TypedArray%.prototype.slice ( start, end )
2281      define(
2282        $TypedArray$.prototype, 'slice',
2283        function slice(start, end) {
2284          var o = ToObject(this);
2285          var lenVal = o.length;
2286          var len = ToLength(lenVal);
2287          var relativeStart = ToInteger(start);
2288          var k = (relativeStart < 0) ? max(len + relativeStart, 0) : min(relativeStart, len);
2289          var relativeEnd = (end === undefined) ? len : ToInteger(end);
2290          var final = (relativeEnd < 0) ? max(len + relativeEnd, 0) : min(relativeEnd, len);
2291          var count = final - k;
2292          var c = o.constructor;
2293          if (IsConstructor(c)) {
2294            var a = new c(count);
2295          } else {
2296            throw TypeError();
2297          }
2298          var n = 0;
2299          while (k < final) {
2300            var kValue = o[k];
2301            a[n] = kValue;
2302            ++k;
2303            ++n;
2304          }
2305          return a;
2306        });
2307
2308      // 22.2.3.24 %TypedArray%.prototype.some ( callbackfn [ , thisArg ] )
2309      define($TypedArray$.prototype, 'some', Array.prototype.some);
2310
2311      // 22.2.3.25 %TypedArray%.prototype.sort ( comparefn )
2312      define(
2313        $TypedArray$.prototype, 'sort',
2314        function sort() {
2315          var comparefn = arguments[0];
2316
2317          function sortCompare(x, y) {
2318            console.assert(Type(x) === 'number' && Type(y) === 'number');
2319            if (x !== x && y !== y) return +0;
2320            if (x !== x) return 1;
2321            if (y !== y) return -1;
2322            if (comparefn !== undefined) {
2323              return comparefn(x, y);
2324            }
2325            if (x < y) return -1;
2326            if (x > y) return 1;
2327            return +0;
2328          }
2329          return Array.prototype.sort.call(this, sortCompare);
2330        });
2331
2332      // 22.2.3.26 %TypedArray%.prototype.subarray( [ begin [ , end ] ] )
2333      // 22.2.3.27 %TypedArray%.prototype.toLocaleString ([ reserved1 [ , reserved2 ] ])
2334      // 22.2.3.28 %TypedArray%.prototype.toString ( )
2335
2336      // 22.2.3.29 %TypedArray%.prototype.values ( )
2337      define($TypedArray$.prototype, 'values', Array.prototype.values);
2338
2339      // 22.2.3.30 %TypedArray%.prototype [ @@iterator ] ( )
2340      define(
2341        $TypedArray$.prototype, $$iterator,
2342        $TypedArray$.prototype.values
2343      );
2344
2345      // 22.2.3.31 get %TypedArray%.prototype [ @@toStringTag ]
2346      define($TypedArray$.prototype, $$toStringTag, $TypedArrayName$);
2347
2348      // 22.2.4 The TypedArray Constructors
2349      // 22.2.4.1TypedArray( ... argumentsList)
2350      // 22.2.5 Properties of the TypedArray Constructors
2351      // 22.2.5.1 TypedArray.BYTES_PER_ELEMENT
2352      // 22.2.5.2 TypedArray.prototype
2353      // 22.2.6 Properties of TypedArray Prototype Objects
2354      // 22.2.6.1 TypedArray.prototype.BYTES_PER_ELEMENT
2355      // 22.2.6.2 TypedArray.prototype.constructor
2356      // 22.2.7 Properties of TypedArray Instances
2357    });
2358
2359   // ---------------------------------------
2360   // 23 Keyed Collection
2361   // ---------------------------------------
2362
2363   // ---------------------------------------
2364   // 23.1 Map Objects
2365   // ---------------------------------------
2366
2367   (function() {
2368     // 23.1.1 The Map Constructor
2369
2370     // 23.1.1.1 Map ( [ iterable ] )
2371     /** @constructor */
2372     function Map(/*iterable*/) {
2373       var map = strict(this);
2374       var iterable = arguments[0];
2375
2376       if (Type(map) !== 'object') throw TypeError();
2377       if ('[[MapData]]' in map) throw TypeError();
2378
2379       if (iterable !== undefined) {
2380         var adder = map['set'];
2381         if (!IsCallable(adder)) throw TypeError();
2382         var iter = GetIterator(ToObject(iterable));
2383       }
2384       set_internal(map, '[[MapData]]', { keys: [], values: [] });
2385       if (iter === undefined) return map;
2386       while (true) {
2387         var next = IteratorStep(iter);
2388         if (next === false)
2389           return map;
2390         var nextItem = IteratorValue(next);
2391         if (Type(nextItem) !== 'object') throw TypeError();
2392         var k = nextItem[0];
2393         var v = nextItem[1];
2394         adder.call(map, k, v);
2395       }
2396
2397       return map;
2398     }
2399
2400     if (!('Map' in global) || OVERRIDE_NATIVE_FOR_TESTING ||
2401         (function() { try { new global.Map([]); return false; } catch (_) { return true; } }()) ||
2402         (function() { try { return !new global.Map().entries().next; } catch (_) { return true; } }()) ||
2403         (new global.Map([['a', 1]]).size !== 1))
2404       global.Map = Map;
2405
2406
2407     function MapDataIndexOf(mapData, key) {
2408       var i;
2409       if (key === key) return mapData.keys.indexOf(key);
2410       // Slow case for NaN
2411       for (i = 0; i < mapData.keys.length; i += 1)
2412         if (SameValueZero(mapData.keys[i], key)) return i;
2413       return -1;
2414     }
2415
2416     // 23.1.1.2 new Map ( ... argumentsList )
2417     // 23.1.2 Properties of the Map Constructor
2418     // 23.1.2.1 Map.prototype
2419     var $MapPrototype$ = {};
2420     Map.prototype = $MapPrototype$;
2421
2422     // 23.1.2.2 get Map [ @@species ]
2423
2424     // 23.1.3 Properties of the Map Prototype Object
2425     // 23.1.3.1 Map.prototype.clear ()
2426     define(
2427       Map.prototype, 'clear',
2428       function clear() {
2429         var m = strict(this);
2430         if (Type(m) !== 'object') throw TypeError();
2431         if (!('[[MapData]]' in m)) throw TypeError();
2432         if (m['[[MapData]]'] === undefined) throw TypeError();
2433         var entries = m['[[MapData]]'];
2434         entries.keys.length = 0;
2435         entries.values.length = 0;
2436         return undefined;
2437       });
2438
2439     // 23.1.3.2 Map.prototype.constructor
2440
2441     // 23.1.3.3 Map.prototype.delete ( key )
2442     define(
2443       Map.prototype, 'delete',
2444       function delete_(key) {
2445         var m = strict(this);
2446         if (Type(m) !== 'object') throw TypeError();
2447         if (!('[[MapData]]' in m)) throw TypeError();
2448         if (m['[[MapData]]'] === undefined) throw TypeError();
2449         var entries = m['[[MapData]]'];
2450         var i = MapDataIndexOf(entries, key);
2451         if (i < 0) return false;
2452         entries.keys[i] = empty;
2453         entries.values[i] = empty;
2454         return true;
2455       });
2456
2457     // 23.1.3.4 Map.prototype.entries ( )
2458     define(
2459       Map.prototype, 'entries',
2460       function entries() {
2461         var m = strict(this);
2462         if (Type(m) !== 'object') throw TypeError();
2463         return CreateMapIterator(m, 'key+value');
2464       });
2465
2466     // 23.1.3.5 Map.prototype.forEach ( callbackfn [ , thisArg ] )
2467     define(
2468       Map.prototype, 'forEach',
2469       function forEach(callbackfn /*, thisArg*/) {
2470         var thisArg = arguments[1];
2471
2472         var m = strict(this);
2473         if (Type(m) !== 'object') throw TypeError();
2474         if (!('[[MapData]]' in m)) throw TypeError();
2475         if (m['[[MapData]]'] === undefined) throw TypeError();
2476         var entries = m['[[MapData]]'];
2477
2478         if (!IsCallable(callbackfn)) {
2479           throw TypeError('First argument to forEach is not callable.');
2480         }
2481         for (var i = 0; i < entries.keys.length; ++i) {
2482           if (entries.keys[i] !== empty) {
2483             callbackfn.call(thisArg, entries.values[i], entries.keys[i], m);
2484           }
2485         }
2486         return undefined;
2487       });
2488
2489     // 23.1.3.6 Map.prototype.get ( key )
2490     define(
2491       Map.prototype, 'get',
2492       function get(key) {
2493         var m = strict(this);
2494         if (Type(m) !== 'object') throw TypeError();
2495         if (!('[[MapData]]' in m)) throw TypeError();
2496         if (m['[[MapData]]'] === undefined) throw TypeError();
2497         var entries = m['[[MapData]]'];
2498         var i = MapDataIndexOf(entries, key);
2499         if (i >= 0) return entries.values[i];
2500         return undefined;
2501       });
2502
2503     // 23.1.3.7 Map.prototype.has ( key )
2504     define(
2505       Map.prototype, 'has',
2506       function has(key) {
2507         var m = strict(this);
2508         if (Type(m) !== 'object') throw TypeError();
2509         if (!('[[MapData]]' in m)) throw TypeError();
2510         if (m['[[MapData]]'] === undefined) throw TypeError();
2511         var entries = m['[[MapData]]'];
2512         if (MapDataIndexOf(entries, key) >= 0) return true;
2513         return false;
2514       });
2515
2516     // 23.1.3.8 Map.prototype.keys ( )
2517     define(
2518       Map.prototype, 'keys',
2519       function keys() {
2520         var m = strict(this);
2521         if (Type(m) !== 'object') throw TypeError();
2522         return CreateMapIterator(m, 'key');
2523       });
2524
2525     // 23.1.3.9 Map.prototype.set ( key , value )
2526     define(
2527       Map.prototype, 'set',
2528       function set(key, value) {
2529         var m = strict(this);
2530         if (Type(m) !== 'object') throw TypeError();
2531         if (!('[[MapData]]' in m)) throw TypeError();
2532         if (m['[[MapData]]'] === undefined) throw TypeError();
2533         var entries = m['[[MapData]]'];
2534         var i = MapDataIndexOf(entries, key);
2535         if (i < 0) i = entries.keys.length;
2536         if (SameValue(key, -0)) key = 0;
2537         entries.keys[i] = key;
2538         entries.values[i] = value;
2539         return m;
2540       });
2541
2542     // 23.1.3.10 get Map.prototype.size
2543     Object.defineProperty(
2544       Map.prototype, 'size', {
2545         get: function() {
2546           var m = strict(this);
2547           if (Type(m) !== 'object') throw TypeError();
2548           if (!('[[MapData]]' in m)) throw TypeError();
2549           if (m['[[MapData]]'] === undefined) throw TypeError();
2550           var entries = m['[[MapData]]'];
2551           var count = 0;
2552           for (var i = 0; i < entries.keys.length; ++i) {
2553             if (entries.keys[i] !== empty)
2554               count = count + 1;
2555           }
2556           return count;
2557         }
2558       });
2559
2560     // 23.1.3.11 Map.prototype.values ( )
2561     define(
2562       Map.prototype, 'values',
2563       function values() {
2564         var m = strict(this);
2565         if (Type(m) !== 'object') throw TypeError();
2566         return CreateMapIterator(m, 'value');
2567       });
2568
2569     // 23.1.3.12 Map.prototype [ @@iterator ]( )
2570     define(
2571       Map.prototype, $$iterator,
2572       function() {
2573         var m = strict(this);
2574         if (Type(m) !== 'object') throw TypeError();
2575         return CreateMapIterator(m, 'key+value');
2576       });
2577
2578     // 23.1.3.13 Map.prototype [ @@toStringTag ]
2579     define(global.Map.prototype, $$toStringTag, 'Map');
2580
2581     // 23.1.4 Properties of Map Instances
2582     // 23.1.5 Map Iterator Objects
2583
2584     /** @constructor */
2585     function MapIterator() {}
2586
2587     // 23.1.5.1 CreateMapIterator Abstract Operation
2588     function CreateMapIterator(map, kind) {
2589       if (Type(map) !== 'object') throw TypeError();
2590       if (!('[[MapData]]' in map)) throw TypeError();
2591       if (map['[[MapData]]'] === undefined) throw TypeError();
2592       var iterator = new MapIterator;
2593       set_internal(iterator, '[[Map]]', map);
2594       set_internal(iterator, '[[MapNextIndex]]', 0);
2595       set_internal(iterator, '[[MapIterationKind]]', kind);
2596       return iterator;
2597     }
2598
2599     // 23.1.5.2 The %MapIteratorPrototype% Object
2600     var $MapIteratorPrototype$ = Object.create($IteratorPrototype$);
2601     MapIterator.prototype = $MapIteratorPrototype$;
2602
2603     // 23.1.5.2.1 %MapIteratorPrototype%.next ( )
2604     define(
2605       $MapIteratorPrototype$, 'next',
2606       function next() {
2607         var o = strict(this);
2608         if (Type(o) !== 'object') throw TypeError();
2609         var m = o['[[Map]]'],
2610             index = o['[[MapNextIndex]]'],
2611             itemKind = o['[[MapIterationKind]]'],
2612             entries = m['[[MapData]]'];
2613         while (index < entries.keys.length) {
2614           var e = {key: entries.keys[index], value: entries.values[index]};
2615           index = index += 1;
2616           set_internal(o, '[[MapNextIndex]]', index);
2617           if (e.key !== empty) {
2618             if (itemKind === 'key') {
2619               return CreateIterResultObject(e.key, false);
2620             } else if (itemKind === 'value') {
2621               return CreateIterResultObject(e.value, false);
2622             } else {
2623               return CreateIterResultObject([e.key, e.value], false);
2624             }
2625           }
2626         }
2627         return CreateIterResultObject(undefined, true);
2628       });
2629
2630     // 23.1.5.2.2 %MapIteratorPrototype% [ @@toStringTag ]
2631     define($MapIteratorPrototype$, $$toStringTag, 'Map Iterator');
2632
2633     // 23.1.5.3 Properties of Map Iterator Instances
2634   }());
2635
2636   // ---------------------------------------
2637   // 23.2 Set Objects
2638   // ---------------------------------------
2639
2640   (function() {
2641     // 23.2.1 The Set Constructor
2642     // 23.2.1.1 Set ( [ iterable ] )
2643
2644     /** @constructor */
2645     function Set(/*iterable*/) {
2646       var set = strict(this);
2647       var iterable = arguments[0];
2648
2649       if (Type(set) !== 'object') throw TypeError();
2650       if ('[[SetData]]' in set) throw TypeError();
2651
2652       if (iterable !== undefined) {
2653         var adder = set['add'];
2654         if (!IsCallable(adder)) throw TypeError();
2655         var iter = GetIterator(ToObject(iterable));
2656       }
2657       set_internal(set, '[[SetData]]', []);
2658       if (iter === undefined) return set;
2659       while (true) {
2660         var next = IteratorStep(iter);
2661         if (next === false)
2662           return set;
2663         var nextValue = IteratorValue(next);
2664         adder.call(set, nextValue);
2665       }
2666
2667       return set;
2668     }
2669
2670     if (!('Set' in global) || OVERRIDE_NATIVE_FOR_TESTING ||
2671         (function() { try { return !new global.Set().entries().next; } catch (_) { return true; } }()) ||
2672         (new global.Set([1]).size !== 1))
2673       global.Set = Set;
2674
2675     function SetDataIndexOf(setData, key) {
2676       var i;
2677       if (key === key)
2678         return setData.indexOf(key);
2679       // Slow case for NaN
2680       for (i = 0; i < setData.length; i += 1)
2681         if (SameValueZero(setData[i], key)) return i;
2682       return -1;
2683     }
2684
2685     // 23.2.1.2 new Set ( ...argumentsList )
2686     // 23.2.2 Properties of the Set Constructor
2687
2688     // 23.2.2.1 Set.prototype
2689     var $SetPrototype$ =  {};
2690     Set.prototype = $SetPrototype$;
2691
2692     // 23.2.2.2 get Set [ @@species ]
2693     // 23.2.3 Properties of the Set Prototype Object
2694
2695     // 23.2.3.1 Set.prototype.add (value )
2696     define(
2697       Set.prototype, 'add',
2698       function add(value) {
2699         var s = strict(this);
2700         if (Type(s) !== 'object') throw TypeError();
2701         if (!('[[SetData]]' in s)) throw TypeError();
2702         if (s['[[SetData]]'] === undefined) throw TypeError();
2703         if (SameValue(value, -0)) value = 0;
2704         var entries = s['[[SetData]]'];
2705         var i = SetDataIndexOf(entries, value);
2706         if (i < 0) i = s['[[SetData]]'].length;
2707         s['[[SetData]]'][i] = value;
2708
2709         return s;
2710       });
2711
2712     // 23.2.3.2 Set.prototype.clear ()
2713     define(
2714       Set.prototype, 'clear',
2715       function clear() {
2716         var s = strict(this);
2717         if (Type(s) !== 'object') throw TypeError();
2718         if (!('[[SetData]]' in s)) throw TypeError();
2719         if (s['[[SetData]]'] === undefined) throw TypeError();
2720         var entries = s['[[SetData]]'];
2721         entries.length = 0;
2722         return undefined;
2723       });
2724
2725     // 23.2.3.3 Set.prototype.constructor
2726     // 23.2.3.4 Set.prototype.delete ( value )
2727     define(
2728       Set.prototype, 'delete',
2729       function delete_(value) {
2730         var s = strict(this);
2731         if (Type(s) !== 'object') throw TypeError();
2732         if (!('[[SetData]]' in s)) throw TypeError();
2733         if (s['[[SetData]]'] === undefined) throw TypeError();
2734         var entries = s['[[SetData]]'];
2735         var i = SetDataIndexOf(entries, value);
2736         if (i < 0) return false;
2737         entries[i] = empty;
2738         return true;
2739       });
2740
2741     // 23.2.3.5 Set.prototype.entries ( )
2742     define(
2743       Set.prototype, 'entries',
2744       function entries() {
2745         var s = strict(this);
2746         if (Type(s) !== 'object') throw TypeError();
2747         return CreateSetIterator(s, 'key+value');
2748       });
2749
2750     // 23.2.3.6 Set.prototype.forEach ( callbackfn [ , thisArg ] )
2751     define(
2752       Set.prototype, 'forEach',
2753       function forEach(callbackfn/*, thisArg*/) {
2754         var thisArg = arguments[1];
2755
2756         var s = strict(this);
2757         if (Type(s) !== 'object') throw TypeError();
2758         if (!('[[SetData]]' in s)) throw TypeError();
2759         if (s['[[SetData]]'] === undefined) throw TypeError();
2760         var entries = s['[[SetData]]'];
2761
2762         if (!IsCallable(callbackfn)) {
2763           throw TypeError('First argument to forEach is not callable.');
2764         }
2765         for (var i = 0; i < entries.length; ++i) {
2766           if (entries[i] !== empty) {
2767             callbackfn.call(thisArg, entries[i], entries[i], s);
2768           }
2769         }
2770       });
2771
2772     // 23.2.3.7 Set.prototype.has ( value )
2773     define(
2774       Set.prototype, 'has',
2775       function has(key) {
2776         var s = strict(this);
2777         if (Type(s) !== 'object') throw TypeError();
2778         if (!('[[SetData]]' in s)) throw TypeError();
2779         if (s['[[SetData]]'] === undefined) throw TypeError();
2780         var entries = s['[[SetData]]'];
2781         return SetDataIndexOf(entries, key) !== -1;
2782       });
2783
2784     // 23.2.3.8 Set.prototype.keys ( )
2785     // See Set.prototype.values
2786
2787     // 23.2.3.9 get Set.prototype.size
2788     Object.defineProperty(
2789       Set.prototype, 'size', {
2790         get: function() {
2791           var s = strict(this);
2792           if (Type(s) !== 'object') throw TypeError();
2793           if (!('[[SetData]]' in s)) throw TypeError();
2794           if (s['[[SetData]]'] === undefined) throw TypeError();
2795           var entries = s['[[SetData]]'];
2796           var count = 0;
2797           for (var i = 0; i < entries.length; ++i) {
2798             if (entries[i] !== empty)
2799               count = count + 1;
2800           }
2801           return count;
2802         }
2803       });
2804
2805     // 23.2.3.10 Set.prototype.values ( )
2806     define(
2807       Set.prototype, 'values',
2808       function values() {
2809         var s = strict(this);
2810         if (Type(s) !== 'object') throw TypeError();
2811         return CreateSetIterator(s, 'value');
2812       });
2813     // NOTE: function name is still 'values':
2814     Set.prototype.keys = Set.prototype.values;
2815
2816     // 23.2.3.11 Set.prototype [@@iterator ] ( )
2817     define(
2818       Set.prototype, $$iterator,
2819       function() {
2820         var s = strict(this);
2821         if (Type(s) !== 'object') throw TypeError();
2822         return CreateSetIterator(s);
2823       });
2824
2825     // 23.2.3.12 Set.prototype [ @@toStringTag ]
2826     define(global.Set.prototype, $$toStringTag, 'Set');
2827
2828     // 23.2.4 Properties of Set Instances
2829     // 23.2.5 Set Iterator Objects
2830     /** @constructor */
2831     function SetIterator() {}
2832
2833     // 23.2.5.1 CreateSetIterator Abstract Operation
2834     function CreateSetIterator(set, kind) {
2835       if (Type(set) !== 'object') throw TypeError();
2836       if (!('[[SetData]]' in set)) throw TypeError();
2837       if (set['[[SetData]]'] === undefined) throw TypeError();
2838       var iterator = new SetIterator;
2839       set_internal(iterator, '[[IteratedSet]]', set);
2840       set_internal(iterator, '[[SetNextIndex]]', 0);
2841       set_internal(iterator, '[[SetIterationKind]]', kind);
2842       return iterator;
2843     }
2844
2845     // 23.2.5.2 The %SetIteratorPrototype% Object
2846     var $SetIteratorPrototype$ = Object.create($IteratorPrototype$);
2847     SetIterator.prototype = $SetIteratorPrototype$;
2848
2849     // 23.2.5.2.1 %SetIteratorPrototype%.next( )
2850     define(
2851       $SetIteratorPrototype$, 'next',
2852       function next() {
2853         var o = strict(this);
2854         if (Type(o) !== 'object') throw TypeError();
2855         var s = o['[[IteratedSet]]'],
2856             index = o['[[SetNextIndex]]'],
2857             itemKind = o['[[SetIterationKind]]'],
2858             entries = s['[[SetData]]'];
2859         while (index < entries.length) {
2860           var e = entries[index];
2861           index = index += 1;
2862           set_internal(o, '[[SetNextIndex]]', index);
2863           if (e !== empty) {
2864             if (itemKind === 'key+value')
2865               return CreateIterResultObject([e, e], false);
2866             return CreateIterResultObject(e, false);
2867           }
2868         }
2869         return CreateIterResultObject(undefined, true);
2870       });
2871
2872     // 23.2.5.2.2 %SetIteratorPrototype% [ @@toStringTag ]
2873     define($SetIteratorPrototype$, $$toStringTag, 'Set Iterator');
2874
2875     // 23.2.5.3 Properties of Set Iterator Instances
2876
2877   }());
2878
2879   // ---------------------------------------
2880   // 23.3 WeakMap Objects
2881   // ---------------------------------------
2882
2883   (function() {
2884     // 23.3.1 The WeakMap Constructor
2885     // 23.3.1.1 WeakMap ( [ iterable ] )
2886     /** @constructor */
2887     function WeakMap(/*iterable*/) {
2888       var map = strict(this);
2889       var iterable = arguments[0];
2890
2891       if (Type(map) !== 'object') throw TypeError();
2892       if ('[[WeakMapData]]' in map) throw TypeError();
2893
2894       if (iterable !== undefined) {
2895         var adder = map['set'];
2896         if (!IsCallable(adder)) throw TypeError();
2897         var iter = GetIterator(ToObject(iterable));
2898       }
2899       set_internal(map, '[[WeakMapData]]', new EphemeronTable);
2900       if (iter === undefined) return map;
2901       while (true) {
2902         var next = IteratorStep(iter);
2903         if (next === false)
2904           return map;
2905         var nextValue = IteratorValue(next);
2906         if (Type(nextValue) !== 'object') throw TypeError();
2907         var k = nextValue[0];
2908         var v = nextValue[1];
2909         adder.call(map, k, v);
2910       }
2911
2912       return map;
2913     }
2914
2915     if (!('WeakMap' in global) || OVERRIDE_NATIVE_FOR_TESTING)
2916       global.WeakMap = WeakMap;
2917
2918     // 23.3.2 Properties of the WeakMap Constructor
2919     // 23.3.2.1 WeakMap.prototype
2920     var $WeakMapPrototype$ = {};
2921     WeakMap.prototype = $WeakMapPrototype$;
2922
2923
2924
2925    // 23.3.2.2 WeakMap[ @@create ] ( )
2926     // 23.3.3 Properties of the WeakMap Prototype Object
2927
2928     // 23.3.3.1 WeakMap.prototype.constructor
2929
2930     // 23.3.3.2 WeakMap.prototype.delete ( key )
2931     define(
2932       WeakMap.prototype, 'delete',
2933       function delete_(key) {
2934         var M = strict(this);
2935         if (Type(M) !== 'object') throw TypeError();
2936         if (M['[[WeakMapData]]'] === undefined) throw TypeError();
2937         if (Type(key) !== 'object') throw TypeError('Expected object');
2938         return M['[[WeakMapData]]'].remove(key);
2939       });
2940
2941     // 23.3.3.3 WeakMap.prototype.get ( key )
2942     define(
2943       WeakMap.prototype, 'get',
2944       function get(key, defaultValue) {
2945         var M = strict(this);
2946         if (Type(M) !== 'object') throw TypeError();
2947         if (M['[[WeakMapData]]'] === undefined) throw TypeError();
2948         if (Type(key) !== 'object') throw TypeError('Expected object');
2949         return M['[[WeakMapData]]'].get(key, defaultValue);
2950       });
2951
2952     // 23.3.3.4 WeakMap.prototype.has ( key )
2953     define(
2954       WeakMap.prototype, 'has',
2955       function has(key) {
2956         var M = strict(this);
2957         if (Type(M) !== 'object') throw TypeError();
2958         if (M['[[WeakMapData]]'] === undefined) throw TypeError();
2959         if (Type(key) !== 'object') throw TypeError('Expected object');
2960         return M['[[WeakMapData]]'].has(key);
2961       });
2962
2963     // 23.3.3.5 WeakMap.prototype.set ( key , value )
2964     define(
2965       WeakMap.prototype, 'set',
2966       function set(key, value) {
2967         var M = strict(this);
2968         if (Type(M) !== 'object') throw TypeError();
2969         if (M['[[WeakMapData]]'] === undefined) throw TypeError();
2970         if (Type(key) !== 'object') throw TypeError('Expected object');
2971         M['[[WeakMapData]]'].set(key, value);
2972         return M;
2973       });
2974
2975     // 23.3.3.6 WeakMap.prototype [ @@toStringTag ]
2976     define(global.WeakMap.prototype, $$toStringTag, 'WeakMap');
2977
2978     // 23.3.4 Properties of WeakMap Instances
2979
2980     // Polyfills for incomplete native implementations:
2981     (function() {
2982       var wm = new global.WeakMap();
2983       var orig = global.WeakMap.prototype.set;
2984       define(global.WeakMap.prototype, 'set', function set() {
2985         orig.apply(this, arguments);
2986         return this;
2987       }, wm.set({}, 0) !== wm);
2988     }());
2989   }());
2990
2991   // ---------------------------------------
2992   // 23.4 WeakSet Objects
2993   // ---------------------------------------
2994
2995   (function() {
2996     // 23.4.1 The WeakSet Constructor
2997     // 23.4.1.1 WeakSet ( [ iterable ] )
2998     /** @constructor */
2999     function WeakSet(/*iterable*/) {
3000       var set = strict(this);
3001       var iterable = arguments[0];
3002
3003       if (Type(set) !== 'object') throw TypeError();
3004       if ('[[WeakSetData]]' in set) throw TypeError();
3005
3006       if (iterable !== undefined) {
3007         var adder = set['add'];
3008         if (!IsCallable(adder)) throw TypeError();
3009         var iter = GetIterator(ToObject(iterable));
3010       }
3011       set_internal(set, '[[WeakSetData]]', new EphemeronTable);
3012       if (iter === undefined) return set;
3013       while (true) {
3014         var next = IteratorStep(iter);
3015         if (next === false)
3016           return set;
3017         var nextValue = IteratorValue(next);
3018         adder.call(set, nextValue);
3019       }
3020
3021       return set;
3022     }
3023
3024     if (!('WeakSet' in global) || OVERRIDE_NATIVE_FOR_TESTING)
3025       global.WeakSet = WeakSet;
3026
3027     // 23.4.2 Properties of the WeakSet Constructor
3028     // 23.4.2.1 WeakSet.prototype
3029     var $WeakSetPrototype$ = {};
3030     WeakSet.prototype = $WeakSetPrototype$;
3031
3032     // 23.4.3 Properties of the WeakSet Prototype Object
3033     // 23.4.3.1 WeakSet.prototype.add (value )
3034     define(
3035       WeakSet.prototype, 'add',
3036       function add(value) {
3037         var S = strict(this);
3038         if (Type(S) !== 'object') throw TypeError();
3039         if (S['[[WeakSetData]]'] === undefined) throw TypeError();
3040         if (Type(value) !== 'object') throw TypeError('Expected object');
3041         S['[[WeakSetData]]'].set(value, true);
3042         return S;
3043       });
3044
3045     // 23.4.3.2 WeakSet.prototype.constructor
3046     // 23.4.3.3 WeakSet.prototype.delete ( value )
3047     define(
3048       WeakSet.prototype, 'delete',
3049       function delete_(value) {
3050         var S = strict(this);
3051         if (Type(S) !== 'object') throw TypeError();
3052         if (S['[[WeakSetData]]'] === undefined) throw TypeError();
3053         if (Type(value) !== 'object') throw TypeError('Expected object');
3054         return S['[[WeakSetData]]'].remove(value);
3055       });
3056
3057     // 23.4.3.4 WeakSet.prototype.has ( value )
3058     define(
3059       WeakSet.prototype, 'has',
3060       function has(key) {
3061         var S = strict(this);
3062         if (Type(S) !== 'object') throw TypeError();
3063         if (S['[[WeakSetData]]'] === undefined) throw TypeError();
3064         if (Type(key) !== 'object') throw TypeError('Expected object');
3065         return S['[[WeakSetData]]'].has(key);
3066       });
3067
3068     // 23.4.3.5 WeakSet.prototype [ @@toStringTag ]
3069     define(global.WeakSet.prototype, $$toStringTag, 'WeakSet');
3070
3071     // 23.4.4 Properties of WeakSet Instances
3072
3073     // Polyfills for incomplete native implementations:
3074     (function() {
3075       var ws = new global.WeakSet();
3076       var orig = global.WeakSet.prototype.add;
3077       define(global.WeakSet.prototype, 'add', function add() {
3078         orig.apply(this, arguments);
3079         return this;
3080       }, ws.add({}) !== ws);
3081     }());
3082   }());
3083
3084   // ---------------------------------------
3085   // 24 Structured Data
3086   // ---------------------------------------
3087
3088   // ---------------------------------------
3089   // 24.1 ArrayBuffer Objects
3090   // ---------------------------------------
3091
3092   // See typedarray.js for TypedArray polyfill
3093
3094   (function() {
3095     if (!('ArrayBuffer' in global))
3096       return;
3097
3098     // 24.1.1 Abstract Operations For ArrayBuffer Objects
3099     // 24.1.1.1 AllocateArrayBuffer( constructor, byteLength )
3100     // 24.1.1.2 IsDetachedBuffer( arrayBuffer )
3101     // 24.1.1.3 DetachArrayBuffer( arrayBuffer )
3102     // 24.1.1.4 CloneArrayBuffer( srcBuffer, srcByteOffset [, cloneConstructor] )
3103     // 24.1.1.5 GetValueFromBuffer ( arrayBuffer, byteIndex, type, isLittleEndian )
3104     // 24.1.1.6 SetValueInBuffer ( arrayBuffer, byteIndex, type, value, isLittleEndian )
3105     // 24.1.2 The ArrayBuffer Constructor
3106     // 24.1.2.1 ArrayBuffer( length )
3107     // 24.1.3 Properties of the ArrayBuffer Constructor
3108
3109     // 24.1.3.1 ArrayBuffer.isView ( arg )
3110     define(
3111       ArrayBuffer, 'isView',
3112       function isView(arg) {
3113         if (Type(arg) !== 'object') return false;
3114         if ('buffer' in arg && arg.buffer instanceof ArrayBuffer) return true;
3115         return false;
3116       });
3117
3118     // 24.1.3.2 ArrayBuffer.prototype
3119     // 24.1.3.3 get ArrayBuffer [ @@species ]
3120     // 24.1.4 Properties of the ArrayBuffer Prototype Object
3121     // 24.1.4.1 get ArrayBuffer.prototype.byteLength
3122     // 24.1.4.2 ArrayBuffer.prototype.constructor
3123     // 24.1.4.3 ArrayBuffer.prototype.slice ( start , end)
3124
3125     // 24.1.4.4 ArrayBuffer.prototype [ @@toStringTag ]
3126     define(ArrayBuffer.prototype, $$toStringTag, 'ArrayBuffer');
3127
3128     // 24.1.5 Properties of the ArrayBuffer Instances
3129   }());
3130
3131   // ---------------------------------------
3132   // 24.2 DataView Objects
3133   // ---------------------------------------
3134
3135   // See typedarray.js for TypedArray polyfill
3136
3137   (function() {
3138     if (!('DataView' in global))
3139       return;
3140
3141     // 24.2.1 Abstract Operations For DataView Objects
3142     // 24.2.1.1 GetViewValue(view, requestIndex, isLittleEndian, type)
3143     // 24.2.1.2 SetViewValue(view, requestIndex, isLittleEndian, type, value)
3144     // 24.2.2 The DataView Constructor
3145     // 24.2.2.1 DataView (buffer [ , byteOffset [ , byteLength ] ] )
3146     // 24.2.3 Properties of the DataView Constructor
3147     // 24.2.3.1 DataView.prototype
3148     // 24.2.4 Properties of the DataView Prototype Object
3149     // 24.2.4.1 get DataView.prototype.buffer
3150     // 24.2.4.2 get DataView.prototype.byteLength
3151     // 24.2.4.3 get DataView.prototype.byteOffset
3152     // 24.2.4.4 DataView.prototype.constructor
3153     // 24.2.4.5 DataView.prototype.getFloat32 ( byteOffset [ , littleEndian ] )
3154     // 24.2.4.6 DataView.prototype.getFloat64 ( byteOffset [ , littleEndian ] )
3155     // 24.2.4.7 DataView.prototype.getInt8 ( byteOffset )
3156     // 24.2.4.8 DataView.prototype.getInt16 ( byteOffset [ , littleEndian ] )
3157     // 24.2.4.9 DataView.prototype.getInt32 ( byteOffset [ , littleEndian ] )
3158     // 24.2.4.10 DataView.prototype.getUint8 ( byteOffset )
3159     // 24.2.4.11 DataView.prototype.getUint16 ( byteOffset [ , littleEndian ] )
3160     // 24.2.4.12 DataView.prototype.getUint32 ( byteOffset [ , littleEndian ] )
3161     // 24.2.4.13 DataView.prototype.setFloat32 ( byteOffset, value [ , littleEndian ] )
3162     // 24.2.4.14 DataView.prototype.setFloat64 ( byteOffset, value [ , littleEndian ] )
3163     // 24.2.4.15 DataView.prototype.setInt8 ( byteOffset, value )
3164     // 24.2.4.16 DataView.prototype.setInt16 ( byteOffset, value [ , littleEndian ] )
3165     // 24.2.4.17 DataView.prototype.setInt32 ( byteOffset, value [ , littleEndian ] )
3166     // 24.2.4.18 DataView.prototype.setUint8 ( byteOffset, value )
3167     // 24.2.4.19 DataView.prototype.setUint16 ( byteOffset, value [ , littleEndian ] )
3168     // 24.2.4.20 DataView.prototype.setUint32 ( byteOffset, value [ , littleEndian ] )
3169
3170     // 24.2.4.21 DataView.prototype[ @@toStringTag ]
3171     define(DataView.prototype, $$toStringTag, 'DataView');
3172
3173     // 24.2.5 Properties of DataView Instances
3174   }());
3175
3176   // ---------------------------------------
3177   // 24.3 The JSON Object
3178   // ---------------------------------------
3179
3180   // 24.3.1 JSON.parse ( text [ , reviver ] )
3181   // 24.3.2 JSON.stringify ( value [ , replacer [ , space ] ] )
3182   // 24.3.3 JSON [ @@toStringTag ]
3183   define(JSON, $$toStringTag, 'JSON');
3184
3185   // ---------------------------------------
3186   // 25.1 Iteration
3187   // ---------------------------------------
3188
3189   // 25.1.1 Common Iteration Interfaces
3190   // 25.1.1.1 The Iterable Interface
3191   // 25.1.1.2 The Iterator Interface
3192   // 25.1.1.3 The IteratorResult Interface
3193
3194   // 25.1.2 The %IteratorPrototype% Object
3195   // Defined earlier, so other prototypes can reference it.
3196   // 25.1.2.1 %IteratorPrototype% [ @@iterator ] ( )
3197   define($IteratorPrototype$, $$iterator, function() {
3198     return this;
3199   });
3200
3201
3202   // ---------------------------------------
3203   // 25.4 Promise Objects
3204   // ---------------------------------------
3205
3206   (function() {
3207     // 25.4 Promise Objects
3208
3209     // 25.4.1 Promise Abstract Operations
3210
3211     // 25.4.1.1 PromiseCapability Records
3212     // 25.4.1.1.1 IfAbruptRejectPromise ( value, capability )
3213
3214     function IfAbruptRejectPromise(value, capability) {
3215       var rejectResult = capability['[[Reject]]'].call(undefined, value);
3216       return capability['[[Promise]]'];
3217     }
3218
3219     // 25.4.1.2 PromiseReaction Records
3220
3221     // 25.4.1.3 CreateResolvingFunctions ( promise )
3222
3223     function CreateResolvingFunctions(promise) {
3224       var alreadyResolved = {'[[value]]': false};
3225       var resolve = PromiseResolveFunction();
3226       set_internal(resolve, '[[Promise]]',  promise);
3227       set_internal(resolve, '[[AlreadyResolved]]', alreadyResolved);
3228       var reject = PromiseRejectFunction();
3229       set_internal(reject, '[[Promise]]', promise);
3230       set_internal(reject, '[[AlreadyResolved]]', alreadyResolved);
3231       return { '[[Resolve]]': resolve, '[[Reject]]': reject};
3232     }
3233
3234     // 25.4.1.3.1 Promise Reject Functions
3235
3236     function PromiseRejectFunction() {
3237       var F = function(reason) {
3238         console.assert(Type(F['[[Promise]]']) === 'object');
3239         var promise = F['[[Promise]]'];
3240         var alreadyResolved = F['[[AlreadyResolved]]'];
3241         if (alreadyResolved['[[value]]']) return undefined;
3242         set_internal(alreadyResolved, '[[value]]', true);
3243         return RejectPromise(promise, reason);
3244       };
3245       return F;
3246     }
3247
3248     // 25.4.1.3.2 Promise Resolve Functions
3249
3250     function PromiseResolveFunction() {
3251       var F = function(resolution) {
3252         console.assert(Type(F['[[Promise]]']) === 'object');
3253         var promise = F['[[Promise]]'];
3254         var alreadyResolved = F['[[AlreadyResolved]]'];
3255         if (alreadyResolved['[[value]]']) return undefined;
3256         set_internal(alreadyResolved, '[[value]]', true);
3257
3258         if (SameValue(resolution, promise))  {
3259           var selfResolutionError = TypeError();
3260           return RejectPromise(promise, selfResolutionError);
3261         }
3262         if (Type(resolution) !== 'object')
3263           return FulfillPromise(promise, resolution);
3264         try {
3265           var then = resolution['then'];
3266         } catch(then) {
3267           return RejectPromise(promise, then);
3268         }
3269         if (!IsCallable(then))
3270           return FulfillPromise(promise, resolution);
3271         EnqueueJob('PromiseJobs', PromiseResolveThenableJob, [promise, resolution, then]);
3272         return undefined;
3273       };
3274       return F;
3275     }
3276
3277     // 25.4.1.4 FulfillPromise ( promise, value )
3278
3279     function FulfillPromise(promise, value) {
3280       console.assert(promise['[[PromiseState]]'] === 'pending');
3281       var reactions = promise['[[PromiseFulfillReactions]]'];
3282       set_internal(promise, '[[PromiseResult]]', value);
3283       set_internal(promise, '[[PromiseFulfillReactions]]', undefined);
3284       set_internal(promise, '[[PromiseRejectReactions]]', undefined);
3285       set_internal(promise, '[[PromiseState]]', 'fulfilled');
3286       return TriggerPromiseReactions(reactions, value);
3287     }
3288
3289     // 25.4.1.5 NewPromiseCapability ( C )
3290
3291     function NewPromiseCapability(c) {
3292       // To keep Promise hermetic, this doesn't look much like the spec.
3293       return CreatePromiseCapabilityRecord(undefined, c);
3294     }
3295
3296     // 25.4.1.5.1 CreatePromiseCapabilityRecord ( promise, constructor )
3297
3298     function CreatePromiseCapabilityRecord(promise, constructor) {
3299       // To keep Promise hermetic, this doesn't look much like the spec.
3300       console.assert(IsConstructor(constructor));
3301       var promiseCapability = {};
3302       set_internal(promiseCapability, '[[Promise]]', promise);
3303       set_internal(promiseCapability, '[[Resolve]]', undefined);
3304       set_internal(promiseCapability, '[[Reject]]', undefined);
3305       var executor = GetCapabilitiesExecutor();
3306       set_internal(executor, '[[Capability]]', promiseCapability);
3307
3308       // NOTE: Differs from spec; object is constructed here
3309       var constructorResult = promise = new constructor(executor);
3310       set_internal(promiseCapability, '[[Promise]]', promise);
3311
3312       if (!IsCallable(promiseCapability['[[Resolve]]'])) throw TypeError();
3313       if (!IsCallable(promiseCapability['[[Reject]]'])) throw TypeError();
3314       if (Type(constructorResult) === 'object' && !SameValue(promise, constructorResult)) throw TypeError();
3315       return promiseCapability;
3316     }
3317
3318     // 25.4.1.5.2 GetCapabilitiesExecutor Functions
3319
3320     function GetCapabilitiesExecutor() {
3321       var F = function(resolve, reject) {
3322         console.assert(F['[[Capability]]']);
3323         var promiseCapability = F['[[Capability]]'];
3324         if (promiseCapability['[[Resolve]]'] !== undefined) throw TypeError();
3325         if (promiseCapability['[[Reject]]'] !== undefined) throw TypeError();
3326         set_internal(promiseCapability, '[[Resolve]]', resolve);
3327         set_internal(promiseCapability, '[[Reject]]', reject);
3328         return undefined;
3329       };
3330       return F;
3331     }
3332
3333     // 25.4.1.6 IsPromise ( x )
3334
3335     function IsPromise(x) {
3336       if (Type(x) !== 'object') return false;
3337       if (!('[[PromiseState]]' in x)) return false;
3338       if (x['[[PromiseState]]'] === undefined) return false;
3339       return true;
3340     }
3341
3342     // 25.4.1.7 RejectPromise ( promise, reason )
3343
3344     function RejectPromise(promise, reason) {
3345       console.assert(promise['[[PromiseState]]'] === 'pending');
3346       var reactions = promise['[[PromiseRejectReactions]]'];
3347       set_internal(promise, '[[PromiseResult]]', reason);
3348       set_internal(promise, '[[PromiseFulfillReactions]]', undefined);
3349       set_internal(promise, '[[PromiseRejectReactions]]', undefined);
3350       set_internal(promise, '[[PromiseState]]', 'rejected');
3351       return TriggerPromiseReactions(reactions, reason);
3352     }
3353
3354     // 25.4.1.8 TriggerPromiseReactions ( reactions, argument )
3355
3356     function TriggerPromiseReactions(reactions, argument) {
3357       for (var i = 0, len = reactions.length; i < len; ++i)
3358         EnqueueJob('PromiseJobs', PromiseReactionJob, [reactions[i], argument]);
3359       return undefined;
3360     }
3361
3362     // 25.4.2 Promise Jobs
3363
3364     // 25.4.2.1 PromiseReactionJob ( reaction, argument )
3365
3366     function PromiseReactionJob(reaction, argument) {
3367       var promiseCapability = reaction['[[Capabilities]]'];
3368       var handler = reaction['[[Handler]]'];
3369       var handlerResult, status;
3370       try {
3371         if (handler === 'Identity') handlerResult = argument;
3372         else if (handler === 'Thrower') throw argument;
3373         else handlerResult = handler.call(undefined, argument);
3374       } catch (handlerResult) {
3375         status = promiseCapability['[[Reject]]'].call(undefined, handlerResult);
3376         NextJob(status); return;
3377       }
3378       status = promiseCapability['[[Resolve]]'].call(undefined, handlerResult);
3379       NextJob(status);
3380     }
3381
3382     // 25.4.2.2 PromiseResolveThenableJob ( promiseToResolve, thenable, then)
3383
3384     function PromiseResolveThenableJob(promiseToResolve, thenable, then) {
3385       // SPEC BUG: promise vs. promiseToResolve
3386       var resolvingFunctions = CreateResolvingFunctions(promiseToResolve);
3387       try {
3388         var thenCallResult = then.call(thenable, resolvingFunctions['[[Resolve]]'],
3389                                        resolvingFunctions['[[Reject]]']);
3390       } catch (thenCallResult) {
3391         var status = resolvingFunctions['[[Reject]]'].call(undefined, thenCallResult);
3392         NextJob(status); return;
3393       }
3394       NextJob(thenCallResult);
3395     }
3396
3397     // 25.4.3 The Promise Constructor
3398
3399     // 25.4.3.1 Promise ( executor )
3400
3401     function Promise(executor) {
3402       var config = { configurable: false, enumerable: false, writable: true, value: undefined };
3403       Object.defineProperty(this, '[[PromiseState]]', config);
3404       Object.defineProperty(this, '[[PromiseConstructor]]', config);
3405       Object.defineProperty(this, '[[PromiseResult]]', config);
3406       Object.defineProperty(this, '[[PromiseFulfillReactions]]', config);
3407       Object.defineProperty(this, '[[PromiseRejectReactions]]', config);
3408
3409       var promise = this;
3410       if (Type(promise) !== 'object') throw new TypeError();
3411       if (!('[[PromiseState]]' in promise)) throw TypeError();
3412       if (promise['[[PromiseState]]'] !== undefined) throw TypeError();
3413       if (!IsCallable(executor)) throw TypeError();
3414
3415       set_internal(promise, '[[PromiseConstructor]]', Promise);
3416
3417       return InitializePromise(promise, executor);
3418     }
3419
3420     // 25.4.3.1.1 InitializePromise ( promise, executor )
3421
3422     function InitializePromise(promise, executor) {
3423       console.assert('[[PromiseState]]' in promise);
3424       console.assert(IsCallable(executor));
3425       set_internal(promise, '[[PromiseState]]', 'pending');
3426       set_internal(promise, '[[PromiseFulfillReactions]]', []);
3427       set_internal(promise, '[[PromiseRejectReactions]]', []);
3428       var resolvingFunctions = CreateResolvingFunctions(promise);
3429       try {
3430         var completion = executor.call(undefined, resolvingFunctions['[[Resolve]]'],
3431                                        resolvingFunctions['[[Reject]]']);
3432       } catch (completion) {
3433         var status = resolvingFunctions['[[Reject]]'].call(undefined, completion);
3434       }
3435       return promise;
3436     }
3437
3438     // 25.4.4 Properties of the Promise Constructor
3439     // 25.4.4.1 Promise.all ( iterable )
3440
3441     define(Promise, 'all', function all(iterable) {
3442       var c = strict(this);
3443       var promiseCapability = NewPromiseCapability(c);
3444       try {
3445         var iterator = GetIterator(iterable);
3446       } catch (value) {
3447         promiseCapability['[[Reject]]'].call(undefined, value);
3448         return promiseCapability['[[Promise]]'];
3449       }
3450       var values = [];
3451       var remainingElementsCount = { value: 1 };
3452       var index = 0;
3453       while (true) {
3454         try {
3455           var next = IteratorStep(iterator);
3456         } catch (value) {
3457           promiseCapability['[[Reject]]'].call(undefined, value);
3458           return promiseCapability['[[Promise]]'];
3459         }
3460         if (!next) {
3461           remainingElementsCount.value -= 1;
3462           if (remainingElementsCount.value === 0) {
3463             var resolveResult = promiseCapability['[[Resolve]]'].apply(undefined, values);
3464
3465
3466           }
3467           return promiseCapability['[[Promise]]'];
3468         }
3469         try {
3470           var nextValue = IteratorValue(next);
3471         } catch (value) {
3472           promiseCapability['[[Reject]]'].call(undefined, value);
3473           return promiseCapability['[[Promise]]'];
3474         }
3475         try {
3476           var nextPromise = c.resolve(nextValue);
3477         } catch (value) {
3478           promiseCapability['[[Reject]]'].call(undefined, value);
3479           return promiseCapability['[[Promise]]'];
3480         }
3481         var resolveElement = PromiseAllResolveElementFunction();
3482         set_internal(resolveElement, '[[AlreadyCalled]]', { value: false });
3483         set_internal(resolveElement, '[[Index]]', index);
3484         set_internal(resolveElement, '[[Values]]', values);
3485         set_internal(resolveElement, '[[Capabilities]]', promiseCapability);
3486         set_internal(resolveElement, '[[RemainingElements]]', remainingElementsCount);
3487         remainingElementsCount.value += 1;
3488         try {
3489           var result = nextPromise.then(resolveElement, promiseCapability['[[Reject]]']);
3490         } catch (value) {
3491           promiseCapability['[[Reject]]'].call(undefined, value);
3492           return promiseCapability['[[Promise]]'];
3493         }
3494         index += 1;
3495       }
3496     });
3497
3498     // 25.4.4.1.1 Promise.all Resolve Element Functions
3499
3500     function PromiseAllResolveElementFunction() {
3501       var F = function(x) {
3502         var alreadyCalled = F['[[AlreadyCalled]]'];
3503         if (alreadyCalled.value) return undefined;
3504         alreadyCalled.value = true;
3505         var index = F['[[Index]]'];
3506         var values = F['[[Values]]'];
3507         var promiseCapability = F['[[Capabilities]]'];
3508         var remainingElementsCount = F['[[RemainingElements]]'];
3509         try {
3510           values[index] = x;
3511         } catch (result) {
3512           promiseCapability['[[Reject]]'].call(undefined, result);
3513           return promiseCapability['[[Promise]]'];
3514         }
3515         remainingElementsCount.value -= 1;
3516         if (remainingElementsCount.value === 0)
3517           return promiseCapability['[[Resolve]]'].call(undefined, values);
3518         return undefined;
3519       };
3520       return F;
3521     }
3522
3523     // 25.4.4.2 Promise.prototype
3524
3525     Promise.prototype = {};
3526
3527     // 25.4.4.3 Promise.race ( iterable )
3528
3529     define(Promise, 'race', function race(iterable) {
3530       var c = strict(this);
3531       var promiseCapability = NewPromiseCapability(c);
3532       try {
3533         var iterator = GetIterator(iterable);
3534       } catch (value) {
3535         promiseCapability['[[Reject]]'].call(undefined, value);
3536         return promiseCapability['[[Promise]]'];
3537       }
3538       while (true) {
3539         try {
3540           var next = IteratorStep(iterator);
3541         } catch (value) {
3542           promiseCapability['[[Reject]]'].call(undefined, value);
3543           return promiseCapability['[[Promise]]'];
3544         }
3545         if (!next) return promiseCapability['[[Promise]]'];
3546         try {
3547           var nextValue = IteratorValue(next);
3548         } catch (value) {
3549           promiseCapability['[[Reject]]'].call(undefined, value);
3550           return promiseCapability['[[Promise]]'];
3551         }
3552         try {
3553           var nextPromise = c.resolve(nextValue);
3554         } catch (value) {
3555           promiseCapability['[[Reject]]'].call(undefined, value);
3556           return promiseCapability['[[Promise]]'];
3557         }
3558         try {
3559           nextPromise.then(promiseCapability['[[Resolve]]'], promiseCapability['[[Reject]]']);
3560         } catch (value) {
3561           promiseCapability['[[Reject]]'].call(undefined, value);
3562           return promiseCapability['[[Promise]]'];
3563         }
3564       }
3565     });
3566
3567     // 25.4.4.4 Promise.reject ( r )
3568
3569     define(Promise, 'reject', function reject(r) {
3570       var c = strict(this);
3571       var promiseCapability = NewPromiseCapability(c);
3572       var rejectResult = promiseCapability['[[Reject]]'].call(undefined, r);
3573       return promiseCapability['[[Promise]]'];
3574     });
3575
3576     // 25.4.4.5 Promise.resolve ( x )
3577
3578     define(Promise, 'resolve', function resolve(x) {
3579       var c = strict(this);
3580       if (IsPromise(x)) {
3581         var constructor = x['[[PromiseConstructor]]'];
3582         if (SameValue(constructor, c)) return x;
3583       }
3584       var promiseCapability = NewPromiseCapability(c);
3585       var resolveResult = promiseCapability['[[Resolve]]'].call(undefined, x);
3586       return promiseCapability['[[Promise]]'];
3587     });
3588
3589     // 25.4.4.6 Promise [ @@create ] ( )
3590     // 25.4.4.6.1 AllocatePromise ( constructor )
3591     // 25.4.5 Properties of the Promise Prototype Object
3592     // 25.4.5.1 Promise.prototype.catch ( onRejected )
3593
3594     define(Promise.prototype, 'catch', function catch_(onRejected) {
3595       var promise = this;
3596       return promise.then(undefined, onRejected);
3597     });
3598
3599     // 25.4.5.2 Promise.prototype.constructor
3600
3601     Promise.prototype.constructor = Promise;
3602
3603     // 25.4.5.3 Promise.prototype.then ( onFulfilled , onRejected )
3604
3605     define(Promise.prototype, 'then', function then(onFulfilled, onRejected) {
3606       var promise = this;
3607       if (!IsPromise(promise)) throw TypeError();
3608       if (!IsCallable(onFulfilled)) onFulfilled = 'Identity';
3609       if (!IsCallable(onRejected)) onRejected = 'Thrower';
3610       var c = promise.constructor;
3611       var promiseCapability = NewPromiseCapability(c);
3612       var fulfillReaction = { '[[Capabilities]]': promiseCapability,
3613                               '[[Handler]]': onFulfilled };
3614       var rejectReaction = { '[[Capabilities]]': promiseCapability,
3615                              '[[Handler]]': onRejected };
3616       if (promise['[[PromiseState]]'] === 'pending') {
3617         promise['[[PromiseFulfillReactions]]'].push(fulfillReaction);
3618         promise['[[PromiseRejectReactions]]'].push(rejectReaction);
3619       } else if (promise['[[PromiseState]]'] === 'fulfilled') {
3620         var value = promise['[[PromiseResult]]'];
3621         EnqueueJob('PromiseJobs', PromiseReactionJob, [fulfillReaction, value]);
3622       } else if (promise['[[PromiseState]]'] === 'rejected') {
3623         var reason = promise['[[PromiseResult]]'];
3624         EnqueueJob('PromiseJobs', PromiseReactionJob, [rejectReaction, reason]);
3625       }
3626       return promiseCapability['[[Promise]]'];
3627     });
3628
3629     // 25.4.6 Properties of Promise Instances
3630
3631     if (!('Promise' in global) || OVERRIDE_NATIVE_FOR_TESTING)
3632       global.Promise = Promise;
3633
3634     // Patch early Promise.cast vs. Promise.resolve implementations
3635     if ('cast' in global.Promise) global.Promise.resolve = global.Promise.cast;
3636   }());
3637
3638   // 25.4.5.1 Promise.prototype [ @@toStringTag ]
3639   define(Promise.prototype, $$toStringTag, 'Promise');
3640
3641   // ---------------------------------------
3642   // 26 Reflection
3643   // ---------------------------------------
3644
3645   (function() {
3646     // 26.1 The Reflect Object
3647     if (!('Reflect' in global) || OVERRIDE_NATIVE_FOR_TESTING)
3648       global.Reflect = {};
3649
3650     // 26.1.1 Reflect.apply ( target, thisArgument, argumentsList )
3651     define(
3652       Reflect, 'apply',
3653       function apply(target, thisArgument, argumentsList) {
3654         if (!IsCallable(target)) throw TypeError();
3655         return Function.prototype.apply.call(target, thisArgument, argumentsList);
3656       });
3657
3658     // 26.1.2 Reflect.construct ( target, argumentsList [, newTarget] )
3659     define(
3660       Reflect, 'construct',
3661       function construct(target, argumentsList) {
3662         return __cons(target, argumentsList);
3663       });
3664
3665     // 26.1.3 Reflect.defineProperty ( target, propertyKey, attributes )
3666     define(
3667       Reflect, 'defineProperty',
3668       function defineProperty(target, propertyKey, attributes) {
3669         try {
3670           Object.defineProperty(target, propertyKey, attributes);
3671           return true;
3672         } catch (_) {
3673           return false;
3674         }
3675       });
3676
3677     // 26.1.4 Reflect.deleteProperty ( target, propertyKey )
3678     define(
3679       Reflect, 'deleteProperty',
3680       function deleteProperty(target,name) {
3681         try {
3682           delete target[name];
3683           return !HasOwnProperty(target, name);
3684         } catch (_) {
3685           return false;
3686         }
3687       });
3688
3689     // 26.1.5 Reflect.enumerate ( target )
3690     define(
3691       Reflect, 'enumerate',
3692       function enumerate(target) {
3693         target = ToObject(target);
3694         var iterator = Enumerate(target);
3695         return iterator;
3696       });
3697
3698     // 26.1.6 Reflect.get ( target, propertyKey [ , receiver ])
3699     define(
3700       Reflect, 'get',
3701       function get(target, name, receiver) {
3702         target = ToObject(target);
3703         name = String(name);
3704         receiver = (receiver === undefined) ? target : ToObject(receiver);
3705         var desc = getPropertyDescriptor(target, name);
3706         if (desc && 'get' in desc)
3707           return Function.prototype.call.call(desc['get'], receiver);
3708         return target[name];
3709       });
3710
3711     // 26.1.7 Reflect.getOwnPropertyDescriptor ( target, propertyKey )
3712     define(
3713       Reflect, 'getOwnPropertyDescriptor',
3714       Object.getOwnPropertyDescriptor);
3715
3716     // 26.1.8 Reflect.getPrototypeOf ( target )
3717     define(
3718       Reflect, 'getPrototypeOf',
3719       Object.getPrototypeOf);
3720
3721     // 26.1.9 Reflect.has ( target, propertyKey )
3722     define(
3723       Reflect, 'has',
3724       function has(target,name) {
3725         return String(name) in ToObject(target);
3726       });
3727
3728     // 26.1.10 Reflect.isExtensible (target)
3729     define(
3730       Reflect, 'isExtensible',
3731       Object.isExtensible);
3732
3733     // 26.1.11 Reflect.ownKeys ( target )
3734     define(
3735       Reflect, 'ownKeys',
3736       function ownKeys(target) {
3737         var obj = ToObject(target);
3738         return Object.getOwnPropertyNames(obj);
3739       });
3740
3741     // 26.1.12 Reflect.preventExtensions ( target )
3742     define(
3743       Reflect, 'preventExtensions',
3744       function preventExtensions(target) {
3745         try { Object.preventExtensions(target); return true; } catch (_) { return false; }
3746       });
3747
3748     // 26.1.13 Reflect.set ( target, propertyKey, V [ , receiver ] )
3749     define(
3750       Reflect, 'set',
3751       function set(target, name, value, receiver) {
3752         target = ToObject(target);
3753         name = String(name);
3754         receiver = (receiver === undefined) ? target : ToObject(receiver);
3755         var desc = getPropertyDescriptor(target, name);
3756         try {
3757           if (desc && 'set' in desc)
3758             Function.prototype.call.call(desc['set'], receiver, value);
3759           else
3760             target[name] = value;
3761           return true;
3762         } catch (_) {
3763           return false;
3764         }
3765       });
3766
3767     // 26.1.14 Reflect.setPrototypeOf ( target, proto )
3768     define(
3769       Reflect, 'setPrototypeOf',
3770       function setPrototypeOf(target, proto) {
3771         try {
3772           target.__proto__ = proto;
3773           return Reflect.getPrototypeOf(target) === proto;
3774         } catch(_) {
3775           return false;
3776         }
3777       });
3778
3779   }());
3780
3781   // ---------------------------------------
3782   // 26.2 Proxy Objects
3783   // ---------------------------------------
3784
3785   // Not polyfillable.
3786
3787 }(self));
3788
3789 // This helper is defined outside the main scope so that the use of
3790 // 'eval' does not taint the scope for minifiers.
3791 function __cons(t, a) {
3792   return eval('new t(' + a.map(function(_, i) { return 'a[' + i + ']'; }).join(',') + ')');
3793 }