// Composited file - DO NOT EDIT //---------------------------------------------------------------------- // // ECMAScript 5 Polyfills // //---------------------------------------------------------------------- //---------------------------------------------------------------------- // ES5 15.2 Object Objects //---------------------------------------------------------------------- // // ES5 15.2.3 Properties of the Object Constructor // // ES5 15.2.3.2 Object.getPrototypeOf ( O ) // From http://ejohn.org/blog/objectgetprototypeof/ // NOTE: won't work for typical function T() {}; T.prototype = {}; new T; case // since the constructor property is destroyed. if (!Object.getPrototypeOf) { Object.getPrototypeOf = function (o) { if (o !== Object(o)) { throw TypeError("Object.getPrototypeOf called on non-object"); } return o.__proto__ || o.constructor.prototype || Object.prototype; }; } // // ES5 15.2.3.3 Object.getOwnPropertyDescriptor ( O, P ) // if (typeof Object.getOwnPropertyDescriptor !== "function") { // Object.getOwnPropertyDescriptor = function (o, name) { // if (o !== Object(o)) { throw TypeError(); } // if (o.hasOwnProperty(name)) { // return { // value: o[name], // enumerable: true, // writable: true, // configurable: true // }; // } // }; // } // ES5 15.2.3.4 Object.getOwnPropertyNames ( O ) if (typeof Object.getOwnPropertyNames !== "function") { Object.getOwnPropertyNames = function (o) { if (o !== Object(o)) { throw TypeError("Object.getOwnPropertyNames called on non-object"); } var props = [], p; for (p in o) { if (Object.prototype.hasOwnProperty.call(o, p)) { props.push(p); } } return props; }; } // ES5 15.2.3.5 Object.create ( O [, Properties] ) if (typeof Object.create !== "function") { Object.create = function (prototype, properties) { if (typeof prototype !== "object") { throw TypeError(); } function Ctor() {} Ctor.prototype = prototype; var o = new Ctor(); if (prototype) { o.constructor = Ctor; } if (properties !== undefined) { if (properties !== Object(properties)) { throw TypeError(); } Object.defineProperties(o, properties); } return o; }; } // ES 15.2.3.6 Object.defineProperty ( O, P, Attributes ) // Partial support for most common case - getters, setters, and values (function() { if (!Object.defineProperty || !(function () { try { Object.defineProperty({}, 'x', {}); return true; } catch (e) { return false; } } ())) { var orig = Object.defineProperty; Object.defineProperty = function (o, prop, desc) { // In IE8 try built-in implementation for defining properties on DOM prototypes. if (orig) { try { return orig(o, prop, desc); } catch (e) {} } if (o !== Object(o)) { throw TypeError("Object.defineProperty called on non-object"); } if (Object.prototype.__defineGetter__ && ('get' in desc)) { Object.prototype.__defineGetter__.call(o, prop, desc.get); } if (Object.prototype.__defineSetter__ && ('set' in desc)) { Object.prototype.__defineSetter__.call(o, prop, desc.set); } if ('value' in desc) { o[prop] = desc.value; } return o; }; } }()); // ES 15.2.3.7 Object.defineProperties ( O, Properties ) if (typeof Object.defineProperties !== "function") { Object.defineProperties = function (o, properties) { if (o !== Object(o)) { throw TypeError("Object.defineProperties called on non-object"); } var name; for (name in properties) { if (Object.prototype.hasOwnProperty.call(properties, name)) { Object.defineProperty(o, name, properties[name]); } } return o; }; } // ES5 15.2.3.14 Object.keys ( O ) // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Object/keys if (!Object.keys) { Object.keys = function (o) { if (o !== Object(o)) { throw TypeError('Object.keys called on non-object'); } var ret = [], p; for (p in o) { if (Object.prototype.hasOwnProperty.call(o, p)) { ret.push(p); } } return ret; }; } //---------------------------------------------------------------------- // ES5 15.3 Function Objects //---------------------------------------------------------------------- // // ES5 15.3.4 Properties of the Function Prototype Object // // ES5 15.3.4.5 Function.prototype.bind ( thisArg [, arg1 [, arg2, ... ]] ) // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Function/bind if (!Function.prototype.bind) { Function.prototype.bind = function (o) { if (typeof this !== 'function') { throw TypeError("Bind must be called on a function"); } var args = Array.prototype.slice.call(arguments, 1), self = this, nop = function() {}, bound = function () { return self.apply(this instanceof nop ? this : o, args.concat(Array.prototype.slice.call(arguments))); }; if (this.prototype) nop.prototype = this.prototype; bound.prototype = new nop(); return bound; }; } //---------------------------------------------------------------------- // ES5 15.4 Array Objects //---------------------------------------------------------------------- // // ES5 15.4.3 Properties of the Array Constructor // // ES5 15.4.3.2 Array.isArray ( arg ) // https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/isArray Array.isArray = Array.isArray || function (o) { return Boolean(o && Object.prototype.toString.call(Object(o)) === '[object Array]'); }; // // ES5 15.4.4 Properties of the Array Prototype Object // // ES5 15.4.4.14 Array.prototype.indexOf ( searchElement [ , fromIndex ] ) // From https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/indexOf if (!Array.prototype.indexOf) { Array.prototype.indexOf = function (searchElement /*, fromIndex */) { if (this === void 0 || this === null) { throw TypeError(); } var t = Object(this); var len = t.length >>> 0; if (len === 0) { return -1; } var n = 0; if (arguments.length > 0) { n = Number(arguments[1]); if (isNaN(n)) { n = 0; } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) { n = (n > 0 || -1) * Math.floor(Math.abs(n)); } } if (n >= len) { return -1; } var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0); for (; k < len; k++) { if (k in t && t[k] === searchElement) { return k; } } return -1; }; } // ES5 15.4.4.15 Array.prototype.lastIndexOf ( searchElement [ , fromIndex ] ) // From https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/lastIndexOf if (!Array.prototype.lastIndexOf) { Array.prototype.lastIndexOf = function (searchElement /*, fromIndex*/) { if (this === void 0 || this === null) { throw TypeError(); } var t = Object(this); var len = t.length >>> 0; if (len === 0) { return -1; } var n = len; if (arguments.length > 1) { n = Number(arguments[1]); if (n !== n) { n = 0; } else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0)) { n = (n > 0 || -1) * Math.floor(Math.abs(n)); } } var k = n >= 0 ? Math.min(n, len - 1) : len - Math.abs(n); for (; k >= 0; k--) { if (k in t && t[k] === searchElement) { return k; } } return -1; }; } // ES5 15.4.4.16 Array.prototype.every ( callbackfn [ , thisArg ] ) // From https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/every if (!Array.prototype.every) { Array.prototype.every = function (fun /*, thisp */) { if (this === void 0 || this === null) { throw TypeError(); } var t = Object(this); var len = t.length >>> 0; if (typeof fun !== "function") { throw TypeError(); } var thisp = arguments[1], i; for (i = 0; i < len; i++) { if (i in t && !fun.call(thisp, t[i], i, t)) { return false; } } return true; }; } // ES5 15.4.4.17 Array.prototype.some ( callbackfn [ , thisArg ] ) // From https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/some if (!Array.prototype.some) { Array.prototype.some = function (fun /*, thisp */) { if (this === void 0 || this === null) { throw TypeError(); } var t = Object(this); var len = t.length >>> 0; if (typeof fun !== "function") { throw TypeError(); } var thisp = arguments[1], i; for (i = 0; i < len; i++) { if (i in t && fun.call(thisp, t[i], i, t)) { return true; } } return false; }; } // ES5 15.4.4.18 Array.prototype.forEach ( callbackfn [ , thisArg ] ) // From https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/forEach if (!Array.prototype.forEach) { Array.prototype.forEach = function (fun /*, thisp */) { if (this === void 0 || this === null) { throw TypeError(); } var t = Object(this); var len = t.length >>> 0; if (typeof fun !== "function") { throw TypeError(); } var thisp = arguments[1], i; for (i = 0; i < len; i++) { if (i in t) { fun.call(thisp, t[i], i, t); } } }; } // ES5 15.4.4.19 Array.prototype.map ( callbackfn [ , thisArg ] ) // From https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/Map if (!Array.prototype.map) { Array.prototype.map = function (fun /*, thisp */) { if (this === void 0 || this === null) { throw TypeError(); } var t = Object(this); var len = t.length >>> 0; if (typeof fun !== "function") { throw TypeError(); } var res = []; res.length = len; var thisp = arguments[1], i; for (i = 0; i < len; i++) { if (i in t) { res[i] = fun.call(thisp, t[i], i, t); } } return res; }; } // ES5 15.4.4.20 Array.prototype.filter ( callbackfn [ , thisArg ] ) // From https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/Filter if (!Array.prototype.filter) { Array.prototype.filter = function (fun /*, thisp */) { if (this === void 0 || this === null) { throw TypeError(); } var t = Object(this); var len = t.length >>> 0; if (typeof fun !== "function") { throw TypeError(); } var res = []; var thisp = arguments[1], i; for (i = 0; i < len; i++) { if (i in t) { var val = t[i]; // in case fun mutates this if (fun.call(thisp, val, i, t)) { res.push(val); } } } return res; }; } // ES5 15.4.4.21 Array.prototype.reduce ( callbackfn [ , initialValue ] ) // From https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/Reduce if (!Array.prototype.reduce) { Array.prototype.reduce = function (fun /*, initialValue */) { if (this === void 0 || this === null) { throw TypeError(); } var t = Object(this); var len = t.length >>> 0; if (typeof fun !== "function") { throw TypeError(); } // no value to return if no initial value and an empty array if (len === 0 && arguments.length === 1) { throw TypeError(); } var k = 0; var accumulator; if (arguments.length >= 2) { accumulator = arguments[1]; } else { do { if (k in t) { accumulator = t[k++]; break; } // if array contains no values, no initial value to return if (++k >= len) { throw TypeError(); } } while (true); } while (k < len) { if (k in t) { accumulator = fun.call(undefined, accumulator, t[k], k, t); } k++; } return accumulator; }; } // ES5 15.4.4.22 Array.prototype.reduceRight ( callbackfn [, initialValue ] ) // From https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/ReduceRight if (!Array.prototype.reduceRight) { Array.prototype.reduceRight = function (callbackfn /*, initialValue */) { if (this === void 0 || this === null) { throw TypeError(); } var t = Object(this); var len = t.length >>> 0; if (typeof callbackfn !== "function") { throw TypeError(); } // no value to return if no initial value, empty array if (len === 0 && arguments.length === 1) { throw TypeError(); } var k = len - 1; var accumulator; if (arguments.length >= 2) { accumulator = arguments[1]; } else { do { if (k in this) { accumulator = this[k--]; break; } // if array contains no values, no initial value to return if (--k < 0) { throw TypeError(); } } while (true); } while (k >= 0) { if (k in t) { accumulator = callbackfn.call(undefined, accumulator, t[k], k, t); } k--; } return accumulator; }; } //---------------------------------------------------------------------- // ES5 15.5 String Objects //---------------------------------------------------------------------- // // ES5 15.5.4 Properties of the String Prototype Object // // ES5 15.5.4.20 String.prototype.trim() if (!String.prototype.trim) { String.prototype.trim = function () { return String(this).replace(/^\s+/, '').replace(/\s+$/, ''); }; } //---------------------------------------------------------------------- // ES5 15.9 Date Objects //---------------------------------------------------------------------- // // ES 15.9.4 Properties of the Date Constructor // // ES5 15.9.4.4 Date.now ( ) // From https://developer.mozilla.org/en/Core_JavaScript_1.5_Reference/Global_Objects/Date/now if (!Date.now) { Date.now = function now() { return Number(new Date()); }; } // // ES5 15.9.5 Properties of the Date Prototype Object // // ES5 15.9.4.43 Date.prototype.toISOString ( ) // Inspired by http://www.json.org/json2.js if (!Date.prototype.toISOString) { Date.prototype.toISOString = function () { function pad2(n) { return ('00' + n).slice(-2); } function pad3(n) { return ('000' + n).slice(-3); } return this.getUTCFullYear() + '-' + pad2(this.getUTCMonth() + 1) + '-' + pad2(this.getUTCDate()) + 'T' + pad2(this.getUTCHours()) + ':' + pad2(this.getUTCMinutes()) + ':' + pad2(this.getUTCSeconds()) + '.' + pad3(this.getUTCMilliseconds()) + 'Z'; }; } //---------------------------------------------------------------------- // // ECMAScript 2015 Polyfills // //---------------------------------------------------------------------- (function (global) { "use strict"; // Set this to always override native implementations, for testing // the polyfill in browsers with partial/full ES2015 support. var OVERRIDE_NATIVE_FOR_TESTING = false; var undefined = (void 0); // Paranoia // Helpers function strict(o) { return o === global ? undefined : o; } function isSymbol(s) { return (typeof s === 'symbol') || ('Symbol' in global && s instanceof global.Symbol); } function getPropertyDescriptor(target, name) { var desc = Object.getOwnPropertyDescriptor(target, name); var proto = Object.getPrototypeOf(target); while (!desc && proto) { desc = Object.getOwnPropertyDescriptor(proto, name); proto = Object.getPrototypeOf(proto); } return desc; } var enqueue = (function(nativePromise, nativeSetImmediate) { if (nativePromise) return function(job) { nativePromise.resolve().then(function() { job(); }); }; if (nativeSetImmediate) return function(job) { nativeSetImmediate(job); }; return function(job) { setTimeout(job, 0); }; }(global['Promise'], global['setImmediate'])); function define(o, p, v, override) { if (p in o && !override && !OVERRIDE_NATIVE_FOR_TESTING) return; if (typeof v === 'function') { // Sanity check that functions are appropriately named (where possible) console.assert(isSymbol(p) || !('name' in v) || v.name === p || v.name === p + '_', 'Expected function name "' + p.toString() + '", was "' + v.name + '"'); Object.defineProperty(o, p, { value: v, configurable: true, enumerable: false, writable: true }); } else { Object.defineProperty(o, p, { value: v, configurable: false, enumerable: false, writable: false }); } } function set_internal(o, p, v) { Object.defineProperty(o, p, { value: v, configurable: false, enumerable: false, writable: true }); } // Snapshot intrinsic functions var $isNaN = global.isNaN, $parseInt = global.parseInt, $parseFloat = global.parseFloat; var E = Math.E, LOG10E = Math.LOG10E, LOG2E = Math.LOG2E, abs = Math.abs, ceil = Math.ceil, exp = Math.exp, floor = Math.floor, log = Math.log, max = Math.max, min = Math.min, pow = Math.pow, random = Math.random, sqrt = Math.sqrt; var orig_match = String.prototype.match, orig_replace = String.prototype.replace, orig_search = String.prototype.search, orig_split = String.prototype.split; // These are used for implementing the polyfills, but not exported. // Inspired by https://gist.github.com/1638059 /** @constructor */ function EphemeronTable() { var secretKey = ObjectCreate(null); function conceal(o) { var oValueOf = o.valueOf, secrets = ObjectCreate(null); Object.defineProperty(o, 'valueOf', { value: (function(secretKey) { return function (k) { return (k === secretKey) ? secrets : oValueOf.apply(o, arguments); }; }(secretKey)), configurable: true, writeable: true, enumerable: false }); return secrets; } function reveal(o) { var v = typeof o.valueOf === 'function' && o.valueOf(secretKey); return v === o ? null : v; } return { clear: function() { secretKey = ObjectCreate(null); }, remove: function(key) { var secrets = reveal(key); if (secrets && HasOwnProperty(secrets, 'value')) { delete secrets.value; return true; } return false; }, get: function(key, defaultValue) { var secrets = reveal(key); return (secrets && HasOwnProperty(secrets, 'value')) ? secrets.value : defaultValue; }, has: function(key) { var secrets = reveal(key); return Boolean(secrets && HasOwnProperty(secrets, 'value')); }, set: function(key, value) { var secrets = reveal(key) || conceal(key); secrets.value = value; } }; } var empty = Object.create(null); //---------------------------------------------------------------------- // // ECMAScript 2015 // http://www.ecma-international.org/ecma-262/6.0/ // //---------------------------------------------------------------------- // --------------------------------------- // 19.4 Symbol Objects // --------------------------------------- // NOTE: Symbols are defined here - out of spec order - since we need the // properties and prototype to be populated for other polyfills. // NOTE: Not secure, nor is obj[$$symbol] hidden from Object.keys() var symbolForKey; (function() { var secret = Object.create(null); var symbolMap = {}; symbolForKey = function(k) { return symbolMap[k]; }; var GlobalSymbolRegistry = []; function unique(bits) { return Array(bits + 1).join('x').replace(/x/g, function() { return random() < 0.5 ? '\u200C' : '\u200D'; // JWNJ / ZWJ }); } // 19.4.1 The Symbol Constructor // 19.4.1.1 Symbol ( description=undefined ) function Symbol(description) { if (!(this instanceof Symbol)) return new Symbol(description, secret); if (this instanceof Symbol && arguments[1] !== secret) throw TypeError(); var descString = description === undefined ? undefined : String(description); set_internal(this, '[[SymbolData]]', unique(128)); set_internal(this, '[[Description]]', descString); symbolMap[this] = this; return this; } if (!('Symbol' in global) || OVERRIDE_NATIVE_FOR_TESTING) global.Symbol = Symbol; // 19.4.2 Properties of the Symbol Constructor // 19.4.2.1 Symbol.for (key) define(Symbol, 'for', function for_(key) { var stringKey = String(key); for (var i = 0; i < GlobalSymbolRegistry.length; ++i) { var e = GlobalSymbolRegistry[i]; if (SameValue(e['[[key]]'], stringKey)) return e['[[symbol]]']; } var newSymbol = Symbol(key); GlobalSymbolRegistry.push({'[[key]]': stringKey, '[[symbol]]': newSymbol}); return newSymbol; }); // 19.4.2.2 Symbol.hasInstance // 19.4.2.3 Symbol.isConcatSpreadable // 19.4.2.4 Symbol.iterator define(global.Symbol, 'iterator', global.Symbol('Symbol.iterator')); // 19.4.2.5 Symbol.keyFor (sym) define(Symbol, 'keyFor', function keyFor(sym) { if (!(sym instanceof Symbol)) throw TypeError(); for (var i = 0; i < GlobalSymbolRegistry.length; ++i) { var e = GlobalSymbolRegistry[i]; if (SameValue(e['[[symbol]]'], sym)) return e['[[key]]']; } return undefined; }); // 19.4.2.6 Symbol.match define(global.Symbol, 'match', global.Symbol('Symbol.match')); // 19.4.2.7 Symbol.prototype // 19.4.2.8 Symbol.replace define(global.Symbol, 'replace', global.Symbol('Symbol.replace')); // 19.4.2.9 Symbol.search define(global.Symbol, 'search', global.Symbol('Symbol.search')); // 19.4.2.10 Symbol.species // 19.4.2.11 Symbol.search define(global.Symbol, 'split', global.Symbol('Symbol.split')); // 19.4.2.12 Symbol.toPrimitive // 19.4.2.13 Symbol.toStringTag define(global.Symbol, 'toStringTag', global.Symbol('Symbol.toStringTag')); // 19.4.2.14 Symbol.unscopables // 19.4.3 Properties of the Symbol Prototype Object // 19.4.3.1 Symbol.prototype.constructor // 19.4.3.2 Symbol.prototype.toString ( ) Object.defineProperty(Symbol.prototype, 'toString', { value: function toString() { var s = strict(this); var desc = s['[[Description]]']; return 'Symbol(' + (desc === undefined ? '' : desc) + s['[[SymbolData]]'] + ')'; }, configurable: true, writeable: true, enumerable: false }); // 19.4.3.3 Symbol.prototype.valueOf ( ) Object.defineProperty(Symbol.prototype, 'valueOf', { value: function valueOf() { // To prevent automatic string conversion: throw TypeError(); // Spec has approximately the following: //var s = strict(this); //if (Type(s) === 'symbol') return s; //if (Type(s) !== 'object') throw TypeError(); //if (!('[[SymbolData]]' in s)) throw TypeError(); //return s['[[SymbolData]]']; }, configurable: true, writeable: true, enumerable: false }); // 19.4.3.4 Symbol.prototype [ @@toStringTag ] // (Done later to polyfill partial implementations) // 19.4.4 Properties of Symbol Instances }()); console.assert(typeof global.Symbol() === 'symbol' || symbolForKey(String(global.Symbol('x'))) !== undefined); // Defined here so that other prototypes can reference it // 25.1.2 The %IteratorPrototype% Object var $IteratorPrototype$ = {}; //---------------------------------------- // 6 ECMAScript Data Types and Values //---------------------------------------- // 6.1 ECMAScript Language Types // "Type(x)" is used as shorthand for "the type of x"... function Type(v) { switch (typeof v) { case 'undefined': return 'undefined'; case 'boolean': return 'boolean'; case 'number': return 'number'; case 'string': return 'string'; case 'symbol': return 'symbol'; default: if (v === null) return 'null'; if (v instanceof global.Symbol) return 'symbol'; return 'object'; } } // 6.1.5.1 Well-Known Symbols var $$iterator = global.Symbol.iterator, $$match = global.Symbol.match, $$replace = global.Symbol.replace, $$search = global.Symbol.search, $$split = global.Symbol.split, $$toStringTag = global.Symbol.toStringTag; //---------------------------------------- // 7 Abstract Operations //---------------------------------------- //---------------------------------------- // 7.1 Type Conversion //---------------------------------------- // 7.1.1 ToPrimitive ( input [, PreferredType] ) // just use valueOf() // 7.1.2 ToBoolean ( argument ) // just use Boolean() // 7.1.3 ToNumber ( argument ) // just use Number() // 7.1.4 ToInteger ( argument ) function ToInteger(n) { n = Number(n); if ($isNaN(n)) return 0; if (n === 0 || n === Infinity || n === -Infinity) return n; return ((n < 0) ? -1 : 1) * floor(abs(n)); } // 7.1.5 ToInt32 ( argument ) function ToInt32(v) { return v >> 0; } // 7.1.6 ToUint32 ( argument ) function ToUint32(v) { return v >>> 0; } // 7.1.7 ToInt16 ( argument ) function ToInt16(v) { return (v << 16) >> 16; } // 7.1.8 ToUint16 ( argument ) function ToUint16(v) { return v & 0xFFFF; } // 7.1.9 ToInt8 ( argument ) function ToInt8(v) { return (v << 24) >> 24; } // 7.1.10 ToUint8 ( argument ) function ToUint8(v) { return v & 0xFF; } // 7.1.11 ToUint8Clamp ( argument ) function ToUint8Clamp(argument) { var number = Number(argument); if ($isNaN(number)) return 0; if (number <= 0) return 0; if (number >= 255) return 255; var f = floor(number); if ((f + 0.5) < number) return f + 1; if (number < (f + 0.5)) return f; if (f % 2) return f + 1; return f; } // 7.1.12 ToString ( argument ) // just use String() // 7.1.13 ToObject ( argument ) function ToObject(v) { if (v === null || v === undefined) throw TypeError(); return Object(v); } // 7.1.14 ToPropertyKey ( argument ) function ToPropertyKey(v) { return String(v); } // 7.1.15 ToLength ( argument ) function ToLength(v) { var len = ToInteger(v); if (len <= 0) return 0; if (len === Infinity) return 0x20000000000000 - 1; // 2^53-1 return min(len, 0x20000000000000 - 1); // 2^53-1 } // 7.1.16 CanonicalNumericIndexString ( argument ) //---------------------------------------- // 7.2 Testing and Comparison Operations //---------------------------------------- // 7.2.1 RequireObjectCoercible ( argument ) // 7.2.2 IsArray ( argument ) // 7.2.3 IsCallable ( argument ) function IsCallable(o) { return typeof o === 'function'; } // 7.2.4 IsConstructor ( argument ) function IsConstructor(o) { // Hacks for Safari 7 TypedArray XXXConstructor objects if (/Constructor/.test(Object.prototype.toString.call(o))) return true; if (/Function/.test(Object.prototype.toString.call(o))) return true; // TODO: Can this be improved on? return typeof o === 'function'; } // 7.2.5 IsExtensible (O) // 7.2.6 IsInteger ( argument ) // 7.2.7 IsPropertyKey ( argument ) function IsPropertyKey(argument) { if (Type(argument) === 'string') return true; if (Type(argument) === 'symbol') return true; return false; } // 7.2.8 IsRegExp ( argument ) // 7.2.9 SameValue(x, y) function SameValue(x, y) { if (typeof x !== typeof y) return false; switch (typeof x) { case 'undefined': return true; case 'number': if (x !== x && y !== y) return true; if (x === 0 && y === 0) return 1/x === 1/y; return x === y; case 'boolean': case 'string': case 'object': default: return x === y; } } // 7.2.10 SameValueZero(x, y) function SameValueZero(x, y) { if (typeof x !== typeof y) return false; switch (typeof x) { case 'undefined': return true; case 'number': if (x !== x && y !== y) return true; return x === y; case 'boolean': case 'string': case 'object': default: return x === y; } } //---------------------------------------- // 7.3 Operations on Objects //---------------------------------------- // 7.3.1 Get (O, P) // - just use o.p or o[p] // 7.3.2 GetV (V, P) function GetV(v, p) { var o = ToObject(v); return o[p]; } // 7.3.3 Set (O, P, V, Throw) // - just use o.p = v or o[p] = v // 7.3.9 GetMethod (O, P) function GetMethod(o, p) { var func = GetV(o, p); if (func === undefined || func === null) return undefined; if (!IsCallable(func)) throw TypeError(); return func; } // 7.3.10 HasProperty (O, P) function HasProperty(o, p) { while (o) { if (Object.prototype.hasOwnProperty.call(o, p)) return true; if (Type(o) !== 'object') return false; var op = Object.getPrototypeOf(o); if (op === o) return false; // IE8 has self-referential prototypes o = op; } return false; } // 7.3.11 HasOwnProperty (O, P) function HasOwnProperty(o, p) { return Object.prototype.hasOwnProperty.call(o, p); } //---------------------------------------- // 7.4 Operations on Iterator Objects //---------------------------------------- // 7.4.1 GetIterator ( obj, method ) function GetIterator(obj, method) { if (arguments.length < 2) method = GetMethod(obj, $$iterator); var iterator = method.call(obj); if (Type(iterator) !== 'object') throw TypeError(); return iterator; } // 7.4.2 IteratorNext ( iterator, value ) function IteratorNext(iterator, value) { if (arguments.length < 2) var result = iterator.next(); else result = iterator.next(value); if (Type(result) !== 'object') throw TypeError(); return result; } // 7.4.3 IteratorComplete ( iterResult ) function IteratorComplete(iterResult) { console.assert(Type(iterResult) === 'object'); return Boolean(iterResult.done); } // 7.4.4 IteratorValue ( iterResult ) function IteratorValue(iterResult) { console.assert(Type(iterResult) === 'object'); return iterResult.value; } // 7.4.5 IteratorStep ( iterator ) function IteratorStep( iterator, value ) { var result = IteratorNext(iterator, value); var done = result['done']; if (Boolean(done) === true) return false; return result; } // 7.4.6 IteratorClose( iterator, completion ) function IteratorClose( iterator, completion ) { console.assert(Type(iterator) === 'object'); var _return = GetMethod(iterator, 'return'); if (_return === undefined) return completion; try { var innerResult = _return[iterator](); } catch (result) { // TODO: If completion.[[type]] is throw, return completion return result; } if (Type(innerResult) !== 'object') throw TypeError(); return completion; } // 7.4.7 CreateIterResultObject (value, done) function CreateIterResultObject(value, done) { console.assert(Type(done) === 'boolean'); var obj = {}; obj["value"] = value; obj["done"] = done; return obj; } // 7.4.8 CreateListIterator (list) // 7.4.8.1 ListIterator next( ) //---------------------------------------- // 8 Executable Code and Execution Contexts //---------------------------------------- //---------------------------------------- // 8.4 Jobs and Job Queues //---------------------------------------- // 8.4.1 EnqueueJob ( queueName, job, arguments) function EnqueueJob(queueName, job, args) { var fn = function() { job.apply(undefined, args); }; enqueue(fn); } // 8.4.2 NextJob result function NextJob(result) { // no-op } //---------------------------------------- // 9 Ordinary and Exotic Objects Behaviors //---------------------------------------- // 9.1.11 [[Enumerate]] () function Enumerate(obj) { var e = []; if (Object(obj) !== obj) return e; var visited = new Set; while (obj !== null) { Object.getOwnPropertyNames(obj).forEach(function(name) { if (!visited.has(name)) { var desc = Object.getOwnPropertyDescriptor(obj, name); if (desc) { visited.add(name); if (desc.enumerable) e.push(name); } } }); obj = Object.getPrototypeOf(obj); } return e[$$iterator](); } // 9.1.12 [[OwnPropertyKeys]] ( ) function OwnPropertyKeys(o) { return Object.getOwnPropertyNames(o); } // 9.1.13 ObjectCreate(proto, internalSlotsList) function ObjectCreate(proto, internalSlotsList) { return Object.create(proto, internalSlotsList); } // --------------------------------------- // 19 Fundamental Objects // --------------------------------------- // --------------------------------------- // 19.1 Object Objects // --------------------------------------- // 19.1.1 The Object Constructor // 19.1.1.1 Object ( [ value ] ) // 19.1.2 Properties of the Object Constructor // 19.1.2.1 Object.assign ( target, ...sources ) define( Object, 'assign', function assign(target, /*...*/sources) { var to = ToObject(target); if (arguments.length < 2) return to; var sourcesIndex = 1; while (sourcesIndex < arguments.length) { var nextSource = arguments[sourcesIndex++]; if (nextSource === undefined || nextSource === null) { var keys = []; } else { var from = ToObject(nextSource); keys = OwnPropertyKeys(from); } for (var keysIndex = 0; keysIndex < keys.length; ++keysIndex) { var nextKey = keys[keysIndex]; var desc = Object.getOwnPropertyDescriptor(from, nextKey); if (desc !== undefined && desc.enumerable) { var propValue = from[nextKey]; to[nextKey] = propValue; } } } return to; }); // 19.1.2.2 Object.create ( O [ , Properties ] ) // 19.1.2.3 Object.defineProperties ( O, Properties ) // 19.1.2.4 Object.defineProperty ( O, P, Attributes ) // 19.1.2.5 Object.freeze ( O ) // 19.1.2.6 Object.getOwnPropertyDescriptor ( O, P ) (function() { var nativeSymbols = (typeof global.Symbol() === 'symbol'), $getOwnPropertyNames = Object.getOwnPropertyNames, $keys = Object.keys, $window_names = (typeof window === 'object' ? $getOwnPropertyNames(window) : []); function isStringKey(k) { return !symbolForKey(k); } // 19.1.2.7 Object.getOwnPropertyNames ( O ) define( Object, 'getOwnPropertyNames', function getOwnPropertyNames(o) { if (Object.prototype.toString.call(o) === '[object Window]') { // Workaround for cross-realm calling by IE itself. // https://github.com/inexorabletash/polyfill/issues/96 try { return $getOwnPropertyNames(o).filter(isStringKey); } catch (_) { return $window_names.slice(); } } return $getOwnPropertyNames(o).filter(isStringKey); }, !nativeSymbols); // 19.1.2.8 Object.getOwnPropertySymbols ( O ) define( Object, 'getOwnPropertySymbols', function getOwnPropertySymbols(o) { return $getOwnPropertyNames(o).filter(symbolForKey).map(symbolForKey); }, !nativeSymbols); // 19.1.2.14 Object.keys ( O ) define( Object, 'keys', function keys(o) { return $keys(o).filter(isStringKey); }, !nativeSymbols); }()); // 19.1.2.9 Object.getPrototypeOf ( O ) // 19.1.2.10 Object.is ( value1, value2 ) define( Object, 'is', function is(value1, value2) { return SameValue(value1, value2); }); // 19.1.2.11 Object.isExtensible ( O ) // 19.1.2.12 Object.isFrozen ( O ) // 19.1.2.13 Object.isSealed ( O ) // 19.1.2.14 Object.keys ( O ) // see above // 19.1.2.15 Object.preventExtensions ( O ) // 19.1.2.16 Object.prototype // 19.1.2.17 Object.seal ( O ) // 19.1.2.18 Object.setPrototypeOf ( O, proto ) define( Object, 'setPrototypeOf', function setPrototypeOf(o, proto) { if (Type(o) !== 'object') throw TypeError(); if (Type(proto) !== 'object' && Type(proto) !== 'null') throw TypeError(); o.__proto__ = proto; return o; } ); // 19.1.3 Properties of the Object Prototype Object // 19.1.3.1 Object.prototype.constructor // 19.1.3.2 Object.prototype.hasOwnProperty ( V ) // 19.1.3.3 Object.prototype.isPrototypeOf ( V ) // 19.1.3.4 Object.prototype.propertyIsEnumerable ( V ) // 19.1.3.5 Object.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] ) // 19.1.3.6 Object.prototype.toString ( ) var o_p_ts = Object.prototype.toString; define(Object.prototype, 'toString', function() { var o = strict(this); if (o === Object(o) && $$toStringTag in o) { return '[object ' + o[$$toStringTag] + ']'; } return o_p_ts.apply(o, arguments); }); // 19.1.3.7 Object.prototype.valueOf ( ) // 19.1.4 Properties of Object Instances // --------------------------------------- // 19.2 Function Objects // --------------------------------------- // 19.2.1 The Function Constructor // 19.2.1.1 Function ( p1, p2, … , pn, body ) // 19.2.2 Properties of the Function Constructor // 19.2.2.1 Function.length // 19.2.2.2 Function.prototype // 19.2.3 Properties of the Function Prototype Object // 19.2.3.1 Function.prototype.apply ( thisArg, argArray ) // 19.2.3.2 Function.prototype.bind ( thisArg , ...args) // 19.2.3.3 Function.prototype.call (thisArg , ...args) // 19.2.3.4 Function.prototype.constructor // 19.2.3.5 Function.prototype.toString ( ) // 19.2.3.6 Function.prototype[@@hasInstance] ( V ) // 19.2.4 Function Instances // 19.2.4.1 length // 19.2.4.2 name // 19.2.4.3 prototype // (No polyfillable changes from ES5) // --------------------------------------- // 19.3 Boolean Objects // --------------------------------------- // 19.3.1 The Boolean Constructor // 19.3.1.1 Boolean ( value ) // 19.3.2 Properties of the Boolean Constructor // 19.3.2.1 Boolean.prototype // 19.3.3 Properties of the Boolean Prototype Object // 19.3.3.1 Boolean.prototype.constructor // 19.3.3.2 Boolean.prototype.toString ( ) // 19.3.3.3 Boolean.prototype.valueOf ( ) // 19.3.4 Properties of Boolean Instances // (No polyfillable changes from ES5) // --------------------------------------- // 19.4 Symbol Objects // --------------------------------------- // Moved earlier in this script, so that other polyfills can depend on them. // 19.4.3.4 Symbol.prototype [ @@toStringTag ] define(global.Symbol.prototype, global.Symbol.toStringTag, 'Symbol'); // --------------------------------------- // 19.5 Error Objects // --------------------------------------- // 19.5.1 The Error Constructor // 19.5.1.1 Error ( message ) // 19.5.1.2 new Error( ...argumentsList ) // 19.5.2 Properties of the Error Constructor // 19.5.2.1 Error.prototype // 19.5.3 Properties of the Error Prototype Object // 19.5.3.1 Error.prototype.constructor // 19.5.3.2 Error.prototype.message // 19.5.3.3 Error.prototype.name // 19.5.3.4 Error.prototype.toString ( ) // 19.5.4 Properties of Error Instances // 19.5.5 Native Error Types Used in This Standard // 19.5.5.1 EvalError // 19.5.5.2 RangeError // 19.5.5.3 ReferenceError // 19.5.5.4 SyntaxError // 19.5.5.5 TypeError // 19.5.5.6 URIError // 19.5.6 NativeError Object Structure // 19.5.6.1 NativeError Constructors // 19.5.6.1.1 NativeError ( message ) // 19.5.6.1.2 new NativeError ( ...argumentsList ) // 19.5.6.2 Properties of the NativeError Constructors // 19.5.6.2.1 NativeError.prototype // 19.5.6.3 Properties of the NativeError Prototype Objects // 19.5.6.4 Properties of NativeError Instances // (No polyfillable changes from ES5) // --------------------------------------- // 20 Numbers and Dates // --------------------------------------- // --------------------------------------- // 20.1 Number Objects // --------------------------------------- // 20.1.1 The Number Constructor // 20.1.1.1 Number ( [ value ] ) // 20.1.1.2 new Number ( ...argumentsList ) // 20.1.2 Properties of the Number Constructor // 20.1.2.1 Number.EPSILON define( Number, 'EPSILON', (function () { var next, result; for (next = 1; 1 + next !== 1; next = next / 2) result = next; return result; }())); // 20.1.2.2 Number.isFinite ( number ) define( Number, 'isFinite', function isFinite(number) { if (Type(number) !== 'number') return false; if (number !== number || number === +Infinity || number === -Infinity) return false; return true; }); // 20.1.2.3 Number.isInteger ( number ) define( Number, 'isInteger', function isInteger(number) { if (Type(number) !== 'number') return false; if (number !== number || number === +Infinity || number === -Infinity) return false; var integer = ToInteger(number); if (integer !== number) return false; return true; }); // 20.1.2.4 Number.isNaN ( number ) define( Number, 'isNaN', function isNaN(number) { if (Type(number) !== 'number') return false; if (number !== number) return true; return false; }); // 20.1.2.5 Number.isSafeInteger ( number ) define( Number, 'isSafeInteger', function isSafeInteger(number) { if (Type(number) !== 'number') return false; if (number !== number || number === +Infinity || number === -Infinity) return false; var integer = ToInteger(number); if (integer !== number) return false; if (abs(integer) <= (0x20000000000000 - 1)) // 2^53-1 return true; return false; }); // 20.1.2.6 Number.MAX_SAFE_INTEGER define( Number, 'MAX_SAFE_INTEGER', 9007199254740991); // 2^53-1 // 20.1.2.7 Number.MAX_VALUE // 20.1.2.8 Number.MIN_SAFE_INTEGER define( Number, 'MIN_SAFE_INTEGER', -9007199254740991); // -2^53+1 // 20.1.2.9 Number.MIN_VALUE // 20.1.2.10 Number.NaN // 20.1.2.11 Number.NEGATIVE_INFINITY // 20.1.2.12 Number.parseFloat ( string ) define(Number, 'parseFloat', $parseFloat); // 20.1.2.13 Number.parseInt ( string, radix ) define(Number, 'parseInt', $parseInt); // 20.1.2.14 Number.POSITIVE_INFINITY // 20.1.2.15 Number.prototype // 20.1.3 Properties of the Number Prototype Object // 20.1.3.1 Number.prototype.constructor // 20.1.3.2 Number.prototype.toExponential ( fractionDigits ) // 20.1.3.3 Number.prototype.toFixed ( fractionDigits ) // 20.1.3.4 Number.prototype.toLocaleString( [ reserved1 [ , reserved2 ] ]) // 20.1.3.5 Number.prototype.toPrecision ( precision ) // 20.1.3.6 Number.prototype.toString ( [ radix ] ) // 20.1.3.7 Number.prototype.valueOf ( ) // 20.1.4 Properties of Number Instances // --------------------------------------- // 20.2 The Math Object // --------------------------------------- // 20.2.1 Value Properties of the Math Object // 20.2.1.1 Math.E // 20.2.1.2 Math.LN10 // 20.2.1.3 Math.LN2 // 20.2.1.4 Math.LOG10E // 20.2.1.5 Math.LOG2E // 20.2.1.6 Math.PI // 20.2.1.7 Math.SQRT1_2 // 20.2.1.8 Math.SQRT2 // 20.2.1.9 Math [ @@toStringTag ] define(Math, $$toStringTag, 'Math'); // 20.2.2 Function Properties of the Math Object // 20.2.2.1 Math.abs ( x ) // 20.2.2.2 Math.acos ( x ) // 20.2.2.3 Math.acosh(x) define( Math, 'acosh', function acosh(x) { x = Number(x); return log(x + sqrt(x * x - 1)); }); // 20.2.2.4 Math.asin ( x ) // 20.2.2.5 Math.asinh( x ) define( Math, 'asinh', function asinh(x) { x = Number(x); if (SameValue(x, -0)) { return x; } var s = sqrt(x * x + 1); return (s === -x) ? log(0) : log(x + s); }); // 20.2.2.6 Math.atan ( x ) // 20.2.2.7 Math.atanh( x ) define( Math, 'atanh', function atanh(x) { x = Number(x); return (x === 0) ? x : log((1 + x) / (1 - x)) / 2; }); // 20.2.2.8 Math.atan2 ( y, x ) // 20.2.2.9 Math.cbrt ( x ) define( Math, 'cbrt', function cbrt(x) { x = Number(x); if ($isNaN(x/x)) { return x; } var r = pow(abs(x), 1/3); var t = x/r/r; return r + (r * (t-r) / (2*r + t)); }); // 20.2.2.10 Math.ceil ( x ) // 20.2.2.11 Math.clz32 ( x ) define( Math, 'clz32', function clz32(x) { function clz8(x) { return (x & 0xf0) ? (x & 0x80 ? 0 : x & 0x40 ? 1 : x & 0x20 ? 2 : 3) : (x & 0x08 ? 4 : x & 0x04 ? 5 : x & 0x02 ? 6 : x & 0x01 ? 7 : 8); } x = ToUint32(x); return x & 0xff000000 ? clz8(x >> 24) : x & 0xff0000 ? clz8(x >> 16) + 8 : x & 0xff00 ? clz8(x >> 8) + 16 : clz8(x) + 24; }); // 20.2.2.12 Math.cos ( x ) // 20.2.2.13 Math.cosh ( x ) define( Math, 'cosh', function cosh(x) { x = Number(x); return (pow(E, x) + pow(E, -x)) / 2; }); // 20.2.2.14 Math.exp ( x ) // 20.2.2.15 Math.expm1 ( x ) define( Math, 'expm1', function expm1(x) { x = Number(x); // from: http://www.johndcook.com/cpp_log1p.html if (SameValue(x, -0)) { return -0; } else if (abs(x) < 1e-5) { return x + 0.5 * x * x; // two terms of Taylor expansion } else { return exp(x) - 1; } }); // 20.2.2.16 Math.floor ( x ) // 20.2.2.17 Math.fround ( x ) define( Math, 'fround', function fround(x) { if ($isNaN(x)) { return NaN; } if (1/x === +Infinity || 1/x === -Infinity || x === +Infinity || x === -Infinity) { return x; } return (new Float32Array([x]))[0]; }); // 20.2.2.18 Math.hypot ( value1 [, value2 [ ... ] ] ) define( Math, 'hypot', function hypot() { var values = []; var m = 0, sawNaN = false; for (var i = 0; i < arguments.length; ++i) { var n = abs(Number(arguments[i])); if (n === Infinity) return n; if (n !== n) sawNaN = true; if (n > m) m = n; values[i] = n; } if (sawNaN) return NaN; if (m === 0) return +0; var sum = +0; for (i = 0; i < values.length; ++i) { var r = values[i] / m; sum = sum + r * r; } return m * sqrt(sum); }); // 20.2.2.19 Math.imul ( x, y ) define( Math, 'imul', function imul(x, y) { var a = ToUint32(x); var b = ToUint32(y); // (slow but accurate) var ah = (a >>> 16) & 0xffff; var al = a & 0xffff; var bh = (b >>> 16) & 0xffff; var bl = b & 0xffff; return ((al * bl) + (((ah * bl + al * bh) << 16) >>> 0)|0); }, ('imul' in Math && Math.imul(1, 0x80000000) === 0) // Safari 7 bug ); // 20.2.2.20 Math.log ( x ) // 20.2.2.21 Math.log1p ( x ) define( Math, 'log1p', function log1p(x) { x = Number(x); // from: http://www.johndcook.com/cpp_expm1.html if (x < -1) { return NaN; } else if (SameValue(x, -0)) { return -0; } else if (abs(x) > 1e-4) { return log(1 + x); } else { return (-0.5 * x + 1) * x; } }); // 20.2.2.22 Math.log10 ( x ) define( Math, 'log10', function log10(x) { x = Number(x); return log(x) * LOG10E; }); // 20.2.2.23 Math.log2 ( x ) define( Math, 'log2', function log2(x) { x = Number(x); return log(x) * LOG2E; }); // 20.2.2.24 Math.max ( value1, value2 , ...values ) // 20.2.2.25 Math.min ( value1, value2 , ...values ) // 20.2.2.26 Math.pow ( x, y ) // 20.2.2.27 Math.random ( ) // 20.2.2.28 Math.round ( x ) // 20.2.2.29 Math.sign(x) define( Math, 'sign', function sign(x) { x = Number(x); return x < 0 ? -1 : x > 0 ? 1 : x; }); // 20.2.2.30 Math.sin ( x ) // 20.2.2.31 Math.sinh( x ) define( Math, 'sinh', function sinh(x) { x = Number(x); return SameValue(x, -0) ? x : (pow(E, x) - pow(E, -x)) / 2; }); // 20.2.2.32 Math.sqrt ( x ) // 20.2.2.33 Math.tan ( x ) // 20.2.2.34 Math.tanh ( x ) define( Math, 'tanh', function tanh(x) { x = Number(x); var n = pow(E, 2 * x) - 1, d = pow(E, 2 * x) + 1; if (SameValue(x, -0)) return x; return (n === d) ? 1 : n / d; // Handle Infinity/Infinity }); // 20.2.2.35 Math.trunc ( x ) define( Math, 'trunc', function trunc(x) { x = Number(x); return $isNaN(x) ? NaN : x < 0 ? ceil(x) : floor(x); }); // --------------------------------------- // 20.3 Date Objects // --------------------------------------- // 20.3.1 Overview of Date Objects and Definitions of Abstract Operations // 20.3.1.1 Time Values and Time Range // 20.3.1.2 Day Number and Time within Day // 20.3.1.3 Year Number // 20.3.1.4 Month Number // 20.3.1.5 Date Number // 20.3.1.6 Week Day // 20.3.1.7 Local Time Zone Adjustment // 20.3.1.8 Daylight Saving Time Adjustment // 20.3.1.9 Local Time // 20.3.1.10 Hours, Minutes, Second, and Milliseconds // 20.3.1.11 MakeTime (hour, min, sec, ms) // 20.3.1.12 MakeDay (year, month, date) // 20.3.1.13 MakeDate (day, time) // 20.3.1.14 TimeClip (time) // 20.3.1.15 Date Time String Format // 20.3.1.15.1 Extended years // 20.3.2 The Date Constructor // 20.3.2.1 Date ( year, month [, date [ , hours [ , minutes [ , seconds [ , ms ] ] ] ] ] ) // 20.3.2.2 Date ( value ) // 20.3.2.3 Date ( ) // 20.3.3 Properties of the Date Constructor // 20.3.3.1 Date.now ( ) // 20.3.3.2 Date.parse (string) // 20.3.3.3 Date.prototype // 20.3.3.4 Date.UTC ( year, month [ , date [ , hours [ , minutes [ , seconds [ , ms ] ] ] ] ] ) // 20.3.4 Properties of the Date Prototype Object // 20.3.4.1 Date.prototype.constructor // 20.3.4.2 Date.prototype.getDate ( ) // 20.3.4.3 Date.prototype.getDay ( ) // 20.3.4.4 Date.prototype.getFullYear ( ) // 20.3.4.5 Date.prototype.getHours ( ) // 20.3.4.6 Date.prototype.getMilliseconds ( ) // 20.3.4.7 Date.prototype.getMinutes ( ) // 20.3.4.8 Date.prototype.getMonth ( ) // 20.3.4.9 Date.prototype.getSeconds ( ) // 20.3.4.10 Date.prototype.getTime ( ) // 20.3.4.11 Date.prototype.getTimezoneOffset ( ) // 20.3.4.12 Date.prototype.getUTCDate ( ) // 20.3.4.13 Date.prototype.getUTCDay ( ) // 20.3.4.14 Date.prototype.getUTCFullYear ( ) // 20.3.4.15 Date.prototype.getUTCHours ( ) // 20.3.4.16 Date.prototype.getUTCMilliseconds ( ) // 20.3.4.17 Date.prototype.getUTCMinutes ( ) // 20.3.4.18 Date.prototype.getUTCMonth ( ) // 20.3.4.19 Date.prototype.getUTCSeconds ( ) // 20.3.4.20 Date.prototype.setDate ( date ) // 20.3.4.21 Date.prototype.setFullYear ( year [ , month [ , date ] ] ) // 20.3.4.22 Date.prototype.setHours ( hour [ , min [ , sec [ , ms ] ] ] ) // 20.3.4.23 Date.prototype.setMilliseconds ( ms ) // 20.3.4.24 Date.prototype.setMinutes ( min [ , sec [ , ms ] ] ) // 20.3.4.25 Date.prototype.setMonth ( month [ , date ] ) // 20.3.4.26 Date.prototype.setSeconds ( sec [ , ms ] ) // 20.3.4.27 Date.prototype.setTime ( time ) // 20.3.4.28 Date.prototype.setUTCDate ( date ) // 20.3.4.29 Date.prototype.setUTCFullYear ( year [ , month [ , date ] ] ) // 20.3.4.30 Date.prototype.setUTCHours ( hour [ , min [ , sec [ , ms ] ] ] ) // 20.3.4.31 Date.prototype.setUTCMilliseconds ( ms ) // 20.3.4.32 Date.prototype.setUTCMinutes ( min [ , sec [, ms ] ] ) // 20.3.4.33 Date.prototype.setUTCMonth ( month [ , date ] ) // 20.3.4.34 Date.prototype.setUTCSeconds ( sec [ , ms ] ) // 20.3.4.35 Date.prototype.toDateString ( ) // 20.3.4.36 Date.prototype.toISOString ( ) // 20.3.4.37 Date.prototype.toJSON ( key ) // 20.3.4.38 Date.prototype.toLocaleDateString ( [ reserved1 [ , reserved2 ] ] ) // 20.3.4.39 Date.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] ) // 20.3.4.40 Date.prototype.toLocaleTimeString ( [ reserved1 [ , reserved2 ] ] ) // 20.3.4.41 Date.prototype.toString ( ) // 20.3.4.42 Date.prototype.toTimeString ( ) // 20.3.4.43 Date.prototype.toUTCString ( ) // 20.3.4.44 Date.prototype.valueOf ( ) // 20.3.4.45 Date.prototype [ @@toPrimitive ] ( hint ) // 20.3.5 Properties of Date Instances // (No polyfillable changes from ES5) // --------------------------------------- // 21 Text Processing // --------------------------------------- var string_regexp_dispatch = (function() { var faux = {}, secret = Symbol(); faux[Symbol.match] = function() { return secret; }; return ("").match(faux) === secret; }()); // 21.1 String Objects // 21.1.1 The String Constructor // 21.1.1.1 String ( value ) // 21.1.2 Properties of the String Constructor // 21.1.2.1 String.fromCharCode ( ...codeUnits ) // 21.1.2.2 String.fromCodePoint ( ...codePoints ) define( String, 'fromCodePoint', function fromCodePoint(/*...codePoints*/) { var codePoints = arguments, length = codePoints.length, elements = [], nextIndex = 0; while (nextIndex < length) { var next = codePoints[nextIndex]; var nextCP = Number(next); if (!SameValue(nextCP, ToInteger(nextCP)) || nextCP < 0 || nextCP > 0x10FFFF) { throw RangeError('Invalid code point ' + nextCP); } if (nextCP < 0x10000) { elements.push(String.fromCharCode(nextCP)); } else { nextCP -= 0x10000; elements.push(String.fromCharCode((nextCP >> 10) + 0xD800)); elements.push(String.fromCharCode((nextCP % 0x400) + 0xDC00)); } nextIndex += 1; } return elements.join(''); }); // 21.1.2.3 String.prototype // 21.1.2.4 String.raw ( template , ...substitutions ) define( String, 'raw', function raw(template /*, ...substitutions*/) { var substitutions = [].slice.call(arguments, 1); var cooked = Object(template); var rawValue = cooked['raw']; var raw = Object(rawValue); var len = raw['length']; var literalSegments = ToLength(len); if (literalSegments <= 0) return ''; var stringElements = []; var nextIndex = 0; while (true) { var next = raw[nextIndex]; var nextSeg = String(next); stringElements.push(nextSeg); if (nextIndex + 1 === literalSegments) return stringElements.join(''); next = substitutions[nextIndex]; var nextSub = String(next); stringElements.push(nextSub); nextIndex = nextIndex + 1; } }); // See https://githib.com/inexorabletash/uate for a more useful version. // 21.1.3 Properties of the String Prototype Object // 21.1.3.1 String.prototype.charAt ( pos ) // 21.1.3.2 String.prototype.charCodeAt ( pos ) // 21.1.3.3 String.prototype.codePointAt ( pos ) define( String.prototype, 'codePointAt', function codePointAt(pos) { var o = strict(this); var s = String(o); var position = ToInteger(pos); var size = s.length; if (position < 0 || position >= size) return undefined; var first = s.charCodeAt(position); if (first < 0xD800 || first > 0xDBFF || position + 1 === size) return first; var second = s.charCodeAt(position + 1); if (second < 0xDC00 || second > 0xDFFF) return first; return ((first - 0xD800) * 1024) + (second - 0xDC00) + 0x10000; }); // 21.1.3.4 String.prototype.concat ( ...args ) // 21.1.3.5 String.prototype.constructor // 21.1.3.6 String.prototype.endsWith ( searchString [ , endPosition] ) define( String.prototype, 'endsWith', function endsWith(searchString) { var endPosition = arguments[1]; var o = strict(this); var s = String(o); var searchStr = String(searchString); var len = s.length; var pos = (endPosition === undefined) ? len : ToInteger(endPosition); var end = min(max(pos, 0), len); var searchLength = searchStr.length; var start = end - searchLength; if (start < 0) return false; if (s.substring(start, start + searchLength) === searchStr) return true; return false; }); // 21.1.3.7 String.prototype.includes ( searchString [ , position ] ) define( String.prototype, 'includes', function includes(searchString) { var position = arguments[1]; var o = strict(this); var s = String(o); var searchStr = String(searchString); var pos = ToInteger(position); var len = s.length; var start = min(max(pos, 0), len); return s.indexOf(searchStr, start) !== -1; }); // 21.1.3.8 String.prototype.indexOf ( searchString [ , position ] ) // 21.1.3.9 String.prototype.lastIndexOf ( searchString [ , position ] ) // 21.1.3.10 String.prototype.localeCompare ( that [, reserved1 [ , reserved2 ] ] ) // 21.1.3.11 String.prototype.match ( regexp ) define( String.prototype, 'match', function match(regexp) { var o = strict(this); var s = String(o); if (HasProperty(regexp, $$match)) var rx = regexp; else rx = new RegExp(regexp); return rx[$$match](s); }, !string_regexp_dispatch); // 21.1.3.12 String.prototype.normalize ( [ form ] ) // Not practical due to table sizes; if needed, pull in: // https://github.com/walling/unorm/ // 21.1.3.13 String.prototype.repeat ( count ) define( String.prototype, 'repeat', function repeat(count) { var o = strict(this); var s = String(o); var n = ToInteger(count); if (n < 0) throw RangeError(); if (n === Infinity) throw RangeError(); var t = new Array(n + 1).join(s); return t; }); // 21.1.3.14 String.prototype.replace (searchValue, replaceValue ) define( String.prototype, 'replace', function replace(searchValue, replaceValue) { var o = strict(this); if (HasProperty(searchValue, $$replace)) return searchValue[$$replace](o, replaceValue); return orig_replace.call(o, searchValue, replaceValue); }, !string_regexp_dispatch); // 21.1.3.15 String.prototype.search ( regexp ) define( String.prototype, 'search', function search(regexp) { var o = strict(this); var string = String(o); if (HasProperty(regexp, $$search)) var rx = regexp; else rx = new RegExp(regexp); return rx[$$search](string); }, !string_regexp_dispatch); // 21.1.3.16 String.prototype.slice ( start, end ) // 21.1.3.17 String.prototype.split ( separator, limit ) define( String.prototype, 'split', function split(separator, limit) { var o = strict(this); if (HasProperty(separator, $$split)) return separator[$$split](o, limit); return orig_split.call(o, separator, limit); }, !string_regexp_dispatch); // 21.1.3.18 String.prototype.startsWith ( searchString [, position ] ) define( String.prototype, 'startsWith', function startsWith(searchString) { var position = arguments[1]; var o = strict(this); var s = String(o); var searchStr = String(searchString); var pos = ToInteger(position); var len = s.length; var start = min(max(pos, 0), len); var searchLength = searchStr.length; if (searchLength + start > len) return false; if (s.substring(start, start + searchLength) === searchStr) return true; return false; }); // 21.1.3.19 String.prototype.substring ( start, end ) // 21.1.3.20 String.prototype.toLocaleLowerCase ( [ reserved1 [ , reserved2 ] ] ) // 21.1.3.21 String.prototype.toLocaleUpperCase ([ reserved1 [ , reserved2 ] ] ) // 21.1.3.22 String.prototype.toLowerCase ( ) // 21.1.3.23 String.prototype.toString ( ) // 21.1.3.24 String.prototype.toUpperCase ( ) // 21.1.3.25 String.prototype.trim ( ) // 21.1.3.26 String.prototype.valueOf ( ) // 21.1.3.27 String.prototype [ @@iterator ]( ) define( String.prototype, $$iterator, function entries() { return CreateStringIterator(this, 'value'); }); // 21.1.4 Properties of String Instances // 21.1.4.1 length // 21.1.5 String Iterator Objects /** @constructor */ function StringIterator() {} // 21.1.5.1 CreateStringIterator Abstract Operation function CreateStringIterator(string, kind) { var s = String(string); var iterator = new StringIterator; set_internal(iterator, '[[IteratedString]]', s); set_internal(iterator, '[[StringIteratorNextIndex]]', 0); set_internal(iterator, '[[StringIterationKind]]', kind); return iterator; } // 21.1.5.2 The %StringIteratorPrototype% Object var $StringIteratorPrototype$ = Object.create($IteratorPrototype$); StringIterator.prototype = $StringIteratorPrototype$; // 21.1.5.2.1 %StringIteratorPrototype%.next ( ) define( $StringIteratorPrototype$, 'next', function next() { var o = ToObject(this); var s = String(o['[[IteratedString]]']), index = o['[[StringIteratorNextIndex]]'], len = s.length; if (index >= len) { set_internal(o, '[[StringIteratorNextIndex]]', Infinity); return CreateIterResultObject(undefined, true); } var cp = s.codePointAt(index); set_internal(o, '[[StringIteratorNextIndex]]', index + (cp > 0xFFFF ? 2 : 1)); return CreateIterResultObject(String.fromCodePoint(cp), false); }); // 21.1.5.2.2 %StringIteratorPrototype% [ @@toStringTag ] define($StringIteratorPrototype$, $$toStringTag, 'String Iterator'); // 21.1.5.3 Properties of String Iterator Instances // --------------------------------------- // 21.2 RegExp (Regular Expression) Objects // --------------------------------------- // 21.2.1 Patterns // 21.2.2 Pattern Semantics // 21.2.2.1 Notation // 21.2.2.2 Pattern // 21.2.2.3 Disjunction // 21.2.2.4 Alternative // 21.2.2.5 Term // 21.2.2.6 Assertion // 21.2.2.7 Quantifier // 21.2.2.8 Atom // 21.2.2.9 AtomEscape // 21.2.2.10 CharacterEscape // 21.2.2.11 DecimalEscape // 21.2.2.12 CharacterClassEscape // 21.2.2.13 CharacterClass // 21.2.2.14 ClassRanges // 21.2.2.15 NonemptyClassRanges // 21.2.2.16 NonemptyClassRangesNoDash // 21.2.2.17 ClassAtom // 21.2.2.18 ClassAtomNoDash // 21.2.2.19 ClassEscape // 21.2.3 The RegExp Constructor // 21.2.3.1 RegExp ( pattern, flags ) // 21.2.3.2 new RegExp( ...argumentsList ) // 21.2.3.3 Abstract Operations for the RegExp Constructor // 21.2.4 Properties of the RegExp Constructor // 21.2.4.1 RegExp.prototype // 21.2.5 Properties of the RegExp Prototype Object // 21.2.5.1 RegExp.prototype.constructor // 21.2.5.2 RegExp.prototype.exec ( string ) // 21.2.5.3 get RegExp.prototype.flags if (!('flags' in RegExp.prototype)) { Object.defineProperty( RegExp.prototype, 'flags', { get: function() { var s = String(this); return s.substring(s.lastIndexOf('/') + 1); } }); } // 21.2.5.4 get RegExp.prototype.global // 21.2.5.5 get RegExp.prototype.ignoreCase // 21.2.5.6 RegExp.prototype [ @@match ] ( string ) define(RegExp.prototype, $$match, function(string) { var o = strict(this); return orig_match.call(string, o); }); // 21.2.5.7 get RegExp.prototype.multiline // 21.2.5.8 RegExp.prototype [ @@replace ] ( string, replaceValue ) define(RegExp.prototype, $$replace, function(string, replaceValue) { var o = strict(this); return orig_replace.call(string, o, replaceValue); }); // 21.2.5.9 RegExp.prototype [ @@search ] ( string ) define(RegExp.prototype, $$search, function(string) { var o = strict(this); return orig_search.call(string, o); }); // 21.2.5.10 get RegExp.prototype.source // 21.2.5.11 RegExp.prototype [ @@split ] ( string, limit ) define(RegExp.prototype, $$split, function(string, limit) { var o = strict(this); return orig_split.call(string, o, limit); }); // 21.2.5.12 get RegExp.prototype.sticky // 21.2.5.13 RegExp.prototype.test( S ) // 21.2.5.14 RegExp.prototype.toString ( ) // 21.2.5.15 get RegExp.prototype.unicode // 21.2.6 Properties of RegExp Instances // 21.2.6.1 lastIndex // (No polyfillable changes from ES5) // --------------------------------------- // 22 Indexed Collections // --------------------------------------- // --------------------------------------- // 22.1 Array Objects // --------------------------------------- // 22.1.1 The Array Constructor // 22.1.1.1 Array ( ) // 22.1.1.2 Array (len) // 22.1.1.3 Array (...items ) // 22.1.2 Properties of the Array Constructor // 22.1.2.1 Array.from ( items [ , mapfn [ , thisArg ] ] ) define( Array, 'from', function from(items) { var mapfn = arguments[1]; var thisArg = arguments[2]; var c = strict(this); if (mapfn === undefined) { var mapping = false; } else { if (!IsCallable(mapfn)) throw TypeError(); var t = thisArg; mapping = true; } var usingIterator = GetMethod(items, $$iterator); if (usingIterator !== undefined) { if (IsConstructor(c)) { var a = new c(); } else { a = new Array(0); } var iterator = GetIterator(items, usingIterator); var k = 0; while (true) { var next = IteratorStep(iterator); if (next === false) { a.length = k; return a; } var nextValue = IteratorValue(next); if (mapping) var mappedValue = mapfn.call(t, nextValue); else mappedValue = nextValue; a[k] = mappedValue; k += 1; } } var arrayLike = ToObject(items); var lenValue = arrayLike.length; var len = ToLength(lenValue); if (IsConstructor(c)) { a = new c(len); } else { a = new Array(len); } k = 0; while (k < len) { var kValue = arrayLike[k]; if (mapping) mappedValue = mapfn.call(t, kValue, k); else mappedValue = kValue; a[k] = mappedValue; k += 1; } a.length = len; return a; }); // 22.1.2.2 Array.isArray ( arg ) // 22.1.2.3 Array.of ( ...items ) define( Array, 'of', function of() { var items = arguments; var lenValue = items.length; var len = ToUint32(lenValue); var c = strict(this), a; if (IsConstructor(c)) { a = new c(len); a = ToObject(a); } else { a = new Array(len); } var k = 0; while (k < len) { a[k] = items[k]; k += 1; } a.length = len; return a; }); // 22.1.2.4 Array.prototype // 22.1.2.5 get Array [ @@species ] // 22.1.3 Properties of the Array Prototype Object // 22.1.3.1 Array.prototype.concat ( ...arguments ) // 22.1.3.1.1 Runtime Semantics: IsConcatSpreadable ( O ) // 22.1.3.2 Array.prototype.constructor // 22.1.3.3 Array.prototype.copyWithin (target, start [ , end ] ) define( Array.prototype, 'copyWithin', function copyWithin(target, start/*, end*/) { var end = arguments[2]; var o = ToObject(this); var lenVal = o.length; var len = ToLength(lenVal); len = max(len, 0); var relativeTarget = ToInteger(target); var to; if (relativeTarget < 0) to = max(len + relativeTarget, 0); else to = min(relativeTarget, len); var relativeStart = ToInteger(start); var from; if (relativeStart < 0) from = max(len + relativeStart, 0); else from = min(relativeStart, len); var relativeEnd; if (end === undefined) relativeEnd = len; else relativeEnd = ToInteger(end); var final; if (relativeEnd < 0) final = max(len + relativeEnd, 0); else final = min(relativeEnd, len); var count = min(final - from, len - to); var direction; if (from < to && to < from + count) { direction = -1; from = from + count - 1; to = to + count - 1; } else { direction = 1; } while (count > 0) { var fromKey = String(from); var toKey = String(to); var fromPresent = HasProperty(o, fromKey); if (fromPresent) { var fromVal = o[fromKey]; o[toKey] = fromVal; } else { delete o[toKey]; } from = from + direction; to = to + direction; count = count - 1; } return o; }); // 22.1.3.4 Array.prototype.entries ( ) var nativeArrayIteratorMethods = ('entries' in Array.prototype && 'next' in [].entries()); define( Array.prototype, 'entries', function entries() { return CreateArrayIterator(this, 'key+value'); }, !nativeArrayIteratorMethods); // 22.1.3.5 Array.prototype.every ( callbackfn [ , thisArg] ) // 22.1.3.6 Array.prototype.fill (value [ , start [ , end ] ] ) define( Array.prototype, 'fill', function fill(value/*, start, end*/) { var start = arguments[1], end = arguments[2]; var o = ToObject(this); var lenVal = o.length; var len = ToLength(lenVal); len = max(len, 0); var relativeStart = ToInteger(start); var k; if (relativeStart < 0) k = max((len + relativeStart), 0); else k = min(relativeStart, len); var relativeEnd; if (end === undefined) relativeEnd = len; else relativeEnd = ToInteger(end); var final; if (relativeEnd < 0) final = max((len + relativeEnd), 0); else final = min(relativeEnd, len); while (k < final) { var pk = String(k); o[pk] = value; k += 1; } return o; }); // 22.1.3.7 Array.prototype.filter ( callbackfn [ , thisArg ] ) // 22.1.3.8 Array.prototype.find ( predicate [ , thisArg ] ) define( Array.prototype, 'find', function find(predicate) { var o = ToObject(this); var lenValue = o.length; var len = ToInteger(lenValue); if (!IsCallable(predicate)) throw TypeError(); var t = arguments.length > 1 ? arguments[1] : undefined; var k = 0; while (k < len) { var pk = String(k); var kPresent = HasProperty(o, pk); if (kPresent) { var kValue = o[pk]; var testResult = predicate.call(t, kValue, k, o); if (Boolean(testResult)) { return kValue; } } ++k; } return undefined; }); // 22.1.3.9 Array.prototype.findIndex ( predicate [ , thisArg ] ) define( Array.prototype, 'findIndex', function findIndex(predicate) { var o = ToObject(this); var lenValue = o.length; var len = ToLength(lenValue); if (!IsCallable(predicate)) throw TypeError(); var t = arguments.length > 1 ? arguments[1] : undefined; var k = 0; while (k < len) { var pk = String(k); var kPresent = HasProperty(o, pk); if (kPresent) { var kValue = o[pk]; var testResult = predicate.call(t, kValue, k, o); if (Boolean(testResult)) { return k; } } ++k; } return -1; }); // 22.1.3.10 Array.prototype.forEach ( callbackfn [ , thisArg ] ) // 22.1.3.11 Array.prototype.indexOf ( searchElement [ , fromIndex ] ) // 22.1.3.12 Array.prototype.join (separator) // 22.1.3.13 Array.prototype.keys ( ) define( Array.prototype, 'keys', function keys() { return CreateArrayIterator(this, 'key'); }, !nativeArrayIteratorMethods); // 22.1.3.14 Array.prototype.lastIndexOf ( searchElement [ , fromIndex ] ) // 22.1.3.15 Array.prototype.map ( callbackfn [ , thisArg ] ) // 22.1.3.16 Array.prototype.pop ( ) // 22.1.3.17 Array.prototype.push ( ...items ) // 22.1.3.18 Array.prototype.reduce ( callbackfn [ , initialValue ] ) // 22.1.3.19 Array.prototype.reduceRight ( callbackfn [ , initialValue ] ) // 22.1.3.20 Array.prototype.reverse ( ) // 22.1.3.21 Array.prototype.shift ( ) // 22.1.3.22 Array.prototype.slice (start, end) // 22.1.3.23 Array.prototype.some ( callbackfn [ , thisArg ] ) // 22.1.3.24 Array.prototype.sort (comparefn) // 22.1.3.25 Array.prototype.splice (start, deleteCount , ...items ) // 22.1.3.26 Array.prototype.toLocaleString ( [ reserved1 [ , reserved2 ] ] ) // 22.1.3.27 Array.prototype.toString ( ) // 22.1.3.28 Array.prototype.unshift ( ...items ) // 22.1.3.29 Array.prototype.values ( ) define( Array.prototype, 'values', function values() { return CreateArrayIterator(this, 'value'); }, !nativeArrayIteratorMethods); // 22.1.3.30 Array.prototype [ @@iterator ] ( ) define( Array.prototype, $$iterator, Array.prototype.values ); // 22.1.3.31 Array.prototype [ @@unscopables ] // 22.1.4 Properties of Array Instances // 22.1.4.1 length // 22.1.5 Array Iterator Objects function ArrayIterator() {} // 22.1.5.1 CreateArrayIterator Abstract Operation function CreateArrayIterator(array, kind) { var o = ToObject(array); var iterator = new ArrayIterator; set_internal(iterator, '[[IteratedObject]]', o); set_internal(iterator, '[[ArrayIteratorNextIndex]]', 0); set_internal(iterator, '[[ArrayIterationKind]]', kind); return iterator; } // 22.1.5.2 The %ArrayIteratorPrototype% Object var $ArrayIteratorPrototype$ = Object.create($IteratorPrototype$); ArrayIterator.prototype = $ArrayIteratorPrototype$; // 22.1.5.2.1 %ArrayIteratorPrototype%. next( ) define( $ArrayIteratorPrototype$, 'next', function next() { var o = strict(this); if (Type(o) !== 'object') throw TypeError(); var a = o['[[IteratedObject]]'], index = o['[[ArrayIteratorNextIndex]]'], itemKind = o['[[ArrayIterationKind]]'], lenValue = a.length, len = ToUint32(lenValue), elementKey, elementValue; if (itemKind.indexOf('sparse') !== -1) { var found = false; while (!found && index < len) { elementKey = String(index); found = HasProperty(a, elementKey); if (!found) { index += 1; } } } if (index >= len) { set_internal(o, '[[ArrayIteratorNextIndex]]', Infinity); return CreateIterResultObject(undefined, true); } elementKey = index; set_internal(o, '[[ArrayIteratorNextIndex]]', index + 1); if (itemKind.indexOf('value') !== -1) elementValue = a[elementKey]; if (itemKind.indexOf('key+value') !== -1) return CreateIterResultObject([elementKey, elementValue], false); if (itemKind.indexOf('key') !== -1) return CreateIterResultObject(elementKey, false); if (itemKind === 'value') return CreateIterResultObject(elementValue, false); throw Error('Internal error'); }); // 22.1.5.2.2 %ArrayIteratorPrototype% [ @@toStringTag ] define($ArrayIteratorPrototype$, $$toStringTag, 'Array Iterator'); // 22.1.5.3 Properties of Array Iterator Instances // --------------------------------------- // 22.2 TypedArray Objects // --------------------------------------- // See typedarray.js for TypedArray polyfill ['Int8Array', 'Uint8Array', 'Uint8ClampedArray', 'Int16Array', 'Uint16Array', 'Int32Array', 'Uint32Array', 'Float32Array', 'Float64Array'].forEach(function ($TypedArrayName$) { if (!($TypedArrayName$ in global)) return; var $TypedArray$ = global[$TypedArrayName$]; // 22.2.1 The %TypedArray% Intrinsic Object // 22.2.1.1 %TypedArray% ( length ) // 22.2.1.2 %TypedArray% ( typedArray ) // 22.2.1.3 %TypedArray% ( object ) // 22.2.1.4 %TypedArray% ( buffer [ , byteOffset [ , length ] ] ) // 22.2.1.5 %TypedArray% ( all other argument combinations ) // 22.2.2 Properties of the %TypedArray% Intrinsic Object // 22.2.2.1 %TypedArray%.from ( source [ , mapfn [ , thisArg ] ] ) define( $TypedArray$, 'from', function from(source) { var mapfn = arguments[1]; var thisArg = arguments[2]; var c = strict(this); if (!IsConstructor(c)) throw TypeError(); if (mapfn === undefined) { var mapping = false; } else { if (IsCallable(mapfn)) throw TypeError(); var t = thisArg; mapping = true; } var usingIterator = GetMethod(source, $$iterator); if (usingIterator !== undefined) { var iterator = GetIterator(source, usingIterator); var values = []; var next = true; while (next !== false) { next = IteratorStep(iterator); if (next !== false) { var nextValue = IteratorValue(next); values.push(nextValue); } } var len = values.length; var newObj = new c(len); var k = 0; while (k < len) { var kValue = values.shift(); if (mapping) { var mappedValue = mapfn.call(t, kValue); } else { mappedValue = kValue; } newObj[k] = mappedValue; ++k; } console.assert(values.length === 0); return newObj; } var arrayLike = ToObject(source); var lenValue = arrayLike.length; len = ToLength(lenValue); newObj = new c(len); k = 0; while (k < len) { kValue = arrayLike[k]; if (mapping) { mappedValue = mapfn.call(t, kValue, k); } else { mappedValue = kValue; } newObj[k] = mappedValue; ++k; } return newObj; }); // 22.2.2.2 %TypedArray%.of ( ...items ) define( $TypedArray$, 'of', function of() { var items = arguments; var len = items.length; var c = strict(this); var newObj = new c(len); var k = 0; while (k < len) { newObj[k] = items[k]; ++k; } return newObj; }); // 22.2.2.3 %TypedArray%.prototype // 22.2.2.4 get %TypedArray% [ @@species ] // 22.2.3 Properties of the %TypedArrayPrototype% Object // 22.2.3.1 get %TypedArray%.prototype.buffer // 22.2.3.2 get %TypedArray%.prototype.byteLength // 22.2.3.3 get %TypedArray%.prototype.byteOffset // 22.2.3.4 %TypedArray%.prototype.constructor // 22.2.3.5 %TypedArray%.prototype.copyWithin (target, start [, end ] ) define($TypedArray$.prototype, 'copyWithin', Array.prototype.copyWithin); // 22.2.3.6 %TypedArray%.prototype.entries ( ) define($TypedArray$.prototype, 'entries', Array.prototype.entries); // 22.2.3.7 %TypedArray%.prototype.every ( callbackfn [ , thisArg ] ) define($TypedArray$.prototype, 'every', Array.prototype.every); // 22.2.3.8 %TypedArray%.prototype.fill (value [ , start [ , end ] ] ) define( $TypedArray$.prototype, 'fill', //Array.prototype.fill // Doesn't work in Safari 7 function fill(value/*, start, end*/) { var start = arguments[1], end = arguments[2]; var o = ToObject(this); var lenVal = o.length; var len = ToLength(lenVal); len = max(len, 0); var relativeStart = ToInteger(start); var k; if (relativeStart < 0) k = max((len + relativeStart), 0); else k = min(relativeStart, len); var relativeEnd; if (end === undefined) relativeEnd = len; else relativeEnd = ToInteger(end); var final; if (relativeEnd < 0) final = max((len + relativeEnd), 0); else final = min(relativeEnd, len); while (k < final) { var pk = String(k); o[pk] = value; k += 1; } return o; }); // 22.2.3.9 %TypedArray%.prototype.filter ( callbackfn [ , thisArg ] ) define( $TypedArray$.prototype, 'filter', function filter(callbackfn) { var thisArg = arguments[1]; var o = ToObject(this); var lenVal = o.length; var len = ToLength(lenVal); if (!IsCallable(callbackfn)) throw TypeError(); var t = thisArg; var c = o.constructor; var kept = []; var k = 0; var captured = 0; while (k < len) { var kValue = o[k]; var selected = callbackfn.call(t, kValue, k, o); if (selected) { kept.push(kValue); ++captured; } ++k; } var a = new c(captured); var n = 0; for (var i = 0; i < kept.length; ++i) { var e = kept[i]; a[n] = e; ++n; } return a; }); // 22.2.3.10 %TypedArray%.prototype.find (predicate [ , thisArg ] ) define($TypedArray$.prototype, 'find', Array.prototype.find); // 22.2.3.11 %TypedArray%.prototype.findIndex ( predicate [ , thisArg ] ) define($TypedArray$.prototype, 'findIndex', Array.prototype.findIndex); // 22.2.3.12 %TypedArray%.prototype.forEach ( callbackfn [ , thisArg ] ) define($TypedArray$.prototype, 'forEach', Array.prototype.forEach); // 22.2.3.13 %TypedArray%.prototype.indexOf (searchElement [ , fromIndex ] ) define($TypedArray$.prototype, 'indexOf', Array.prototype.indexOf); // 22.2.3.14 %TypedArray%.prototype.join ( separator ) define($TypedArray$.prototype, 'join', Array.prototype.join); // 22.2.3.15 %TypedArray%.prototype.keys ( ) define($TypedArray$.prototype, 'keys', Array.prototype.keys); // 22.2.3.16 %TypedArray%.prototype.lastIndexOf ( searchElement [ , fromIndex ] ) define($TypedArray$.prototype, 'lastIndexOf', Array.prototype.lastIndexOf); // 22.2.3.17 get %TypedArray%.prototype.length // 22.2.3.18 %TypedArray%.prototype.map ( callbackfn [ , thisArg ] ) define( $TypedArray$.prototype, 'map', function map(callbackfn) { var thisArg = arguments[1]; var o = ToObject(this); var lenValue = o.length; var len = ToLength(lenValue); if (!IsCallable(callbackfn)) throw TypeError(); var t = thisArg; var a = undefined; var c = o.constructor; if (IsConstructor(c)) a = new c(len); if (a === undefined) a = new Array(len); var k = 0; while (k < len) { var kPresent = HasProperty(o, k); if (kPresent) { var kValue = o[k]; var mappedValue = callbackfn.call(t, kValue, k, o); a[k] = mappedValue; } ++k; } return a; }); // 22.2.3.19 %TypedArray%.prototype.reduce ( callbackfn [, initialValue] ) define($TypedArray$.prototype, 'reduce', Array.prototype.reduce); // 22.2.3.20 %TypedArray%.prototype.reduceRight ( callbackfn [, initialValue] ) define($TypedArray$.prototype, 'reduceRight', Array.prototype.reduceRight); // 22.2.3.21 %TypedArray%.prototype.reverse ( ) define($TypedArray$.prototype, 'reverse', Array.prototype.reverse); // 22.2.3.22 %TypedArray%.prototype.set ( overloaded [ , offset ]) // 22.2.3.22.1 %TypedArray%.prototype.set (array [ , offset ] ) // 22.2.3.22.2 %TypedArray%.prototype.set(typedArray [, offset ] ) // 22.2.3.23 %TypedArray%.prototype.slice ( start, end ) define( $TypedArray$.prototype, 'slice', function slice(start, end) { var o = ToObject(this); var lenVal = o.length; var len = ToLength(lenVal); var relativeStart = ToInteger(start); var k = (relativeStart < 0) ? max(len + relativeStart, 0) : min(relativeStart, len); var relativeEnd = (end === undefined) ? len : ToInteger(end); var final = (relativeEnd < 0) ? max(len + relativeEnd, 0) : min(relativeEnd, len); var count = final - k; var c = o.constructor; if (IsConstructor(c)) { var a = new c(count); } else { throw TypeError(); } var n = 0; while (k < final) { var kValue = o[k]; a[n] = kValue; ++k; ++n; } return a; }); // 22.2.3.24 %TypedArray%.prototype.some ( callbackfn [ , thisArg ] ) define($TypedArray$.prototype, 'some', Array.prototype.some); // 22.2.3.25 %TypedArray%.prototype.sort ( comparefn ) define( $TypedArray$.prototype, 'sort', function sort() { var comparefn = arguments[0]; function sortCompare(x, y) { console.assert(Type(x) === 'number' && Type(y) === 'number'); if (x !== x && y !== y) return +0; if (x !== x) return 1; if (y !== y) return -1; if (comparefn !== undefined) { return comparefn(x, y); } if (x < y) return -1; if (x > y) return 1; return +0; } return Array.prototype.sort.call(this, sortCompare); }); // 22.2.3.26 %TypedArray%.prototype.subarray( [ begin [ , end ] ] ) // 22.2.3.27 %TypedArray%.prototype.toLocaleString ([ reserved1 [ , reserved2 ] ]) // 22.2.3.28 %TypedArray%.prototype.toString ( ) // 22.2.3.29 %TypedArray%.prototype.values ( ) define($TypedArray$.prototype, 'values', Array.prototype.values); // 22.2.3.30 %TypedArray%.prototype [ @@iterator ] ( ) define( $TypedArray$.prototype, $$iterator, $TypedArray$.prototype.values ); // 22.2.3.31 get %TypedArray%.prototype [ @@toStringTag ] define($TypedArray$.prototype, $$toStringTag, $TypedArrayName$); // 22.2.4 The TypedArray Constructors // 22.2.4.1TypedArray( ... argumentsList) // 22.2.5 Properties of the TypedArray Constructors // 22.2.5.1 TypedArray.BYTES_PER_ELEMENT // 22.2.5.2 TypedArray.prototype // 22.2.6 Properties of TypedArray Prototype Objects // 22.2.6.1 TypedArray.prototype.BYTES_PER_ELEMENT // 22.2.6.2 TypedArray.prototype.constructor // 22.2.7 Properties of TypedArray Instances }); // --------------------------------------- // 23 Keyed Collection // --------------------------------------- // --------------------------------------- // 23.1 Map Objects // --------------------------------------- (function() { // 23.1.1 The Map Constructor // 23.1.1.1 Map ( [ iterable ] ) /** @constructor */ function Map(/*iterable*/) { var map = strict(this); var iterable = arguments[0]; if (Type(map) !== 'object') throw TypeError(); if ('[[MapData]]' in map) throw TypeError(); if (iterable !== undefined) { var adder = map['set']; if (!IsCallable(adder)) throw TypeError(); var iter = GetIterator(ToObject(iterable)); } set_internal(map, '[[MapData]]', { keys: [], values: [] }); if (iter === undefined) return map; while (true) { var next = IteratorStep(iter); if (next === false) return map; var nextItem = IteratorValue(next); if (Type(nextItem) !== 'object') throw TypeError(); var k = nextItem[0]; var v = nextItem[1]; adder.call(map, k, v); } return map; } if (!('Map' in global) || OVERRIDE_NATIVE_FOR_TESTING || (function() { try { new global.Map([]); return false; } catch (_) { return true; } }()) || (function() { try { return !new global.Map().entries().next; } catch (_) { return true; } }()) || (new global.Map([['a', 1]]).size !== 1)) global.Map = Map; function MapDataIndexOf(mapData, key) { var i; if (key === key) return mapData.keys.indexOf(key); // Slow case for NaN for (i = 0; i < mapData.keys.length; i += 1) if (SameValueZero(mapData.keys[i], key)) return i; return -1; } // 23.1.1.2 new Map ( ... argumentsList ) // 23.1.2 Properties of the Map Constructor // 23.1.2.1 Map.prototype var $MapPrototype$ = {}; Map.prototype = $MapPrototype$; // 23.1.2.2 get Map [ @@species ] // 23.1.3 Properties of the Map Prototype Object // 23.1.3.1 Map.prototype.clear () define( Map.prototype, 'clear', function clear() { var m = strict(this); if (Type(m) !== 'object') throw TypeError(); if (!('[[MapData]]' in m)) throw TypeError(); if (m['[[MapData]]'] === undefined) throw TypeError(); var entries = m['[[MapData]]']; entries.keys.length = 0; entries.values.length = 0; return undefined; }); // 23.1.3.2 Map.prototype.constructor // 23.1.3.3 Map.prototype.delete ( key ) define( Map.prototype, 'delete', function delete_(key) { var m = strict(this); if (Type(m) !== 'object') throw TypeError(); if (!('[[MapData]]' in m)) throw TypeError(); if (m['[[MapData]]'] === undefined) throw TypeError(); var entries = m['[[MapData]]']; var i = MapDataIndexOf(entries, key); if (i < 0) return false; entries.keys[i] = empty; entries.values[i] = empty; return true; }); // 23.1.3.4 Map.prototype.entries ( ) define( Map.prototype, 'entries', function entries() { var m = strict(this); if (Type(m) !== 'object') throw TypeError(); return CreateMapIterator(m, 'key+value'); }); // 23.1.3.5 Map.prototype.forEach ( callbackfn [ , thisArg ] ) define( Map.prototype, 'forEach', function forEach(callbackfn /*, thisArg*/) { var thisArg = arguments[1]; var m = strict(this); if (Type(m) !== 'object') throw TypeError(); if (!('[[MapData]]' in m)) throw TypeError(); if (m['[[MapData]]'] === undefined) throw TypeError(); var entries = m['[[MapData]]']; if (!IsCallable(callbackfn)) { throw TypeError('First argument to forEach is not callable.'); } for (var i = 0; i < entries.keys.length; ++i) { if (entries.keys[i] !== empty) { callbackfn.call(thisArg, entries.values[i], entries.keys[i], m); } } return undefined; }); // 23.1.3.6 Map.prototype.get ( key ) define( Map.prototype, 'get', function get(key) { var m = strict(this); if (Type(m) !== 'object') throw TypeError(); if (!('[[MapData]]' in m)) throw TypeError(); if (m['[[MapData]]'] === undefined) throw TypeError(); var entries = m['[[MapData]]']; var i = MapDataIndexOf(entries, key); if (i >= 0) return entries.values[i]; return undefined; }); // 23.1.3.7 Map.prototype.has ( key ) define( Map.prototype, 'has', function has(key) { var m = strict(this); if (Type(m) !== 'object') throw TypeError(); if (!('[[MapData]]' in m)) throw TypeError(); if (m['[[MapData]]'] === undefined) throw TypeError(); var entries = m['[[MapData]]']; if (MapDataIndexOf(entries, key) >= 0) return true; return false; }); // 23.1.3.8 Map.prototype.keys ( ) define( Map.prototype, 'keys', function keys() { var m = strict(this); if (Type(m) !== 'object') throw TypeError(); return CreateMapIterator(m, 'key'); }); // 23.1.3.9 Map.prototype.set ( key , value ) define( Map.prototype, 'set', function set(key, value) { var m = strict(this); if (Type(m) !== 'object') throw TypeError(); if (!('[[MapData]]' in m)) throw TypeError(); if (m['[[MapData]]'] === undefined) throw TypeError(); var entries = m['[[MapData]]']; var i = MapDataIndexOf(entries, key); if (i < 0) i = entries.keys.length; if (SameValue(key, -0)) key = 0; entries.keys[i] = key; entries.values[i] = value; return m; }); // 23.1.3.10 get Map.prototype.size Object.defineProperty( Map.prototype, 'size', { get: function() { var m = strict(this); if (Type(m) !== 'object') throw TypeError(); if (!('[[MapData]]' in m)) throw TypeError(); if (m['[[MapData]]'] === undefined) throw TypeError(); var entries = m['[[MapData]]']; var count = 0; for (var i = 0; i < entries.keys.length; ++i) { if (entries.keys[i] !== empty) count = count + 1; } return count; } }); // 23.1.3.11 Map.prototype.values ( ) define( Map.prototype, 'values', function values() { var m = strict(this); if (Type(m) !== 'object') throw TypeError(); return CreateMapIterator(m, 'value'); }); // 23.1.3.12 Map.prototype [ @@iterator ]( ) define( Map.prototype, $$iterator, function() { var m = strict(this); if (Type(m) !== 'object') throw TypeError(); return CreateMapIterator(m, 'key+value'); }); // 23.1.3.13 Map.prototype [ @@toStringTag ] define(global.Map.prototype, $$toStringTag, 'Map'); // 23.1.4 Properties of Map Instances // 23.1.5 Map Iterator Objects /** @constructor */ function MapIterator() {} // 23.1.5.1 CreateMapIterator Abstract Operation function CreateMapIterator(map, kind) { if (Type(map) !== 'object') throw TypeError(); if (!('[[MapData]]' in map)) throw TypeError(); if (map['[[MapData]]'] === undefined) throw TypeError(); var iterator = new MapIterator; set_internal(iterator, '[[Map]]', map); set_internal(iterator, '[[MapNextIndex]]', 0); set_internal(iterator, '[[MapIterationKind]]', kind); return iterator; } // 23.1.5.2 The %MapIteratorPrototype% Object var $MapIteratorPrototype$ = Object.create($IteratorPrototype$); MapIterator.prototype = $MapIteratorPrototype$; // 23.1.5.2.1 %MapIteratorPrototype%.next ( ) define( $MapIteratorPrototype$, 'next', function next() { var o = strict(this); if (Type(o) !== 'object') throw TypeError(); var m = o['[[Map]]'], index = o['[[MapNextIndex]]'], itemKind = o['[[MapIterationKind]]'], entries = m['[[MapData]]']; while (index < entries.keys.length) { var e = {key: entries.keys[index], value: entries.values[index]}; index = index += 1; set_internal(o, '[[MapNextIndex]]', index); if (e.key !== empty) { if (itemKind === 'key') { return CreateIterResultObject(e.key, false); } else if (itemKind === 'value') { return CreateIterResultObject(e.value, false); } else { return CreateIterResultObject([e.key, e.value], false); } } } return CreateIterResultObject(undefined, true); }); // 23.1.5.2.2 %MapIteratorPrototype% [ @@toStringTag ] define($MapIteratorPrototype$, $$toStringTag, 'Map Iterator'); // 23.1.5.3 Properties of Map Iterator Instances }()); // --------------------------------------- // 23.2 Set Objects // --------------------------------------- (function() { // 23.2.1 The Set Constructor // 23.2.1.1 Set ( [ iterable ] ) /** @constructor */ function Set(/*iterable*/) { var set = strict(this); var iterable = arguments[0]; if (Type(set) !== 'object') throw TypeError(); if ('[[SetData]]' in set) throw TypeError(); if (iterable !== undefined) { var adder = set['add']; if (!IsCallable(adder)) throw TypeError(); var iter = GetIterator(ToObject(iterable)); } set_internal(set, '[[SetData]]', []); if (iter === undefined) return set; while (true) { var next = IteratorStep(iter); if (next === false) return set; var nextValue = IteratorValue(next); adder.call(set, nextValue); } return set; } if (!('Set' in global) || OVERRIDE_NATIVE_FOR_TESTING || (function() { try { return !new global.Set().entries().next; } catch (_) { return true; } }()) || (new global.Set([1]).size !== 1)) global.Set = Set; function SetDataIndexOf(setData, key) { var i; if (key === key) return setData.indexOf(key); // Slow case for NaN for (i = 0; i < setData.length; i += 1) if (SameValueZero(setData[i], key)) return i; return -1; } // 23.2.1.2 new Set ( ...argumentsList ) // 23.2.2 Properties of the Set Constructor // 23.2.2.1 Set.prototype var $SetPrototype$ = {}; Set.prototype = $SetPrototype$; // 23.2.2.2 get Set [ @@species ] // 23.2.3 Properties of the Set Prototype Object // 23.2.3.1 Set.prototype.add (value ) define( Set.prototype, 'add', function add(value) { var s = strict(this); if (Type(s) !== 'object') throw TypeError(); if (!('[[SetData]]' in s)) throw TypeError(); if (s['[[SetData]]'] === undefined) throw TypeError(); if (SameValue(value, -0)) value = 0; var entries = s['[[SetData]]']; var i = SetDataIndexOf(entries, value); if (i < 0) i = s['[[SetData]]'].length; s['[[SetData]]'][i] = value; return s; }); // 23.2.3.2 Set.prototype.clear () define( Set.prototype, 'clear', function clear() { var s = strict(this); if (Type(s) !== 'object') throw TypeError(); if (!('[[SetData]]' in s)) throw TypeError(); if (s['[[SetData]]'] === undefined) throw TypeError(); var entries = s['[[SetData]]']; entries.length = 0; return undefined; }); // 23.2.3.3 Set.prototype.constructor // 23.2.3.4 Set.prototype.delete ( value ) define( Set.prototype, 'delete', function delete_(value) { var s = strict(this); if (Type(s) !== 'object') throw TypeError(); if (!('[[SetData]]' in s)) throw TypeError(); if (s['[[SetData]]'] === undefined) throw TypeError(); var entries = s['[[SetData]]']; var i = SetDataIndexOf(entries, value); if (i < 0) return false; entries[i] = empty; return true; }); // 23.2.3.5 Set.prototype.entries ( ) define( Set.prototype, 'entries', function entries() { var s = strict(this); if (Type(s) !== 'object') throw TypeError(); return CreateSetIterator(s, 'key+value'); }); // 23.2.3.6 Set.prototype.forEach ( callbackfn [ , thisArg ] ) define( Set.prototype, 'forEach', function forEach(callbackfn/*, thisArg*/) { var thisArg = arguments[1]; var s = strict(this); if (Type(s) !== 'object') throw TypeError(); if (!('[[SetData]]' in s)) throw TypeError(); if (s['[[SetData]]'] === undefined) throw TypeError(); var entries = s['[[SetData]]']; if (!IsCallable(callbackfn)) { throw TypeError('First argument to forEach is not callable.'); } for (var i = 0; i < entries.length; ++i) { if (entries[i] !== empty) { callbackfn.call(thisArg, entries[i], entries[i], s); } } }); // 23.2.3.7 Set.prototype.has ( value ) define( Set.prototype, 'has', function has(key) { var s = strict(this); if (Type(s) !== 'object') throw TypeError(); if (!('[[SetData]]' in s)) throw TypeError(); if (s['[[SetData]]'] === undefined) throw TypeError(); var entries = s['[[SetData]]']; return SetDataIndexOf(entries, key) !== -1; }); // 23.2.3.8 Set.prototype.keys ( ) // See Set.prototype.values // 23.2.3.9 get Set.prototype.size Object.defineProperty( Set.prototype, 'size', { get: function() { var s = strict(this); if (Type(s) !== 'object') throw TypeError(); if (!('[[SetData]]' in s)) throw TypeError(); if (s['[[SetData]]'] === undefined) throw TypeError(); var entries = s['[[SetData]]']; var count = 0; for (var i = 0; i < entries.length; ++i) { if (entries[i] !== empty) count = count + 1; } return count; } }); // 23.2.3.10 Set.prototype.values ( ) define( Set.prototype, 'values', function values() { var s = strict(this); if (Type(s) !== 'object') throw TypeError(); return CreateSetIterator(s, 'value'); }); // NOTE: function name is still 'values': Set.prototype.keys = Set.prototype.values; // 23.2.3.11 Set.prototype [@@iterator ] ( ) define( Set.prototype, $$iterator, function() { var s = strict(this); if (Type(s) !== 'object') throw TypeError(); return CreateSetIterator(s); }); // 23.2.3.12 Set.prototype [ @@toStringTag ] define(global.Set.prototype, $$toStringTag, 'Set'); // 23.2.4 Properties of Set Instances // 23.2.5 Set Iterator Objects /** @constructor */ function SetIterator() {} // 23.2.5.1 CreateSetIterator Abstract Operation function CreateSetIterator(set, kind) { if (Type(set) !== 'object') throw TypeError(); if (!('[[SetData]]' in set)) throw TypeError(); if (set['[[SetData]]'] === undefined) throw TypeError(); var iterator = new SetIterator; set_internal(iterator, '[[IteratedSet]]', set); set_internal(iterator, '[[SetNextIndex]]', 0); set_internal(iterator, '[[SetIterationKind]]', kind); return iterator; } // 23.2.5.2 The %SetIteratorPrototype% Object var $SetIteratorPrototype$ = Object.create($IteratorPrototype$); SetIterator.prototype = $SetIteratorPrototype$; // 23.2.5.2.1 %SetIteratorPrototype%.next( ) define( $SetIteratorPrototype$, 'next', function next() { var o = strict(this); if (Type(o) !== 'object') throw TypeError(); var s = o['[[IteratedSet]]'], index = o['[[SetNextIndex]]'], itemKind = o['[[SetIterationKind]]'], entries = s['[[SetData]]']; while (index < entries.length) { var e = entries[index]; index = index += 1; set_internal(o, '[[SetNextIndex]]', index); if (e !== empty) { if (itemKind === 'key+value') return CreateIterResultObject([e, e], false); return CreateIterResultObject(e, false); } } return CreateIterResultObject(undefined, true); }); // 23.2.5.2.2 %SetIteratorPrototype% [ @@toStringTag ] define($SetIteratorPrototype$, $$toStringTag, 'Set Iterator'); // 23.2.5.3 Properties of Set Iterator Instances }()); // --------------------------------------- // 23.3 WeakMap Objects // --------------------------------------- (function() { // 23.3.1 The WeakMap Constructor // 23.3.1.1 WeakMap ( [ iterable ] ) /** @constructor */ function WeakMap(/*iterable*/) { var map = strict(this); var iterable = arguments[0]; if (Type(map) !== 'object') throw TypeError(); if ('[[WeakMapData]]' in map) throw TypeError(); if (iterable !== undefined) { var adder = map['set']; if (!IsCallable(adder)) throw TypeError(); var iter = GetIterator(ToObject(iterable)); } set_internal(map, '[[WeakMapData]]', new EphemeronTable); if (iter === undefined) return map; while (true) { var next = IteratorStep(iter); if (next === false) return map; var nextValue = IteratorValue(next); if (Type(nextValue) !== 'object') throw TypeError(); var k = nextValue[0]; var v = nextValue[1]; adder.call(map, k, v); } return map; } if (!('WeakMap' in global) || OVERRIDE_NATIVE_FOR_TESTING) global.WeakMap = WeakMap; // 23.3.2 Properties of the WeakMap Constructor // 23.3.2.1 WeakMap.prototype var $WeakMapPrototype$ = {}; WeakMap.prototype = $WeakMapPrototype$; // 23.3.2.2 WeakMap[ @@create ] ( ) // 23.3.3 Properties of the WeakMap Prototype Object // 23.3.3.1 WeakMap.prototype.constructor // 23.3.3.2 WeakMap.prototype.delete ( key ) define( WeakMap.prototype, 'delete', function delete_(key) { var M = strict(this); if (Type(M) !== 'object') throw TypeError(); if (M['[[WeakMapData]]'] === undefined) throw TypeError(); if (Type(key) !== 'object') throw TypeError('Expected object'); return M['[[WeakMapData]]'].remove(key); }); // 23.3.3.3 WeakMap.prototype.get ( key ) define( WeakMap.prototype, 'get', function get(key, defaultValue) { var M = strict(this); if (Type(M) !== 'object') throw TypeError(); if (M['[[WeakMapData]]'] === undefined) throw TypeError(); if (Type(key) !== 'object') throw TypeError('Expected object'); return M['[[WeakMapData]]'].get(key, defaultValue); }); // 23.3.3.4 WeakMap.prototype.has ( key ) define( WeakMap.prototype, 'has', function has(key) { var M = strict(this); if (Type(M) !== 'object') throw TypeError(); if (M['[[WeakMapData]]'] === undefined) throw TypeError(); if (Type(key) !== 'object') throw TypeError('Expected object'); return M['[[WeakMapData]]'].has(key); }); // 23.3.3.5 WeakMap.prototype.set ( key , value ) define( WeakMap.prototype, 'set', function set(key, value) { var M = strict(this); if (Type(M) !== 'object') throw TypeError(); if (M['[[WeakMapData]]'] === undefined) throw TypeError(); if (Type(key) !== 'object') throw TypeError('Expected object'); M['[[WeakMapData]]'].set(key, value); return M; }); // 23.3.3.6 WeakMap.prototype [ @@toStringTag ] define(global.WeakMap.prototype, $$toStringTag, 'WeakMap'); // 23.3.4 Properties of WeakMap Instances // Polyfills for incomplete native implementations: (function() { var wm = new global.WeakMap(); var orig = global.WeakMap.prototype.set; define(global.WeakMap.prototype, 'set', function set() { orig.apply(this, arguments); return this; }, wm.set({}, 0) !== wm); }()); }()); // --------------------------------------- // 23.4 WeakSet Objects // --------------------------------------- (function() { // 23.4.1 The WeakSet Constructor // 23.4.1.1 WeakSet ( [ iterable ] ) /** @constructor */ function WeakSet(/*iterable*/) { var set = strict(this); var iterable = arguments[0]; if (Type(set) !== 'object') throw TypeError(); if ('[[WeakSetData]]' in set) throw TypeError(); if (iterable !== undefined) { var adder = set['add']; if (!IsCallable(adder)) throw TypeError(); var iter = GetIterator(ToObject(iterable)); } set_internal(set, '[[WeakSetData]]', new EphemeronTable); if (iter === undefined) return set; while (true) { var next = IteratorStep(iter); if (next === false) return set; var nextValue = IteratorValue(next); adder.call(set, nextValue); } return set; } if (!('WeakSet' in global) || OVERRIDE_NATIVE_FOR_TESTING) global.WeakSet = WeakSet; // 23.4.2 Properties of the WeakSet Constructor // 23.4.2.1 WeakSet.prototype var $WeakSetPrototype$ = {}; WeakSet.prototype = $WeakSetPrototype$; // 23.4.3 Properties of the WeakSet Prototype Object // 23.4.3.1 WeakSet.prototype.add (value ) define( WeakSet.prototype, 'add', function add(value) { var S = strict(this); if (Type(S) !== 'object') throw TypeError(); if (S['[[WeakSetData]]'] === undefined) throw TypeError(); if (Type(value) !== 'object') throw TypeError('Expected object'); S['[[WeakSetData]]'].set(value, true); return S; }); // 23.4.3.2 WeakSet.prototype.constructor // 23.4.3.3 WeakSet.prototype.delete ( value ) define( WeakSet.prototype, 'delete', function delete_(value) { var S = strict(this); if (Type(S) !== 'object') throw TypeError(); if (S['[[WeakSetData]]'] === undefined) throw TypeError(); if (Type(value) !== 'object') throw TypeError('Expected object'); return S['[[WeakSetData]]'].remove(value); }); // 23.4.3.4 WeakSet.prototype.has ( value ) define( WeakSet.prototype, 'has', function has(key) { var S = strict(this); if (Type(S) !== 'object') throw TypeError(); if (S['[[WeakSetData]]'] === undefined) throw TypeError(); if (Type(key) !== 'object') throw TypeError('Expected object'); return S['[[WeakSetData]]'].has(key); }); // 23.4.3.5 WeakSet.prototype [ @@toStringTag ] define(global.WeakSet.prototype, $$toStringTag, 'WeakSet'); // 23.4.4 Properties of WeakSet Instances // Polyfills for incomplete native implementations: (function() { var ws = new global.WeakSet(); var orig = global.WeakSet.prototype.add; define(global.WeakSet.prototype, 'add', function add() { orig.apply(this, arguments); return this; }, ws.add({}) !== ws); }()); }()); // --------------------------------------- // 24 Structured Data // --------------------------------------- // --------------------------------------- // 24.1 ArrayBuffer Objects // --------------------------------------- // See typedarray.js for TypedArray polyfill (function() { if (!('ArrayBuffer' in global)) return; // 24.1.1 Abstract Operations For ArrayBuffer Objects // 24.1.1.1 AllocateArrayBuffer( constructor, byteLength ) // 24.1.1.2 IsDetachedBuffer( arrayBuffer ) // 24.1.1.3 DetachArrayBuffer( arrayBuffer ) // 24.1.1.4 CloneArrayBuffer( srcBuffer, srcByteOffset [, cloneConstructor] ) // 24.1.1.5 GetValueFromBuffer ( arrayBuffer, byteIndex, type, isLittleEndian ) // 24.1.1.6 SetValueInBuffer ( arrayBuffer, byteIndex, type, value, isLittleEndian ) // 24.1.2 The ArrayBuffer Constructor // 24.1.2.1 ArrayBuffer( length ) // 24.1.3 Properties of the ArrayBuffer Constructor // 24.1.3.1 ArrayBuffer.isView ( arg ) define( ArrayBuffer, 'isView', function isView(arg) { if (Type(arg) !== 'object') return false; if ('buffer' in arg && arg.buffer instanceof ArrayBuffer) return true; return false; }); // 24.1.3.2 ArrayBuffer.prototype // 24.1.3.3 get ArrayBuffer [ @@species ] // 24.1.4 Properties of the ArrayBuffer Prototype Object // 24.1.4.1 get ArrayBuffer.prototype.byteLength // 24.1.4.2 ArrayBuffer.prototype.constructor // 24.1.4.3 ArrayBuffer.prototype.slice ( start , end) // 24.1.4.4 ArrayBuffer.prototype [ @@toStringTag ] define(ArrayBuffer.prototype, $$toStringTag, 'ArrayBuffer'); // 24.1.5 Properties of the ArrayBuffer Instances }()); // --------------------------------------- // 24.2 DataView Objects // --------------------------------------- // See typedarray.js for TypedArray polyfill (function() { if (!('DataView' in global)) return; // 24.2.1 Abstract Operations For DataView Objects // 24.2.1.1 GetViewValue(view, requestIndex, isLittleEndian, type) // 24.2.1.2 SetViewValue(view, requestIndex, isLittleEndian, type, value) // 24.2.2 The DataView Constructor // 24.2.2.1 DataView (buffer [ , byteOffset [ , byteLength ] ] ) // 24.2.3 Properties of the DataView Constructor // 24.2.3.1 DataView.prototype // 24.2.4 Properties of the DataView Prototype Object // 24.2.4.1 get DataView.prototype.buffer // 24.2.4.2 get DataView.prototype.byteLength // 24.2.4.3 get DataView.prototype.byteOffset // 24.2.4.4 DataView.prototype.constructor // 24.2.4.5 DataView.prototype.getFloat32 ( byteOffset [ , littleEndian ] ) // 24.2.4.6 DataView.prototype.getFloat64 ( byteOffset [ , littleEndian ] ) // 24.2.4.7 DataView.prototype.getInt8 ( byteOffset ) // 24.2.4.8 DataView.prototype.getInt16 ( byteOffset [ , littleEndian ] ) // 24.2.4.9 DataView.prototype.getInt32 ( byteOffset [ , littleEndian ] ) // 24.2.4.10 DataView.prototype.getUint8 ( byteOffset ) // 24.2.4.11 DataView.prototype.getUint16 ( byteOffset [ , littleEndian ] ) // 24.2.4.12 DataView.prototype.getUint32 ( byteOffset [ , littleEndian ] ) // 24.2.4.13 DataView.prototype.setFloat32 ( byteOffset, value [ , littleEndian ] ) // 24.2.4.14 DataView.prototype.setFloat64 ( byteOffset, value [ , littleEndian ] ) // 24.2.4.15 DataView.prototype.setInt8 ( byteOffset, value ) // 24.2.4.16 DataView.prototype.setInt16 ( byteOffset, value [ , littleEndian ] ) // 24.2.4.17 DataView.prototype.setInt32 ( byteOffset, value [ , littleEndian ] ) // 24.2.4.18 DataView.prototype.setUint8 ( byteOffset, value ) // 24.2.4.19 DataView.prototype.setUint16 ( byteOffset, value [ , littleEndian ] ) // 24.2.4.20 DataView.prototype.setUint32 ( byteOffset, value [ , littleEndian ] ) // 24.2.4.21 DataView.prototype[ @@toStringTag ] define(DataView.prototype, $$toStringTag, 'DataView'); // 24.2.5 Properties of DataView Instances }()); // --------------------------------------- // 24.3 The JSON Object // --------------------------------------- // 24.3.1 JSON.parse ( text [ , reviver ] ) // 24.3.2 JSON.stringify ( value [ , replacer [ , space ] ] ) // 24.3.3 JSON [ @@toStringTag ] define(JSON, $$toStringTag, 'JSON'); // --------------------------------------- // 25.1 Iteration // --------------------------------------- // 25.1.1 Common Iteration Interfaces // 25.1.1.1 The Iterable Interface // 25.1.1.2 The Iterator Interface // 25.1.1.3 The IteratorResult Interface // 25.1.2 The %IteratorPrototype% Object // Defined earlier, so other prototypes can reference it. // 25.1.2.1 %IteratorPrototype% [ @@iterator ] ( ) define($IteratorPrototype$, $$iterator, function() { return this; }); // --------------------------------------- // 25.4 Promise Objects // --------------------------------------- (function() { // 25.4 Promise Objects // 25.4.1 Promise Abstract Operations // 25.4.1.1 PromiseCapability Records // 25.4.1.1.1 IfAbruptRejectPromise ( value, capability ) function IfAbruptRejectPromise(value, capability) { var rejectResult = capability['[[Reject]]'].call(undefined, value); return capability['[[Promise]]']; } // 25.4.1.2 PromiseReaction Records // 25.4.1.3 CreateResolvingFunctions ( promise ) function CreateResolvingFunctions(promise) { var alreadyResolved = {'[[value]]': false}; var resolve = PromiseResolveFunction(); set_internal(resolve, '[[Promise]]', promise); set_internal(resolve, '[[AlreadyResolved]]', alreadyResolved); var reject = PromiseRejectFunction(); set_internal(reject, '[[Promise]]', promise); set_internal(reject, '[[AlreadyResolved]]', alreadyResolved); return { '[[Resolve]]': resolve, '[[Reject]]': reject}; } // 25.4.1.3.1 Promise Reject Functions function PromiseRejectFunction() { var F = function(reason) { console.assert(Type(F['[[Promise]]']) === 'object'); var promise = F['[[Promise]]']; var alreadyResolved = F['[[AlreadyResolved]]']; if (alreadyResolved['[[value]]']) return undefined; set_internal(alreadyResolved, '[[value]]', true); return RejectPromise(promise, reason); }; return F; } // 25.4.1.3.2 Promise Resolve Functions function PromiseResolveFunction() { var F = function(resolution) { console.assert(Type(F['[[Promise]]']) === 'object'); var promise = F['[[Promise]]']; var alreadyResolved = F['[[AlreadyResolved]]']; if (alreadyResolved['[[value]]']) return undefined; set_internal(alreadyResolved, '[[value]]', true); if (SameValue(resolution, promise)) { var selfResolutionError = TypeError(); return RejectPromise(promise, selfResolutionError); } if (Type(resolution) !== 'object') return FulfillPromise(promise, resolution); try { var then = resolution['then']; } catch(then) { return RejectPromise(promise, then); } if (!IsCallable(then)) return FulfillPromise(promise, resolution); EnqueueJob('PromiseJobs', PromiseResolveThenableJob, [promise, resolution, then]); return undefined; }; return F; } // 25.4.1.4 FulfillPromise ( promise, value ) function FulfillPromise(promise, value) { console.assert(promise['[[PromiseState]]'] === 'pending'); var reactions = promise['[[PromiseFulfillReactions]]']; set_internal(promise, '[[PromiseResult]]', value); set_internal(promise, '[[PromiseFulfillReactions]]', undefined); set_internal(promise, '[[PromiseRejectReactions]]', undefined); set_internal(promise, '[[PromiseState]]', 'fulfilled'); return TriggerPromiseReactions(reactions, value); } // 25.4.1.5 NewPromiseCapability ( C ) function NewPromiseCapability(c) { // To keep Promise hermetic, this doesn't look much like the spec. return CreatePromiseCapabilityRecord(undefined, c); } // 25.4.1.5.1 CreatePromiseCapabilityRecord ( promise, constructor ) function CreatePromiseCapabilityRecord(promise, constructor) { // To keep Promise hermetic, this doesn't look much like the spec. console.assert(IsConstructor(constructor)); var promiseCapability = {}; set_internal(promiseCapability, '[[Promise]]', promise); set_internal(promiseCapability, '[[Resolve]]', undefined); set_internal(promiseCapability, '[[Reject]]', undefined); var executor = GetCapabilitiesExecutor(); set_internal(executor, '[[Capability]]', promiseCapability); // NOTE: Differs from spec; object is constructed here var constructorResult = promise = new constructor(executor); set_internal(promiseCapability, '[[Promise]]', promise); if (!IsCallable(promiseCapability['[[Resolve]]'])) throw TypeError(); if (!IsCallable(promiseCapability['[[Reject]]'])) throw TypeError(); if (Type(constructorResult) === 'object' && !SameValue(promise, constructorResult)) throw TypeError(); return promiseCapability; } // 25.4.1.5.2 GetCapabilitiesExecutor Functions function GetCapabilitiesExecutor() { var F = function(resolve, reject) { console.assert(F['[[Capability]]']); var promiseCapability = F['[[Capability]]']; if (promiseCapability['[[Resolve]]'] !== undefined) throw TypeError(); if (promiseCapability['[[Reject]]'] !== undefined) throw TypeError(); set_internal(promiseCapability, '[[Resolve]]', resolve); set_internal(promiseCapability, '[[Reject]]', reject); return undefined; }; return F; } // 25.4.1.6 IsPromise ( x ) function IsPromise(x) { if (Type(x) !== 'object') return false; if (!('[[PromiseState]]' in x)) return false; if (x['[[PromiseState]]'] === undefined) return false; return true; } // 25.4.1.7 RejectPromise ( promise, reason ) function RejectPromise(promise, reason) { console.assert(promise['[[PromiseState]]'] === 'pending'); var reactions = promise['[[PromiseRejectReactions]]']; set_internal(promise, '[[PromiseResult]]', reason); set_internal(promise, '[[PromiseFulfillReactions]]', undefined); set_internal(promise, '[[PromiseRejectReactions]]', undefined); set_internal(promise, '[[PromiseState]]', 'rejected'); return TriggerPromiseReactions(reactions, reason); } // 25.4.1.8 TriggerPromiseReactions ( reactions, argument ) function TriggerPromiseReactions(reactions, argument) { for (var i = 0, len = reactions.length; i < len; ++i) EnqueueJob('PromiseJobs', PromiseReactionJob, [reactions[i], argument]); return undefined; } // 25.4.2 Promise Jobs // 25.4.2.1 PromiseReactionJob ( reaction, argument ) function PromiseReactionJob(reaction, argument) { var promiseCapability = reaction['[[Capabilities]]']; var handler = reaction['[[Handler]]']; var handlerResult, status; try { if (handler === 'Identity') handlerResult = argument; else if (handler === 'Thrower') throw argument; else handlerResult = handler.call(undefined, argument); } catch (handlerResult) { status = promiseCapability['[[Reject]]'].call(undefined, handlerResult); NextJob(status); return; } status = promiseCapability['[[Resolve]]'].call(undefined, handlerResult); NextJob(status); } // 25.4.2.2 PromiseResolveThenableJob ( promiseToResolve, thenable, then) function PromiseResolveThenableJob(promiseToResolve, thenable, then) { // SPEC BUG: promise vs. promiseToResolve var resolvingFunctions = CreateResolvingFunctions(promiseToResolve); try { var thenCallResult = then.call(thenable, resolvingFunctions['[[Resolve]]'], resolvingFunctions['[[Reject]]']); } catch (thenCallResult) { var status = resolvingFunctions['[[Reject]]'].call(undefined, thenCallResult); NextJob(status); return; } NextJob(thenCallResult); } // 25.4.3 The Promise Constructor // 25.4.3.1 Promise ( executor ) function Promise(executor) { var config = { configurable: false, enumerable: false, writable: true, value: undefined }; Object.defineProperty(this, '[[PromiseState]]', config); Object.defineProperty(this, '[[PromiseConstructor]]', config); Object.defineProperty(this, '[[PromiseResult]]', config); Object.defineProperty(this, '[[PromiseFulfillReactions]]', config); Object.defineProperty(this, '[[PromiseRejectReactions]]', config); var promise = this; if (Type(promise) !== 'object') throw new TypeError(); if (!('[[PromiseState]]' in promise)) throw TypeError(); if (promise['[[PromiseState]]'] !== undefined) throw TypeError(); if (!IsCallable(executor)) throw TypeError(); set_internal(promise, '[[PromiseConstructor]]', Promise); return InitializePromise(promise, executor); } // 25.4.3.1.1 InitializePromise ( promise, executor ) function InitializePromise(promise, executor) { console.assert('[[PromiseState]]' in promise); console.assert(IsCallable(executor)); set_internal(promise, '[[PromiseState]]', 'pending'); set_internal(promise, '[[PromiseFulfillReactions]]', []); set_internal(promise, '[[PromiseRejectReactions]]', []); var resolvingFunctions = CreateResolvingFunctions(promise); try { var completion = executor.call(undefined, resolvingFunctions['[[Resolve]]'], resolvingFunctions['[[Reject]]']); } catch (completion) { var status = resolvingFunctions['[[Reject]]'].call(undefined, completion); } return promise; } // 25.4.4 Properties of the Promise Constructor // 25.4.4.1 Promise.all ( iterable ) define(Promise, 'all', function all(iterable) { var c = strict(this); var promiseCapability = NewPromiseCapability(c); try { var iterator = GetIterator(iterable); } catch (value) { promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } var values = []; var remainingElementsCount = { value: 1 }; var index = 0; while (true) { try { var next = IteratorStep(iterator); } catch (value) { promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } if (!next) { remainingElementsCount.value -= 1; if (remainingElementsCount.value === 0) { var resolveResult = promiseCapability['[[Resolve]]'].apply(undefined, values); } return promiseCapability['[[Promise]]']; } try { var nextValue = IteratorValue(next); } catch (value) { promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } try { var nextPromise = c.resolve(nextValue); } catch (value) { promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } var resolveElement = PromiseAllResolveElementFunction(); set_internal(resolveElement, '[[AlreadyCalled]]', { value: false }); set_internal(resolveElement, '[[Index]]', index); set_internal(resolveElement, '[[Values]]', values); set_internal(resolveElement, '[[Capabilities]]', promiseCapability); set_internal(resolveElement, '[[RemainingElements]]', remainingElementsCount); remainingElementsCount.value += 1; try { var result = nextPromise.then(resolveElement, promiseCapability['[[Reject]]']); } catch (value) { promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } index += 1; } }); // 25.4.4.1.1 Promise.all Resolve Element Functions function PromiseAllResolveElementFunction() { var F = function(x) { var alreadyCalled = F['[[AlreadyCalled]]']; if (alreadyCalled.value) return undefined; alreadyCalled.value = true; var index = F['[[Index]]']; var values = F['[[Values]]']; var promiseCapability = F['[[Capabilities]]']; var remainingElementsCount = F['[[RemainingElements]]']; try { values[index] = x; } catch (result) { promiseCapability['[[Reject]]'].call(undefined, result); return promiseCapability['[[Promise]]']; } remainingElementsCount.value -= 1; if (remainingElementsCount.value === 0) return promiseCapability['[[Resolve]]'].call(undefined, values); return undefined; }; return F; } // 25.4.4.2 Promise.prototype Promise.prototype = {}; // 25.4.4.3 Promise.race ( iterable ) define(Promise, 'race', function race(iterable) { var c = strict(this); var promiseCapability = NewPromiseCapability(c); try { var iterator = GetIterator(iterable); } catch (value) { promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } while (true) { try { var next = IteratorStep(iterator); } catch (value) { promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } if (!next) return promiseCapability['[[Promise]]']; try { var nextValue = IteratorValue(next); } catch (value) { promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } try { var nextPromise = c.resolve(nextValue); } catch (value) { promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } try { nextPromise.then(promiseCapability['[[Resolve]]'], promiseCapability['[[Reject]]']); } catch (value) { promiseCapability['[[Reject]]'].call(undefined, value); return promiseCapability['[[Promise]]']; } } }); // 25.4.4.4 Promise.reject ( r ) define(Promise, 'reject', function reject(r) { var c = strict(this); var promiseCapability = NewPromiseCapability(c); var rejectResult = promiseCapability['[[Reject]]'].call(undefined, r); return promiseCapability['[[Promise]]']; }); // 25.4.4.5 Promise.resolve ( x ) define(Promise, 'resolve', function resolve(x) { var c = strict(this); if (IsPromise(x)) { var constructor = x['[[PromiseConstructor]]']; if (SameValue(constructor, c)) return x; } var promiseCapability = NewPromiseCapability(c); var resolveResult = promiseCapability['[[Resolve]]'].call(undefined, x); return promiseCapability['[[Promise]]']; }); // 25.4.4.6 Promise [ @@create ] ( ) // 25.4.4.6.1 AllocatePromise ( constructor ) // 25.4.5 Properties of the Promise Prototype Object // 25.4.5.1 Promise.prototype.catch ( onRejected ) define(Promise.prototype, 'catch', function catch_(onRejected) { var promise = this; return promise.then(undefined, onRejected); }); // 25.4.5.2 Promise.prototype.constructor Promise.prototype.constructor = Promise; // 25.4.5.3 Promise.prototype.then ( onFulfilled , onRejected ) define(Promise.prototype, 'then', function then(onFulfilled, onRejected) { var promise = this; if (!IsPromise(promise)) throw TypeError(); if (!IsCallable(onFulfilled)) onFulfilled = 'Identity'; if (!IsCallable(onRejected)) onRejected = 'Thrower'; var c = promise.constructor; var promiseCapability = NewPromiseCapability(c); var fulfillReaction = { '[[Capabilities]]': promiseCapability, '[[Handler]]': onFulfilled }; var rejectReaction = { '[[Capabilities]]': promiseCapability, '[[Handler]]': onRejected }; if (promise['[[PromiseState]]'] === 'pending') { promise['[[PromiseFulfillReactions]]'].push(fulfillReaction); promise['[[PromiseRejectReactions]]'].push(rejectReaction); } else if (promise['[[PromiseState]]'] === 'fulfilled') { var value = promise['[[PromiseResult]]']; EnqueueJob('PromiseJobs', PromiseReactionJob, [fulfillReaction, value]); } else if (promise['[[PromiseState]]'] === 'rejected') { var reason = promise['[[PromiseResult]]']; EnqueueJob('PromiseJobs', PromiseReactionJob, [rejectReaction, reason]); } return promiseCapability['[[Promise]]']; }); // 25.4.6 Properties of Promise Instances if (!('Promise' in global) || OVERRIDE_NATIVE_FOR_TESTING) global.Promise = Promise; // Patch early Promise.cast vs. Promise.resolve implementations if ('cast' in global.Promise) global.Promise.resolve = global.Promise.cast; }()); // 25.4.5.1 Promise.prototype [ @@toStringTag ] define(Promise.prototype, $$toStringTag, 'Promise'); // --------------------------------------- // 26 Reflection // --------------------------------------- (function() { // 26.1 The Reflect Object if (!('Reflect' in global) || OVERRIDE_NATIVE_FOR_TESTING) global.Reflect = {}; // 26.1.1 Reflect.apply ( target, thisArgument, argumentsList ) define( Reflect, 'apply', function apply(target, thisArgument, argumentsList) { if (!IsCallable(target)) throw TypeError(); return Function.prototype.apply.call(target, thisArgument, argumentsList); }); // 26.1.2 Reflect.construct ( target, argumentsList [, newTarget] ) define( Reflect, 'construct', function construct(target, argumentsList) { return __cons(target, argumentsList); }); // 26.1.3 Reflect.defineProperty ( target, propertyKey, attributes ) define( Reflect, 'defineProperty', function defineProperty(target, propertyKey, attributes) { try { Object.defineProperty(target, propertyKey, attributes); return true; } catch (_) { return false; } }); // 26.1.4 Reflect.deleteProperty ( target, propertyKey ) define( Reflect, 'deleteProperty', function deleteProperty(target,name) { try { delete target[name]; return !HasOwnProperty(target, name); } catch (_) { return false; } }); // 26.1.5 Reflect.enumerate ( target ) define( Reflect, 'enumerate', function enumerate(target) { target = ToObject(target); var iterator = Enumerate(target); return iterator; }); // 26.1.6 Reflect.get ( target, propertyKey [ , receiver ]) define( Reflect, 'get', function get(target, name, receiver) { target = ToObject(target); name = String(name); receiver = (receiver === undefined) ? target : ToObject(receiver); var desc = getPropertyDescriptor(target, name); if (desc && 'get' in desc) return Function.prototype.call.call(desc['get'], receiver); return target[name]; }); // 26.1.7 Reflect.getOwnPropertyDescriptor ( target, propertyKey ) define( Reflect, 'getOwnPropertyDescriptor', Object.getOwnPropertyDescriptor); // 26.1.8 Reflect.getPrototypeOf ( target ) define( Reflect, 'getPrototypeOf', Object.getPrototypeOf); // 26.1.9 Reflect.has ( target, propertyKey ) define( Reflect, 'has', function has(target,name) { return String(name) in ToObject(target); }); // 26.1.10 Reflect.isExtensible (target) define( Reflect, 'isExtensible', Object.isExtensible); // 26.1.11 Reflect.ownKeys ( target ) define( Reflect, 'ownKeys', function ownKeys(target) { var obj = ToObject(target); return Object.getOwnPropertyNames(obj); }); // 26.1.12 Reflect.preventExtensions ( target ) define( Reflect, 'preventExtensions', function preventExtensions(target) { try { Object.preventExtensions(target); return true; } catch (_) { return false; } }); // 26.1.13 Reflect.set ( target, propertyKey, V [ , receiver ] ) define( Reflect, 'set', function set(target, name, value, receiver) { target = ToObject(target); name = String(name); receiver = (receiver === undefined) ? target : ToObject(receiver); var desc = getPropertyDescriptor(target, name); try { if (desc && 'set' in desc) Function.prototype.call.call(desc['set'], receiver, value); else target[name] = value; return true; } catch (_) { return false; } }); // 26.1.14 Reflect.setPrototypeOf ( target, proto ) define( Reflect, 'setPrototypeOf', function setPrototypeOf(target, proto) { try { target.__proto__ = proto; return Reflect.getPrototypeOf(target) === proto; } catch(_) { return false; } }); }()); // --------------------------------------- // 26.2 Proxy Objects // --------------------------------------- // Not polyfillable. }(self)); // This helper is defined outside the main scope so that the use of // 'eval' does not taint the scope for minifiers. function __cons(t, a) { return eval('new t(' + Array.prototype.map.call(a, function(_, i) { return 'a[' + i + ']'; }).join(',') + ')'); } //---------------------------------------------------------------------- // // ECMAScript 2016 Polyfills // //---------------------------------------------------------------------- (function (global) { "use strict"; var undefined = (void 0); // Paranoia // Helpers function isSymbol(s) { return (typeof s === 'symbol') || ('Symbol' in global && s instanceof global.Symbol); } function define(o, p, v, override) { if (p in o && !override) return; if (typeof v === 'function') { // Sanity check that functions are appropriately named (where possible) console.assert(isSymbol(p) || !('name' in v) || v.name === p || v.name === p + '_', 'Expected function name "' + p.toString() + '", was "' + v.name + '"'); Object.defineProperty(o, p, { value: v, configurable: true, enumerable: false, writable: true }); } else { Object.defineProperty(o, p, { value: v, configurable: false, enumerable: false, writable: false }); } } // Snapshot intrinsic functions var $isNaN = global.isNaN; var abs = Math.abs, floor = Math.floor, max = Math.max, min = Math.min; //---------------------------------------- // 7 Abstract Operations //---------------------------------------- // 7.1.4 function ToInteger(n) { n = Number(n); if ($isNaN(n)) return 0; if (n === 0 || n === Infinity || n === -Infinity) return n; return ((n < 0) ? -1 : 1) * floor(abs(n)); } // 7.1.13 ToObject function ToObject(v) { if (v === null || v === undefined) throw TypeError(); return Object(v); } // 7.1.15 ToLength ( argument ) function ToLength(v) { var len = ToInteger(v); if (len <= 0) { return 0; } return min(len, 0x20000000000000 - 1); // 2^53-1 } //---------------------------------------- // 7.2 Testing and Comparison Operations //---------------------------------------- // 7.2.10 SameValueZero(x, y) function SameValueZero(x, y) { if (typeof x !== typeof y) return false; switch (typeof x) { case 'undefined': return true; case 'number': if (x !== x && y !== y) return true; return x === y; case 'boolean': case 'string': case 'object': default: return x === y; } } //---------------------------------------------------------------------- // // ECMAScript 2016 // //---------------------------------------------------------------------- // https://github.com/tc39/Array.prototype.includes/ define( Array.prototype, 'includes', function includes(target) { var fromIndex = arguments[1]; var o = ToObject(this); var len = ToLength(o["length"]); if (len === 0) return false; var n = ToInteger(fromIndex); if (n >= 0) { var k = n; } else { k = len + n; if (k < 0) k = 0; } while (k < len) { var elementK = o[k]; if (SameValueZero(o[k], target)) return true; k += 1; } return false; }); }(this)); //---------------------------------------------------------------------- // // ECMAScript 2017 Polyfills // //---------------------------------------------------------------------- (function (global) { 'use strict'; var undefined = (void 0); // Paranoia // Helpers function isSymbol(s) { return (typeof s === 'symbol') || ('Symbol' in global && s instanceof global.Symbol); } function define(o, p, v, override) { if (p in o && !override) return; if (typeof v === 'function') { // Sanity check that functions are appropriately named (where possible) console.assert(isSymbol(p) || !('name' in v) || v.name === p || v.name === p + '_', 'Expected function name "' + p.toString() + '", was "' + v.name + '"'); Object.defineProperty(o, p, { value: v, configurable: true, enumerable: false, writable: true }); } else { Object.defineProperty(o, p, { value: v, configurable: false, enumerable: false, writable: false }); } } // Snapshot intrinsic functions var $isNaN = global.isNaN; var abs = Math.abs, floor = Math.floor, min = Math.min; //---------------------------------------- // 7 Abstract Operations //---------------------------------------- // 7.1.4 function ToInteger(n) { n = Number(n); if ($isNaN(n)) return 0; if (n === 0 || n === Infinity || n === -Infinity) return n; return ((n < 0) ? -1 : 1) * floor(abs(n)); } // 7.1.13 ToObject function ToObject(v) { if (v === null || v === undefined) throw TypeError(); return Object(v); } // 7.1.15 ToLength ( argument ) function ToLength(v) { var len = ToInteger(v); if (len <= 0) { return 0; } return min(len, 0x20000000000000 - 1); // 2^53-1 } //---------------------------------------- // 7.3 Operations on Objects //---------------------------------------- // 7.3.4 function CreateDataProperty(O, P, V) { Object.defineProperty(O, P, { value: V, writable: true, enumerable: true, configurable: true }); } // 7.3.21 function EnumerableOwnProperties(o, kind) { var ownKeys = Object.keys(o); var properties = []; ownKeys.forEach(function(key) { var desc = Object.getOwnPropertyDescriptor(o, key); if (desc && desc.enumerable) { if (kind === 'key') properties.push(key); else { var value = o[key]; if (kind === 'value') properties.push(value); else properties.push([key, value]); } } }); return properties; } //---------------------------------------------------------------------- // 19 Fundamental Objects //---------------------------------------------------------------------- // 19.1 Object Objects // 19.1.2 Properties of the Object Constructor // 19.1.2.5 Object.entries define( Object, 'entries', function entries(o) { var obj = ToObject(o); return EnumerableOwnProperties(obj, 'key+value'); }); // 19.1.2.8 Object.getOwnPropertyDescriptors ( O ) define( Object, 'getOwnPropertyDescriptors', function getOwnPropertyDescriptors(o) { var obj = ToObject(o); // ReturnIfAbrupt(obj) var keys = Object.getOwnPropertyNames(obj); // ReturnIfAbrupt(keys) var descriptors = {}; for (var i = 0; i < keys.length; ++i) { var nextKey = keys[i]; var descriptor = Object.getOwnPropertyDescriptor(obj, nextKey); // ReturnIfAbrupt(desc) // ReturnIfAbrupt(descriptor) CreateDataProperty(descriptors, nextKey, descriptor); } return descriptors; }); // 19.1.2.21 Object.values define( Object, 'values', function values(o) { var obj = ToObject(o); return EnumerableOwnProperties(obj, 'value'); }); //---------------------------------------------------------------------- // 21 Text Processing //---------------------------------------------------------------------- // 21.1 String Objects // 21.1.3 Properties of the String Prototype Object // 21.1.3.13 String.prototype.padEnd( maxLength [ , fillString ] ) define( String.prototype, 'padEnd', function padEnd(maxLength) { var fillString = arguments[1]; var o = this; // ReturnIfAbrupt(o) var s = String(this); // ReturnIfAbrupt(s) var stringLength = s.length; if (fillString === undefined) var fillStr = ''; else fillStr = String(fillString); // ReturnIfAbrupt(fillStr) if (fillStr === '') fillStr = ' '; var intMaxLength = ToLength(maxLength); // ReturnIfAbrupt(intMaxLength) if (intMaxLength <= stringLength) return s; var fillLen = intMaxLength - stringLength; var stringFiller = ''; while (stringFiller.length < fillLen) stringFiller = stringFiller + fillStr; return s + stringFiller.substring(0, fillLen); }); // 21.1.3.14 String.prototype.padStart( maxLength [ , fillString ] ) define( String.prototype, 'padStart', function padStart(maxLength) { var fillString = arguments[1]; var o = this; // ReturnIfAbrupt(o) var s = String(this); // ReturnIfAbrupt(s) var stringLength = s.length; if (fillString === undefined) var fillStr = ''; else fillStr = String(fillString); // ReturnIfAbrupt(fillStr) if (fillStr === '') fillStr = ' '; var intMaxLength = ToLength(maxLength); // ReturnIfAbrupt(intMaxLength) if (intMaxLength <= stringLength) return s; var fillLen = intMaxLength - stringLength; var stringFiller = ''; while (stringFiller.length < fillLen) stringFiller = stringFiller + fillStr; return stringFiller.substring(0, fillLen) + s; }); }(this)); (function(global) { 'use strict'; if (!('window' in global && 'document' in global)) return; //---------------------------------------------------------------------- // // HTML // https://html.spec.whatwg.org // //---------------------------------------------------------------------- // document.head attribute // Needed for: IE8- if (!('head' in document)) document.head = document.getElementsByTagName('head')[0]; // Ensure correct parsing of newish elements ("shiv") // Needed for: IE8- [ 'abbr', 'article', 'aside', 'audio', 'bdi', 'canvas', 'data', 'datalist', 'details', 'dialog', 'figcaption', 'figure', 'footer', 'header', 'hgroup', 'main', 'mark', 'meter', 'nav', 'output', 'picture', 'progress', 'section', 'summary', 'template', 'time', 'video'].forEach(function(tag) { document.createElement(tag); }); // HTMLElement.dataset // Needed for: IE10- if (!('dataset' in document.createElement('span')) && 'Element' in global && Element.prototype && Object.defineProperty) { Object.defineProperty(Element.prototype, 'dataset', { get: function() { var result = Object.create(null); for (var i = 0; i < this.attributes.length; ++i) { var attr = this.attributes[i]; if (attr.specified && attr.name.substring(0, 5) === 'data-') { (function(element, name) { var prop = name.replace(/-([a-z])/g, function(m, p) { return p.toUpperCase(); }); result[prop] = element.getAttribute('data-' + name); // Read-only, for IE8- Object.defineProperty(result, prop, { get: function() { return element.getAttribute('data-' + name); }, set: function(value) { element.setAttribute('data-' + name, value); }}); }(this, attr.name.substring(5))); } } return result; }}); } // Base64 utility methods // Needed for: IE9- (function() { if ('atob' in global && 'btoa' in global) return; var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; function atob(input) { input = String(input); var position = 0, output = [], buffer = 0, bits = 0, n; input = input.replace(/\s/g, ''); if ((input.length % 4) === 0) { input = input.replace(/=+$/, ''); } if ((input.length % 4) === 1) { throw Error("InvalidCharacterError"); } if (/[^+/0-9A-Za-z]/.test(input)) { throw Error("InvalidCharacterError"); } while (position < input.length) { n = B64_ALPHABET.indexOf(input.charAt(position)); buffer = (buffer << 6) | n; bits += 6; if (bits === 24) { output.push(String.fromCharCode((buffer >> 16) & 0xFF)); output.push(String.fromCharCode((buffer >> 8) & 0xFF)); output.push(String.fromCharCode(buffer & 0xFF)); bits = 0; buffer = 0; } position += 1; } if (bits === 12) { buffer = buffer >> 4; output.push(String.fromCharCode(buffer & 0xFF)); } else if (bits === 18) { buffer = buffer >> 2; output.push(String.fromCharCode((buffer >> 8) & 0xFF)); output.push(String.fromCharCode(buffer & 0xFF)); } return output.join(''); }; function btoa(input) { input = String(input); var position = 0, out = [], o1, o2, o3, e1, e2, e3, e4; if (/[^\x00-\xFF]/.test(input)) { throw Error("InvalidCharacterError"); } while (position < input.length) { o1 = input.charCodeAt(position++); o2 = input.charCodeAt(position++); o3 = input.charCodeAt(position++); // 111111 112222 222233 333333 e1 = o1 >> 2; e2 = ((o1 & 0x3) << 4) | (o2 >> 4); e3 = ((o2 & 0xf) << 2) | (o3 >> 6); e4 = o3 & 0x3f; if (position === input.length + 2) { e3 = 64; e4 = 64; } else if (position === input.length + 1) { e4 = 64; } out.push(B64_ALPHABET.charAt(e1), B64_ALPHABET.charAt(e2), B64_ALPHABET.charAt(e3), B64_ALPHABET.charAt(e4)); } return out.join(''); }; global.atob = atob; global.btoa = btoa; }()); // requestAnimationFrame - needed for IE9- (function() { if ('requestAnimationFrame' in global) return; var TARGET_FPS = 60, requests = Object.create(null), raf_handle = 0, timeout_handle = -1; function isVisible(element) { return element.offsetWidth > 0 && element.offsetHeight > 0; } function onFrameTimer() { var cur_requests = requests; requests = Object.create(null); timeout_handle = -1; Object.keys(cur_requests).forEach(function(id) { var request = cur_requests[id]; if (!request.element || isVisible(request.element)) request.callback(Date.now()); }); } function requestAnimationFrame(callback, element) { var cb_handle = ++raf_handle; requests[cb_handle] = {callback: callback, element: element}; if (timeout_handle === -1) timeout_handle = global.setTimeout(onFrameTimer, 1000 / TARGET_FPS); return cb_handle; } function cancelAnimationFrame(handle) { delete requests[handle]; if (Object.keys(requests).length === 0) { global.clearTimeout(timeout_handle); timeout_handle = -1; } } global.requestAnimationFrame = requestAnimationFrame; global.cancelAnimationFrame = cancelAnimationFrame; }()); }(self)); (function(global) { 'use strict'; if (!('window' in global && 'document' in global)) return; //---------------------------------------------------------------------- // // DOM // https://dom.spec.whatwg.org/ // //---------------------------------------------------------------------- // Document.querySelectorAll method // http://ajaxian.com/archives/creating-a-queryselector-for-ie-that-runs-at-native-speed // Needed for: IE7- if (!document.querySelectorAll) { document.querySelectorAll = function(selectors) { var style = document.createElement('style'), elements = [], element; document.documentElement.firstChild.appendChild(style); document._qsa = []; style.styleSheet.cssText = selectors + '{x-qsa:expression(document._qsa && document._qsa.push(this))}'; window.scrollBy(0, 0); style.parentNode.removeChild(style); while (document._qsa.length) { element = document._qsa.shift(); element.style.removeAttribute('x-qsa'); elements.push(element); } document._qsa = null; return elements; }; } // Document.querySelector method // Needed for: IE7- if (!document.querySelector) { document.querySelector = function(selectors) { var elements = document.querySelectorAll(selectors); return (elements.length) ? elements[0] : null; }; } // Document.getElementsByClassName method // Needed for: IE8- if (!document.getElementsByClassName) { document.getElementsByClassName = function(classNames) { classNames = String(classNames).replace(/^|\s+/g, '.'); return document.querySelectorAll(classNames); }; } // Node interface constants // Needed for: IE8- global.Node = global.Node || function() { throw TypeError("Illegal constructor"); }; [ ['ELEMENT_NODE', 1], ['ATTRIBUTE_NODE', 2], ['TEXT_NODE', 3], ['CDATA_SECTION_NODE', 4], ['ENTITY_REFERENCE_NODE', 5], ['ENTITY_NODE', 6], ['PROCESSING_INSTRUCTION_NODE', 7], ['COMMENT_NODE', 8], ['DOCUMENT_NODE', 9], ['DOCUMENT_TYPE_NODE', 10], ['DOCUMENT_FRAGMENT_NODE', 11], ['NOTATION_NODE', 12] ].forEach(function(p) { if (!(p[0] in global.Node)) global.Node[p[0]] = p[1]; }); // DOMException constants // Needed for: IE8- global.DOMException = global.DOMException || function() { throw TypeError("Illegal constructor"); }; [ ['INDEX_SIZE_ERR', 1], ['DOMSTRING_SIZE_ERR', 2], ['HIERARCHY_REQUEST_ERR', 3], ['WRONG_DOCUMENT_ERR', 4], ['INVALID_CHARACTER_ERR', 5], ['NO_DATA_ALLOWED_ERR', 6], ['NO_MODIFICATION_ALLOWED_ERR', 7], ['NOT_FOUND_ERR', 8], ['NOT_SUPPORTED_ERR', 9], ['INUSE_ATTRIBUTE_ERR', 10], ['INVALID_STATE_ERR', 11], ['SYNTAX_ERR', 12], ['INVALID_MODIFICATION_ERR', 13], ['NAMESPACE_ERR', 14], ['INVALID_ACCESS_ERR', 15] ].forEach(function(p) { if (!(p[0] in global.DOMException)) global.DOMException[p[0]] = p[1]; }); // Event and EventTargets interfaces // Needed for: IE8 (function(){ if (!('Element' in global) || Element.prototype.addEventListener || !Object.defineProperty) return; // interface Event // PhaseType (const unsigned short) Event.CAPTURING_PHASE = 1; Event.AT_TARGET = 2; Event.BUBBLING_PHASE = 3; Object.defineProperties(Event.prototype, { CAPTURING_PHASE: { get: function() { return 1; } }, AT_TARGET: { get: function() { return 2; } }, BUBBLING_PHASE: { get: function() { return 3; } }, target: { get: function() { return this.srcElement; }}, currentTarget: { get: function() { return this._currentTarget; }}, eventPhase: { get: function() { return (this.srcElement === this.currentTarget) ? Event.AT_TARGET : Event.BUBBLING_PHASE; }}, bubbles: { get: function() { switch (this.type) { // Mouse case 'click': case 'dblclick': case 'mousedown': case 'mouseup': case 'mouseover': case 'mousemove': case 'mouseout': case 'mousewheel': // Keyboard case 'keydown': case 'keypress': case 'keyup': // Frame/Object case 'resize': case 'scroll': // Form case 'select': case 'change': case 'submit': case 'reset': return true; } return false; }}, cancelable: { get: function() { switch (this.type) { // Mouse case 'click': case 'dblclick': case 'mousedown': case 'mouseup': case 'mouseover': case 'mouseout': case 'mousewheel': // Keyboard case 'keydown': case 'keypress': case 'keyup': // Form case 'submit': return true; } return false; }}, timeStamp: { get: function() { return this._timeStamp; }}, stopPropagation: { value: function() { this.cancelBubble = true; }}, preventDefault: { value: function() { this.returnValue = false; }}, defaultPrevented: { get: function() { return this.returnValue === false; }} }); // interface EventTarget function addEventListener(type, listener, useCapture) { if (typeof listener !== 'function') return; if (type === 'DOMContentLoaded') type = 'load'; var target = this; var f = function(e) { e._timeStamp = Date.now(); e._currentTarget = target; listener.call(this, e); e._currentTarget = null; }; this['_' + type + listener] = f; this.attachEvent('on' + type, f); } function removeEventListener(type, listener, useCapture) { if (typeof listener !== 'function') return; if (type === 'DOMContentLoaded') type = 'load'; var f = this['_' + type + listener]; if (f) { this.detachEvent('on' + type, f); this['_' + type + listener] = null; } } [Window, HTMLDocument, Element].forEach(function(o) { o.prototype.addEventListener = addEventListener; o.prototype.removeEventListener = removeEventListener; }); }()); // CustomEvent // https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/CustomEvent // Needed for: IE (function () { if ('CustomEvent' in global && typeof global.CustomEvent === "function") return; function CustomEvent ( event, params ) { params = params || { bubbles: false, cancelable: false, detail: undefined }; var evt = document.createEvent( 'CustomEvent' ); evt.initCustomEvent( event, params.bubbles, params.cancelable, params.detail ); return evt; } CustomEvent.prototype = global.Event.prototype; global.CustomEvent = CustomEvent; })(); // Shim for DOM Events for IE7- // http://www.quirksmode.org/blog/archives/2005/10/_and_the_winner_1.html // Use addEvent(object, event, handler) instead of object.addEventListener(event, handler) window.addEvent = function(obj, type, fn) { if (obj.addEventListener) { obj.addEventListener(type, fn, false); } else if (obj.attachEvent) { obj["e" + type + fn] = fn; obj[type + fn] = function() { var e = window.event; e.currentTarget = obj; e.preventDefault = function() { e.returnValue = false; }; e.stopPropagation = function() { e.cancelBubble = true; }; e.target = e.srcElement; e.timeStamp = Date.now(); obj["e" + type + fn].call(this, e); }; obj.attachEvent("on" + type, obj[type + fn]); } }; window.removeEvent = function(obj, type, fn) { if (obj.removeEventListener) { obj.removeEventListener(type, fn, false); } else if (obj.detachEvent) { obj.detachEvent("on" + type, obj[type + fn]); obj[type + fn] = null; obj["e" + type + fn] = null; } }; function addToElementPrototype(p, f) { if ('Element' in global && Element.prototype && Object.defineProperty) { Object.defineProperty(Element.prototype, p, { get: f }); } } // DOMTokenList interface and Element.classList / Element.relList // Needed for: IE9- // Use getClassList(elem) instead of elem.classList() if IE7- support is needed // Use getRelList(elem) instead of elem.relList() if IE7- support is needed (function() { function DOMTokenListShim(o, p) { function split(s) { return s.length ? s.split(/\s+/g) : []; } // NOTE: This does not exactly match the spec. function removeTokenFromString(token, string) { var tokens = split(string), index = tokens.indexOf(token); if (index !== -1) { tokens.splice(index, 1); } return tokens.join(' '); } Object.defineProperties( this, { length: { get: function() { return split(o[p]).length; } }, item: { value: function(idx) { var tokens = split(o[p]); return 0 <= idx && idx < tokens.length ? tokens[idx] : null; } }, contains: { value: function(token) { token = String(token); var tokens = split(o[p]); return tokens.indexOf(token) !== -1; } }, add: { value: function(/*tokens...*/) { var tokens = Array.prototype.slice.call(arguments).map(String); if (tokens.some(function(token) { return token.length === 0; })) { throw SyntaxError(); } if (tokens.some(function(token) { return (/\s/).test(token); })) { throw Error("InvalidCharacterError"); } try { var underlying_string = o[p]; var token_list = split(underlying_string); tokens = tokens.filter(function(token) { return token_list.indexOf(token) === -1; }); if (tokens.length === 0) { return; } if (underlying_string.length !== 0 && !(/\s$/).test(underlying_string)) { underlying_string += ' '; } underlying_string += tokens.join(' '); o[p] = underlying_string; } finally { var length = split(o[p]).length; if (this.length !== length) { this.length = length; } } } }, remove: { value: function(/*tokens...*/) { var tokens = Array.prototype.slice.call(arguments).map(String); if (tokens.some(function(token) { return token.length === 0; })) { throw SyntaxError(); } if (tokens.some(function(token) { return (/\s/).test(token); })) { throw Error("InvalidCharacterError"); } try { var underlying_string = o[p]; tokens.forEach(function(token) { underlying_string = removeTokenFromString(token, underlying_string); }); o[p] = underlying_string; } finally { var length = split(o[p]).length; if (this.length !== length) { this.length = length; } } } }, toggle: { value: function(token/*, force*/) { var force = arguments[1]; try { token = String(token); if (token.length === 0) { throw SyntaxError(); } if (/\s/.test(token)) { throw Error("InvalidCharacterError"); } var tokens = split(o[p]), index = tokens.indexOf(token); if (index !== -1 && (!force || force === (void 0))) { o[p] = removeTokenFromString(token, o[p]); return false; } if (index !== -1 && force) { return true; } var underlying_string = o[p]; if (underlying_string.length !== 0 && !/\s$/.test(underlying_string)) { underlying_string += ' '; } underlying_string += token; o[p] = underlying_string; return true; } finally { var length = split(o[p]).length; if (this.length !== length) { this.length = length; } } } }, toString: { value: function() { return o[p]; } } }); if (!('length' in this)) { // In case getters are not supported this.length = split(o[p]).length; } else { // If they are, shim in index getters (up to 100) for (var i = 0; i < 100; ++i) { Object.defineProperty(this, String(i), { get: (function(n) { return function() { return this.item(n); }; }(i)) }); } } } // HTML - https://html.spec.whatwg.org // Element.classList if ('classList' in document.createElement('span')) { window.getClassList = function(elem) { return elem.classList; }; } else { window.getClassList = function(elem) { return new DOMTokenListShim(elem, 'className'); }; addToElementPrototype('classList', function() { return new DOMTokenListShim(this, 'className'); } ); } // HTML - https://html.spec.whatwg.org // HTMLAnchorElement.relList // HTMLLinkElement.relList if ('relList' in document.createElement('link')) { window.getRelList = function(elem) { return elem.relList; }; } else { window.getRelList = function(elem) { return new DOMTokenListShim(elem, 'rel'); }; addToElementPrototype('relList', function() { return new DOMTokenListShim(this, 'rel'); } ); } // Add second argument to native DOMTokenList.toggle() if necessary (function() { if (!('DOMTokenList' in global)) return; var e = document.createElement('span'); if (!('classList' in e)) return; e.classList.toggle('x', false); if (!e.classList.contains('x')) return; global.DOMTokenList.prototype.toggle = function toggle(token/*, force*/) { var force = arguments[1]; if (force === undefined) { var add = !this.contains(token); this[add ? 'add' : 'remove'](token); return add; } force = !!force; this[force ? 'add' : 'remove'](token); return force; }; }()); }()); // Interface NonDocumentTypeChildNode // previousElementSibling / nextElementSibling - for IE8 if (!('previousElementSibling' in document.documentElement)) { addToElementPrototype('previousElementSibling', function() { var n = this.previousSibling; while (n && n.nodeType !== Node.ELEMENT_NODE) n = n.previousSibling; return n; }); } if (!('nextElementSibling' in document.documentElement)) { addToElementPrototype('nextElementSibling', function() { var n = this.nextSibling; while (n && n.nodeType !== Node.ELEMENT_NODE) n = n.nextSibling; return n; }); } // Element.matches // https://developer.mozilla.org/en/docs/Web/API/Element/matches // Needed for: IE, Firefox 3.6, early Webkit and Opera 15.0 // Use msMatchesSelector(selector) for IE // Use oMatchesSelector(selector) for Opera 15.0 // Use mozMatchesSelector(selector) for Firefox 3.6 // Use webkitMatchesSelector(selector) for early Webkit // Use polyfill if no matches() support, but querySelectorAll() support if ('Element' in global && !Element.prototype.matches) { if (Element.prototype.msMatchesSelector) { Element.prototype.matches = Element.prototype.msMatchesSelector; } else if (Element.prototype.oMatchesSelector) { Element.prototype.matches = Element.prototype.oMatchesSelector; } else if (Element.prototype.mozMatchesSelector) { Element.prototype.matches = Element.prototype.mozMatchesSelector; } else if (Element.prototype.webkitMatchesSelector) { Element.prototype.matches = Element.prototype.webkitMatchesSelector; } else if (document.querySelectorAll) { Element.prototype.matches = function matches(selector) { var matches = (this.document || this.ownerDocument).querySelectorAll(selector), i = matches.length; while (--i >= 0 && matches.item(i) !== this) {} return i > -1; }; } } // Element.closest // https://developer.mozilla.org/en-US/docs/Web/API/Element/closest if (window.Element && !Element.prototype.closest) { Element.prototype.closest = function(s) { var matches = (this.document || this.ownerDocument).querySelectorAll(s), i, el = this; do { i = matches.length; while (--i >= 0 && matches.item(i) !== el) {}; } while ((i < 0) && (el = el.parentElement)); return el; }; } function mixin(o, ps) { if (!o) return; Object.keys(ps).forEach(function(p) { if ((p in o) || (p in o.prototype)) return; try { Object.defineProperty( o.prototype, p, Object.getOwnPropertyDescriptor(ps, p) ); } catch (ex) { // Throws in IE8; just copy it o[p] = ps[p]; } }); } // Mixin ParentNode // https://dom.spec.whatwg.org/#interface-parentnode function convertNodesIntoANode(nodes) { var node = null; nodes = nodes.map(function(node) { return !(node instanceof Node) ? document.createTextNode(node) : node; }); if (nodes.length === 1) { node = nodes[0]; } else { node = document.createDocumentFragment(); nodes.forEach(function(n) { node.appendChild(n); }); } return node; } var ParentNode = { prepend: function(/*...nodes*/) { var nodes = [].slice.call(arguments); nodes = convertNodesIntoANode(nodes); this.insertBefore(nodes, this.firstChild); }, append: function(/*...nodes*/) { var nodes = [].slice.call(arguments); nodes = convertNodesIntoANode(nodes); this.appendChild(nodes); } }; mixin(global.Document || global.HTMLDocument, ParentNode); // HTMLDocument for IE8 mixin(global.DocumentFragment, ParentNode); mixin(global.Element, ParentNode); // Attributes for IE8 if (!('firstElementChild' in document.documentElement)) { addToElementPrototype('firstElementChild', function() { for (var nodes = this.children, i = 0, l = nodes.length; i < l; ++i) { var n = nodes[i]; if (n.nodeType === Node.ELEMENT_NODE) return n; } return null; }); } if (!('lastElementChild' in document.documentElement)) { addToElementPrototype('lastElementChild', function() { for (var nodes = this.children, i = nodes.length - 1; i >= 0; --i) { var n = nodes[i]; if (n.nodeType === Node.ELEMENT_NODE) return n; } return null; }); } if (!('childElementCount' in document.documentElement)) { addToElementPrototype('childElementCount', function() { for (var c = 0, nodes = this.children, i = 0, l = nodes.length; i < l; ++i) { if (nodes[i].nodeType === Node.ELEMENT_NODE) ++c; } return c; }); } // Mixin ChildNode // https://dom.spec.whatwg.org/#interface-childnode var ChildNode = { before: function(/*...nodes*/) { var nodes = [].slice.call(arguments); var parent = this.parentNode; if (!parent) return; var viablePreviousSibling = this.previousSibling; while (nodes.indexOf(viablePreviousSibling) !== -1) viablePreviousSibling = viablePreviousSibling.previousSibling; var node = convertNodesIntoANode(nodes); parent.insertBefore(node, viablePreviousSibling ? viablePreviousSibling.nextSibling : parent.firstChild); }, after: function(/*...nodes*/) { var nodes = [].slice.call(arguments); var parent = this.parentNode; if (!parent) return; var viableNextSibling = this.nextSibling; while (nodes.indexOf(viableNextSibling) !== -1) viableNextSibling = viableNextSibling.nextSibling; var node = convertNodesIntoANode(nodes); parent.insertBefore(node, viableNextSibling); }, replaceWith: function(/*...nodes*/) { var nodes = [].slice.call(arguments); var parent = this.parentNode; if (!parent) return; var viableNextSibling = this.nextSibling; while (nodes.indexOf(viableNextSibling) !== -1) viableNextSibling = viableNextSibling.nextSibling; var node = convertNodesIntoANode(nodes); if (this.parentNode === parent) parent.replaceChild(node, this); else parent.insertBefore(node, viableNextSibling); }, remove: function() { if (!this.parentNode) return; this.parentNode.removeChild(this); } }; mixin(global.DocumentType, ChildNode); mixin(global.Element, ChildNode); mixin(global.CharacterData, ChildNode); }(self)); (function(global) { 'use strict'; if (!('window' in global && 'document' in global)) return; //---------------------------------------------------------------------- // // XMLHttpRequest // https://xhr.spec.whatwg.org // //---------------------------------------------------------------------- // XMLHttpRequest interface // Needed for: IE7- global.XMLHttpRequest = global.XMLHttpRequest || function() { try { return new ActiveXObject("Msxml2.XMLHTTP.6.0"); } catch (_) { } try { return new ActiveXObject("Msxml2.XMLHTTP.3.0"); } catch (_) { } try { return new ActiveXObject("Msxml2.XMLHTTP"); } catch (_) { } throw Error("This browser does not support XMLHttpRequest."); }; // XMLHttpRequest interface constants // Needed for IE8- [ ['UNSENT', 0], ['OPENED', 1], ['HEADERS_RECEIVED', 2], ['LOADING', 3], ['DONE', 4], ].forEach(function(p) { if (!(p[0] in global.XMLHttpRequest)) global.XMLHttpRequest[p[0]] = p[1]; }); // FormData interface // Needed for: IE9- (function() { if ('FormData' in global) return; function FormData(form) { this._data = []; if (!form) return; for (var i = 0; i < form.elements.length; ++i) { var element = form.elements[i]; if (element.name !== '') this.append(element.name, element.value); } } FormData.prototype = { append: function(name, value /*, filename */) { if ('Blob' in global && value instanceof global.Blob) throw TypeError("Blob not supported"); name = String(name); this._data.push([name, value]); }, toString: function() { return this._data.map(function(pair) { return encodeURIComponent(pair[0]) + '=' + encodeURIComponent(pair[1]); }).join('&'); } }; global.FormData = FormData; var send = global.XMLHttpRequest.prototype.send; global.XMLHttpRequest.prototype.send = function(body) { if (body instanceof FormData) { this.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded'); arguments[0] = body.toString(); } return send.apply(this, arguments); }; }()); }(self)); (function(global) { 'use strict'; if (!('window' in global && 'document' in global)) return; //---------------------------------------------------------------------- // // CSSOM View Module // https://dev.w3.org/csswg/cssom-view/ // //---------------------------------------------------------------------- // Fix for IE8-'s Element.getBoundingClientRect() if ('TextRectangle' in global && !('width' in global.TextRectangle.prototype)) { Object.defineProperties(global.TextRectangle.prototype, { width: { get: function() { return this.right - this.left; } }, height: { get: function() { return this.bottom - this.top; } } }); } }(self)); // URL Polyfill // Draft specification: https://url.spec.whatwg.org // Notes: // - Primarily useful for parsing URLs and modifying query parameters // - Should work in IE8+ and everything more modern, with es5.js polyfills (function (global) { 'use strict'; function isSequence(o) { if (!o) return false; if ('Symbol' in global && 'iterator' in global.Symbol && typeof o[Symbol.iterator] === 'function') return true; if (Array.isArray(o)) return true; return false; } function toArray(iter) { return ('from' in Array) ? Array.from(iter) : Array.prototype.slice.call(iter); } (function() { // Browsers may have: // * No global URL object // * URL with static methods only - may have a dummy constructor // * URL with members except searchParams // * Full URL API support var origURL = global.URL; var nativeURL; try { if (origURL) { nativeURL = new global.URL('http://example.com'); if ('searchParams' in nativeURL) return; if (!('href' in nativeURL)) nativeURL = undefined; } } catch (_) {} // NOTE: Doesn't do the encoding/decoding dance function urlencoded_serialize(pairs) { var output = '', first = true; pairs.forEach(function (pair) { var name = encodeURIComponent(pair.name); var value = encodeURIComponent(pair.value); if (!first) output += '&'; output += name + '=' + value; first = false; }); return output.replace(/%20/g, '+'); } // NOTE: Doesn't do the encoding/decoding dance function urlencoded_parse(input, isindex) { var sequences = input.split('&'); if (isindex && sequences[0].indexOf('=') === -1) sequences[0] = '=' + sequences[0]; var pairs = []; sequences.forEach(function (bytes) { if (bytes.length === 0) return; var index = bytes.indexOf('='); if (index !== -1) { var name = bytes.substring(0, index); var value = bytes.substring(index + 1); } else { name = bytes; value = ''; } name = name.replace(/\+/g, ' '); value = value.replace(/\+/g, ' '); pairs.push({ name: name, value: value }); }); var output = []; pairs.forEach(function (pair) { output.push({ name: decodeURIComponent(pair.name), value: decodeURIComponent(pair.value) }); }); return output; } function URLUtils(url) { if (nativeURL) return new origURL(url); var anchor = document.createElement('a'); anchor.href = url; return anchor; } function URLSearchParams(init) { var $this = this; this._list = []; if (init === undefined || init === null) { // no-op } else if (init instanceof URLSearchParams) { // In ES6 init would be a sequence, but special case for ES5. this._list = urlencoded_parse(String(init)); } else if (typeof init === 'object' && isSequence(init)) { toArray(init).forEach(function(e) { if (!isSequence(e)) throw TypeError(); var nv = toArray(e); if (nv.length !== 2) throw TypeError(); $this._list.push({name: String(nv[0]), value: String(nv[1])}); }); } else if (typeof init === 'object' && init) { Object.keys(init).forEach(function(key) { $this._list.push({name: String(key), value: String(init[key])}); }); } else { init = String(init); if (init.substring(0, 1) === '?') init = init.substring(1); this._list = urlencoded_parse(init); } this._url_object = null; this._setList = function (list) { if (!updating) $this._list = list; }; var updating = false; this._update_steps = function() { if (updating) return; updating = true; if (!$this._url_object) return; // Partial workaround for IE issue with 'about:' if ($this._url_object.protocol === 'about:' && $this._url_object.pathname.indexOf('?') !== -1) { $this._url_object.pathname = $this._url_object.pathname.split('?')[0]; } $this._url_object.search = urlencoded_serialize($this._list); updating = false; }; } Object.defineProperties(URLSearchParams.prototype, { append: { value: function (name, value) { this._list.push({ name: name, value: value }); this._update_steps(); }, writable: true, enumerable: true, configurable: true }, 'delete': { value: function (name) { for (var i = 0; i < this._list.length;) { if (this._list[i].name === name) this._list.splice(i, 1); else ++i; } this._update_steps(); }, writable: true, enumerable: true, configurable: true }, get: { value: function (name) { for (var i = 0; i < this._list.length; ++i) { if (this._list[i].name === name) return this._list[i].value; } return null; }, writable: true, enumerable: true, configurable: true }, getAll: { value: function (name) { var result = []; for (var i = 0; i < this._list.length; ++i) { if (this._list[i].name === name) result.push(this._list[i].value); } return result; }, writable: true, enumerable: true, configurable: true }, has: { value: function (name) { for (var i = 0; i < this._list.length; ++i) { if (this._list[i].name === name) return true; } return false; }, writable: true, enumerable: true, configurable: true }, set: { value: function (name, value) { var found = false; for (var i = 0; i < this._list.length;) { if (this._list[i].name === name) { if (!found) { this._list[i].value = value; found = true; ++i; } else { this._list.splice(i, 1); } } else { ++i; } } if (!found) this._list.push({ name: name, value: value }); this._update_steps(); }, writable: true, enumerable: true, configurable: true }, entries: { value: function() { return new Iterator(this._list, 'key+value'); }, writable: true, enumerable: true, configurable: true }, keys: { value: function() { return new Iterator(this._list, 'key'); }, writable: true, enumerable: true, configurable: true }, values: { value: function() { return new Iterator(this._list, 'value'); }, writable: true, enumerable: true, configurable: true }, forEach: { value: function(callback) { var thisArg = (arguments.length > 1) ? arguments[1] : undefined; this._list.forEach(function(pair, index) { callback.call(thisArg, pair.value, pair.name); }); }, writable: true, enumerable: true, configurable: true }, toString: { value: function () { return urlencoded_serialize(this._list); }, writable: true, enumerable: false, configurable: true } }); function Iterator(source, kind) { var index = 0; this['next'] = function() { if (index >= source.length) return {done: true, value: undefined}; var pair = source[index++]; return {done: false, value: kind === 'key' ? pair.name : kind === 'value' ? pair.value : [pair.name, pair.value]}; }; } if ('Symbol' in global && 'iterator' in global.Symbol) { Object.defineProperty(URLSearchParams.prototype, global.Symbol.iterator, { value: URLSearchParams.prototype.entries, writable: true, enumerable: true, configurable: true}); Object.defineProperty(Iterator.prototype, global.Symbol.iterator, { value: function() { return this; }, writable: true, enumerable: true, configurable: true}); } function URL(url, base) { if (!(this instanceof global.URL)) throw new TypeError("Failed to construct 'URL': Please use the 'new' operator."); if (base) { url = (function () { if (nativeURL) return new origURL(url, base).href; var iframe; try { var doc; // Use another document/base tag/anchor for relative URL resolution, if possible if (Object.prototype.toString.call(window.operamini) === "[object OperaMini]") { iframe = document.createElement('iframe'); iframe.style.display = 'none'; document.documentElement.appendChild(iframe); doc = iframe.contentWindow.document; } else if (document.implementation && document.implementation.createHTMLDocument) { doc = document.implementation.createHTMLDocument(''); } else if (document.implementation && document.implementation.createDocument) { doc = document.implementation.createDocument('http://www.w3.org/1999/xhtml', 'html', null); doc.documentElement.appendChild(doc.createElement('head')); doc.documentElement.appendChild(doc.createElement('body')); } else if (window.ActiveXObject) { doc = new window.ActiveXObject('htmlfile'); doc.write('
<\/head><\/body>'); doc.close(); } if (!doc) throw Error('base not supported'); var baseTag = doc.createElement('base'); baseTag.href = base; doc.getElementsByTagName('head')[0].appendChild(baseTag); var anchor = doc.createElement('a'); anchor.href = url; return anchor.href; } finally { if (iframe) iframe.parentNode.removeChild(iframe); } }()); } // An inner object implementing URLUtils (either a native URL // object or an HTMLAnchorElement instance) is used to perform the // URL algorithms. With full ES5 getter/setter support, return a // regular object For IE8's limited getter/setter support, a // different HTMLAnchorElement is returned with properties // overridden var instance = URLUtils(url || ''); // Detect for ES5 getter/setter support // (an Object.defineProperties polyfill that doesn't support getters/setters may throw) var ES5_GET_SET = (function() { if (!('defineProperties' in Object)) return false; try { var obj = {}; Object.defineProperties(obj, { prop: { 'get': function () { return true; } } }); return obj.prop; } catch (_) { return false; } })(); var self = ES5_GET_SET ? this : document.createElement('a'); var query_object = new URLSearchParams( instance.search ? instance.search.substring(1) : null); query_object._url_object = self; Object.defineProperties(self, { href: { get: function () { return instance.href; }, set: function (v) { instance.href = v; tidy_instance(); update_steps(); }, enumerable: true, configurable: true }, origin: { get: function () { if ('origin' in instance) return instance.origin; return this.protocol + '//' + this.host; }, enumerable: true, configurable: true }, protocol: { get: function () { return instance.protocol; }, set: function (v) { instance.protocol = v; }, enumerable: true, configurable: true }, username: { get: function () { return instance.username; }, set: function (v) { instance.username = v; }, enumerable: true, configurable: true }, password: { get: function () { return instance.password; }, set: function (v) { instance.password = v; }, enumerable: true, configurable: true }, host: { get: function () { // IE returns default port in |host| var re = {'http:': /:80$/, 'https:': /:443$/, 'ftp:': /:21$/}[instance.protocol]; return re ? instance.host.replace(re, '') : instance.host; }, set: function (v) { instance.host = v; }, enumerable: true, configurable: true }, hostname: { get: function () { return instance.hostname; }, set: function (v) { instance.hostname = v; }, enumerable: true, configurable: true }, port: { get: function () { return instance.port; }, set: function (v) { instance.port = v; }, enumerable: true, configurable: true }, pathname: { get: function () { // IE does not include leading '/' in |pathname| if (instance.pathname.charAt(0) !== '/') return '/' + instance.pathname; return instance.pathname; }, set: function (v) { instance.pathname = v; }, enumerable: true, configurable: true }, search: { get: function () { return instance.search; }, set: function (v) { if (instance.search === v) return; instance.search = v; tidy_instance(); update_steps(); }, enumerable: true, configurable: true }, searchParams: { get: function () { return query_object; }, enumerable: true, configurable: true }, hash: { get: function () { return instance.hash; }, set: function (v) { instance.hash = v; tidy_instance(); }, enumerable: true, configurable: true }, toString: { value: function() { return instance.toString(); }, enumerable: false, configurable: true }, valueOf: { value: function() { return instance.valueOf(); }, enumerable: false, configurable: true } }); function tidy_instance() { var href = instance.href.replace(/#$|\?$|\?(?=#)/g, ''); if (instance.href !== href) instance.href = href; } function update_steps() { query_object._setList(instance.search ? urlencoded_parse(instance.search.substring(1)) : []); query_object._update_steps(); }; return self; } if (origURL) { for (var i in origURL) { if (origURL.hasOwnProperty(i) && typeof origURL[i] === 'function') URL[i] = origURL[i]; } } global.URL = URL; global.URLSearchParams = URLSearchParams; }()); // Patch native URLSearchParams constructor to handle sequences/records // if necessary. (function() { if (new global.URLSearchParams([['a', 1]]).get('a') === '1' && new global.URLSearchParams({a: 1}).get('a') === '1') return; var orig = global.URLSearchParams; global.URLSearchParams = function(init) { if (init && typeof init === 'object' && isSequence(init)) { var o = new orig(); toArray(init).forEach(function(e) { if (!isSequence(e)) throw TypeError(); var nv = toArray(e); if (nv.length !== 2) throw TypeError(); o.append(nv[0], nv[1]); }); return o; } else if (init && typeof init === 'object') { o = new orig(); Object.keys(init).forEach(function(key) { o.set(key, init[key]); }); return o; } else { return new orig(init); } }; }()); }(self)); // Work-In-Progress 'prollyfill' for Fetch API // Standard: https://fetch.spec.whatwg.org/#fetch-api // // As usual, the intent is to produce a forward-compatible // subset so that code can be written using future standard // functionality; not every case is considered or supported. // Requires ES2015: Promise, Symbol.iterator (or polyfill) // Requires: URL (or polyfill) // Example: // fetch('README.md') // .then(function(response) { return response.text(); }) // .then(function(text) { alert(text); }); (function(global) { 'use strict'; // Web IDL concepts // https://heycam.github.io/webidl/#idl-ByteString function ByteString(value) { value = String(value); if (value.match(/[^\x00-\xFF]/)) throw TypeError('Not a valid ByteString'); return value; } // https://heycam.github.io/webidl/#idl-USVString function USVString(value) { value = String(value); return value.replace( /([\u0000-\uD7FF\uE000-\uFFFF]|[\uD800-\uDBFF][\uDC00-\uDFFF]|[\uD800-\uDFFF])/g, function (c) { if (/^[\uD800-\uDFFF]$/.test(c)) return '\uFFFD'; return c; }); } function ushort(x) { return x & 0xFFFF; } // 2 Terminology function byteLowerCase(s) { return String(s).replace(/[A-Z]/g, function(c) { return c.toLowerCase(); }); } function byteUpperCase(s) { return String(s).replace(/[a-z]/g, function(c) { return c.toUpperCase(); }); } function byteCaseInsensitiveMatch(a, b) { return byteLowerCase(a) === byteLowerCase(b); } // 2.1 HTTP // 2.1.1 Methods function isForbiddenMethod(m) { m = byteUpperCase(m); return m === 'CONNECT' || m === 'TRACE' || m === 'TRACK'; } function normalizeMethod(m) { var u = byteUpperCase(m); if (u === 'DELETE' || u === 'GET' || u === 'HEAD' || u === 'OPTIONS' || u === 'POST' || u === 'PUT') return u; return m; } function isName(s) { return /^[!#$%&'*+\-.0-9A-Z^_`a-z|~]+$/.test(s); } function isValue(s) { // TODO: Implement me return true; } function isForbiddenHeaderName(n) { n = String(n).toLowerCase(); var forbidden = { 'accept-charset': true, 'accept-encoding': true, 'access-control-request-headers': true, 'access-control-request-method': true, 'connection': true, 'content-length': true, 'cookie': true, 'cookie2': true, 'date': true, 'dnt': true, 'expect': true, 'host': true, 'keep-alive': true, 'origin': true, 'referer': true, 'te': true, 'trailer': true, 'transfer-encoding': true, 'upgrade': true, 'user-agent': true, 'via': true }; return forbidden[n] || n.substring(0, 6) === 'proxy-' || n.substring(0, 4) === 'sec-'; } function isForbiddenResponseHeaderName(n) { n = String(n).toLowerCase(); var forbidden = { 'set-cookie': true, 'set-cookie2': true }; return forbidden[n]; } function isSimpleHeader(name, value) { name = String(name).toLowerCase(); return name === 'accept' || name === 'accept-language' || name === 'content-language' || (name === 'content-type' && ['application/x-www-form-encoded', 'multipart/form-data', 'text/plain'].indexOf(value) !== -1); } // // 5.1 Headers class // // typedef (Headers or sequence