summaryrefslogtreecommitdiffstats
path: root/js/vendor/es6-shim/es6-shim.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/vendor/es6-shim/es6-shim.js')
-rw-r--r--js/vendor/es6-shim/es6-shim.js1928
1 files changed, 1928 insertions, 0 deletions
diff --git a/js/vendor/es6-shim/es6-shim.js b/js/vendor/es6-shim/es6-shim.js
new file mode 100644
index 000000000..5ac65e8c7
--- /dev/null
+++ b/js/vendor/es6-shim/es6-shim.js
@@ -0,0 +1,1928 @@
+// ES6-shim 0.18.0 (c) 2013-2014 Paul Miller (http://paulmillr.com)
+// ES6-shim may be freely distributed under the MIT license.
+// For more details and documentation:
+// https://github.com/paulmillr/es6-shim/
+
+(function(undefined) {
+ 'use strict';
+
+ var isCallableWithoutNew = function(func) {
+ try { func(); }
+ catch (e) { return false; }
+ return true;
+ };
+
+ var supportsSubclassing = function(C, f) {
+ /* jshint proto:true */
+ try {
+ var Sub = function() { C.apply(this, arguments); };
+ if (!Sub.__proto__) { return false; /* skip test on IE < 11 */ }
+ Object.setPrototypeOf(Sub, C);
+ Sub.prototype = Object.create(C.prototype, {
+ constructor: { value: C }
+ });
+ return f(Sub);
+ } catch (e) {
+ return false;
+ }
+ };
+
+ var arePropertyDescriptorsSupported = function() {
+ try {
+ Object.defineProperty({}, 'x', {});
+ return true;
+ } catch (e) { /* this is IE 8. */
+ return false;
+ }
+ };
+
+ var startsWithRejectsRegex = function() {
+ var rejectsRegex = false;
+ if (String.prototype.startsWith) {
+ try {
+ '/a/'.startsWith(/a/);
+ } catch (e) { /* this is spec compliant */
+ rejectsRegex = true;
+ }
+ }
+ return rejectsRegex;
+ };
+
+ /*jshint evil: true */
+ var getGlobal = new Function('return this;');
+ /*jshint evil: false */
+
+ var main = function() {
+ var globals = getGlobal();
+ var global_isFinite = globals.isFinite;
+ var supportsDescriptors = !!Object.defineProperty && arePropertyDescriptorsSupported();
+ var startsWithIsCompliant = startsWithRejectsRegex();
+ var _slice = Array.prototype.slice;
+ var _indexOf = String.prototype.indexOf;
+ var _toString = Object.prototype.toString;
+ var _hasOwnProperty = Object.prototype.hasOwnProperty;
+ var ArrayIterator; // make our implementation private
+
+ var defineProperty = function(object, name, value, force) {
+ if (!force && name in object) return;
+ if (supportsDescriptors) {
+ Object.defineProperty(object, name, {
+ configurable: true,
+ enumerable: false,
+ writable: true,
+ value: value
+ });
+ } else {
+ object[name] = value;
+ }
+ };
+
+ // Define configurable, writable and non-enumerable props
+ // if they don’t exist.
+ var defineProperties = function(object, map) {
+ Object.keys(map).forEach(function(name) {
+ var method = map[name];
+ defineProperty(object, name, method, false);
+ });
+ };
+
+ // Simple shim for Object.create on ES3 browsers
+ // (unlike real shim, no attempt to support `prototype === null`)
+ var create = Object.create || function(prototype, properties) {
+ function Type() {}
+ Type.prototype = prototype;
+ var object = new Type();
+ if (typeof properties !== "undefined") {
+ defineProperties(object, properties);
+ }
+ return object;
+ };
+
+ // This is a private name in the es6 spec, equal to '[Symbol.iterator]'
+ // we're going to use an arbitrary _-prefixed name to make our shims
+ // work properly with each other, even though we don't have full Iterator
+ // support. That is, `Array.from(map.keys())` will work, but we don't
+ // pretend to export a "real" Iterator interface.
+ var $iterator$ = (typeof Symbol === 'function' && Symbol.iterator) ||
+ '_es6shim_iterator_';
+ // Firefox ships a partial implementation using the name @@iterator.
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=907077#c14
+ // So use that name if we detect it.
+ if (globals.Set && typeof new globals.Set()['@@iterator'] === 'function') {
+ $iterator$ = '@@iterator';
+ }
+ var addIterator = function(prototype, impl) {
+ if (!impl) { impl = function iterator() { return this; }; }
+ var o = {};
+ o[$iterator$] = impl;
+ defineProperties(prototype, o);
+ /* jshint notypeof: true */
+ if (!prototype[$iterator$] && typeof $iterator$ === 'symbol') {
+ // implementations are buggy when $iterator$ is a Symbol
+ prototype[$iterator$] = impl;
+ }
+ };
+
+ // taken directly from https://github.com/ljharb/is-arguments/blob/master/index.js
+ // can be replaced with require('is-arguments') if we ever use a build process instead
+ var isArguments = function isArguments(value) {
+ var str = _toString.call(value);
+ var result = str === '[object Arguments]';
+ if (!result) {
+ result = str !== '[object Array]' &&
+ value !== null &&
+ typeof value === 'object' &&
+ typeof value.length === 'number' &&
+ value.length >= 0 &&
+ _toString.call(value.callee) === '[object Function]';
+ }
+ return result;
+ };
+
+ var emulateES6construct = function(o) {
+ if (!ES.TypeIsObject(o)) throw new TypeError('bad object');
+ // es5 approximation to es6 subclass semantics: in es6, 'new Foo'
+ // would invoke Foo.@@create to allocation/initialize the new object.
+ // In es5 we just get the plain object. So if we detect an
+ // uninitialized object, invoke o.constructor.@@create
+ if (!o._es6construct) {
+ if (o.constructor && ES.IsCallable(o.constructor['@@create'])) {
+ o = o.constructor['@@create'](o);
+ }
+ defineProperties(o, { _es6construct: true });
+ }
+ return o;
+ };
+
+ var ES = {
+ CheckObjectCoercible: function(x, optMessage) {
+ /* jshint eqnull:true */
+ if (x == null)
+ throw new TypeError(optMessage || ('Cannot call method on ' + x));
+ return x;
+ },
+
+ TypeIsObject: function(x) {
+ /* jshint eqnull:true */
+ // this is expensive when it returns false; use this function
+ // when you expect it to return true in the common case.
+ return x != null && Object(x) === x;
+ },
+
+ ToObject: function(o, optMessage) {
+ return Object(ES.CheckObjectCoercible(o, optMessage));
+ },
+
+ IsCallable: function(x) {
+ return typeof x === 'function' &&
+ // some versions of IE say that typeof /abc/ === 'function'
+ _toString.call(x) === '[object Function]';
+ },
+
+ ToInt32: function(x) {
+ return x >> 0;
+ },
+
+ ToUint32: function(x) {
+ return x >>> 0;
+ },
+
+ ToInteger: function(value) {
+ var number = +value;
+ if (Number.isNaN(number)) return 0;
+ if (number === 0 || !Number.isFinite(number)) return number;
+ return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
+ },
+
+ ToLength: function(value) {
+ var len = ES.ToInteger(value);
+ if (len <= 0) return 0; // includes converting -0 to +0
+ if (len > Number.MAX_SAFE_INTEGER) return Number.MAX_SAFE_INTEGER;
+ return len;
+ },
+
+ SameValue: function(a, b) {
+ if (a === b) {
+ // 0 === -0, but they are not identical.
+ if (a === 0) return 1 / a === 1 / b;
+ return true;
+ }
+ return Number.isNaN(a) && Number.isNaN(b);
+ },
+
+ SameValueZero: function(a, b) {
+ // same as SameValue except for SameValueZero(+0, -0) == true
+ return (a === b) || (Number.isNaN(a) && Number.isNaN(b));
+ },
+
+ IsIterable: function(o) {
+ return ES.TypeIsObject(o) &&
+ (o[$iterator$] !== undefined || isArguments(o));
+ },
+
+ GetIterator: function(o) {
+ if (isArguments(o)) {
+ // special case support for `arguments`
+ return new ArrayIterator(o, "value");
+ }
+ var it = o[$iterator$]();
+ if (!ES.TypeIsObject(it)) {
+ throw new TypeError('bad iterator');
+ }
+ return it;
+ },
+
+ IteratorNext: function (it) {
+ var result = arguments.length > 1 ? it.next(arguments[1]) : it.next();
+ if (!ES.TypeIsObject(result)) {
+ throw new TypeError('bad iterator');
+ }
+ return result;
+ },
+
+ Construct: function(C, args) {
+ // CreateFromConstructor
+ var obj;
+ if (ES.IsCallable(C['@@create'])) {
+ obj = C['@@create']();
+ } else {
+ // OrdinaryCreateFromConstructor
+ obj = create(C.prototype || null);
+ }
+ // Mark that we've used the es6 construct path
+ // (see emulateES6construct)
+ defineProperties(obj, { _es6construct: true });
+ // Call the constructor.
+ var result = C.apply(obj, args);
+ return ES.TypeIsObject(result) ? result : obj;
+ }
+ };
+
+ var numberConversion = (function () {
+ // from https://github.com/inexorabletash/polyfill/blob/master/typedarray.js#L176-L266
+ // with permission and license, per https://twitter.com/inexorabletash/status/372206509540659200
+
+ function roundToEven(n) {
+ var w = Math.floor(n), f = n - w;
+ if (f < 0.5) {
+ return w;
+ }
+ if (f > 0.5) {
+ return w + 1;
+ }
+ return w % 2 ? w + 1 : w;
+ }
+
+ function packIEEE754(v, ebits, fbits) {
+ var bias = (1 << (ebits - 1)) - 1,
+ s, e, f, ln,
+ i, bits, str, bytes;
+
+ // Compute sign, exponent, fraction
+ if (v !== v) {
+ // NaN
+ // http://dev.w3.org/2006/webapi/WebIDL/#es-type-mapping
+ e = (1 << ebits) - 1;
+ f = Math.pow(2, fbits - 1);
+ s = 0;
+ } else if (v === Infinity || v === -Infinity) {
+ e = (1 << ebits) - 1;
+ f = 0;
+ s = (v < 0) ? 1 : 0;
+ } else if (v === 0) {
+ e = 0;
+ f = 0;
+ s = (1 / v === -Infinity) ? 1 : 0;
+ } else {
+ s = v < 0;
+ v = Math.abs(v);
+
+ if (v >= Math.pow(2, 1 - bias)) {
+ e = Math.min(Math.floor(Math.log(v) / Math.LN2), 1023);
+ f = roundToEven(v / Math.pow(2, e) * Math.pow(2, fbits));
+ if (f / Math.pow(2, fbits) >= 2) {
+ e = e + 1;
+ f = 1;
+ }
+ if (e > bias) {
+ // Overflow
+ e = (1 << ebits) - 1;
+ f = 0;
+ } else {
+ // Normal
+ e = e + bias;
+ f = f - Math.pow(2, fbits);
+ }
+ } else {
+ // Subnormal
+ e = 0;
+ f = roundToEven(v / Math.pow(2, 1 - bias - fbits));
+ }
+ }
+
+ // Pack sign, exponent, fraction
+ bits = [];
+ for (i = fbits; i; i -= 1) {
+ bits.push(f % 2 ? 1 : 0);
+ f = Math.floor(f / 2);
+ }
+ for (i = ebits; i; i -= 1) {
+ bits.push(e % 2 ? 1 : 0);
+ e = Math.floor(e / 2);
+ }
+ bits.push(s ? 1 : 0);
+ bits.reverse();
+ str = bits.join('');
+
+ // Bits to bytes
+ bytes = [];
+ while (str.length) {
+ bytes.push(parseInt(str.slice(0, 8), 2));
+ str = str.slice(8);
+ }
+ return bytes;
+ }
+
+ function unpackIEEE754(bytes, ebits, fbits) {
+ // Bytes to bits
+ var bits = [], i, j, b, str,
+ bias, s, e, f;
+
+ for (i = bytes.length; i; i -= 1) {
+ b = bytes[i - 1];
+ for (j = 8; j; j -= 1) {
+ bits.push(b % 2 ? 1 : 0);
+ b = b >> 1;
+ }
+ }
+ bits.reverse();
+ str = bits.join('');
+
+ // Unpack sign, exponent, fraction
+ bias = (1 << (ebits - 1)) - 1;
+ s = parseInt(str.slice(0, 1), 2) ? -1 : 1;
+ e = parseInt(str.slice(1, 1 + ebits), 2);
+ f = parseInt(str.slice(1 + ebits), 2);
+
+ // Produce number
+ if (e === (1 << ebits) - 1) {
+ return f !== 0 ? NaN : s * Infinity;
+ } else if (e > 0) {
+ // Normalized
+ return s * Math.pow(2, e - bias) * (1 + f / Math.pow(2, fbits));
+ } else if (f !== 0) {
+ // Denormalized
+ return s * Math.pow(2, -(bias - 1)) * (f / Math.pow(2, fbits));
+ } else {
+ return s < 0 ? -0 : 0;
+ }
+ }
+
+ function unpackFloat64(b) { return unpackIEEE754(b, 11, 52); }
+ function packFloat64(v) { return packIEEE754(v, 11, 52); }
+ function unpackFloat32(b) { return unpackIEEE754(b, 8, 23); }
+ function packFloat32(v) { return packIEEE754(v, 8, 23); }
+
+ var conversions = {
+ toFloat32: function (num) { return unpackFloat32(packFloat32(num)); }
+ };
+ if (typeof Float32Array !== 'undefined') {
+ var float32array = new Float32Array(1);
+ conversions.toFloat32 = function (num) {
+ float32array[0] = num;
+ return float32array[0];
+ };
+ }
+ return conversions;
+ }());
+
+ defineProperties(String, {
+ fromCodePoint: function(_) { // length = 1
+ var points = _slice.call(arguments, 0, arguments.length);
+ var result = [];
+ var next;
+ for (var i = 0, length = points.length; i < length; i++) {
+ next = Number(points[i]);
+ if (!ES.SameValue(next, ES.ToInteger(next)) ||
+ next < 0 || next > 0x10FFFF) {
+ throw new RangeError('Invalid code point ' + next);
+ }
+
+ if (next < 0x10000) {
+ result.push(String.fromCharCode(next));
+ } else {
+ next -= 0x10000;
+ result.push(String.fromCharCode((next >> 10) + 0xD800));
+ result.push(String.fromCharCode((next % 0x400) + 0xDC00));
+ }
+ }
+ return result.join('');
+ },
+
+ raw: function(callSite) { // raw.length===1
+ var substitutions = _slice.call(arguments, 1, arguments.length);
+ var cooked = ES.ToObject(callSite, 'bad callSite');
+ var rawValue = cooked.raw;
+ var raw = ES.ToObject(rawValue, 'bad raw value');
+ var len = Object.keys(raw).length;
+ var literalsegments = ES.ToLength(len);
+ if (literalsegments === 0) {
+ return '';
+ }
+
+ var stringElements = [];
+ var nextIndex = 0;
+ var nextKey, next, nextSeg, nextSub;
+ while (nextIndex < literalsegments) {
+ nextKey = String(nextIndex);
+ next = raw[nextKey];
+ nextSeg = String(next);
+ stringElements.push(nextSeg);
+ if (nextIndex + 1 >= literalsegments) {
+ break;
+ }
+ next = substitutions[nextKey];
+ if (next === undefined) {
+ break;
+ }
+ nextSub = String(next);
+ stringElements.push(nextSub);
+ nextIndex++;
+ }
+ return stringElements.join('');
+ }
+ });
+
+ // Firefox 31 reports this function's length as 0
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=1062484
+ if (String.fromCodePoint.length !== 1) {
+ var originalFromCodePoint = String.fromCodePoint;
+ defineProperty(String, 'fromCodePoint', function (_) { return originalFromCodePoint.apply(this, arguments); }, true);
+ }
+
+ var StringShims = {
+ // Fast repeat, uses the `Exponentiation by squaring` algorithm.
+ // Perf: http://jsperf.com/string-repeat2/2
+ repeat: (function() {
+ var repeat = function(s, times) {
+ if (times < 1) return '';
+ if (times % 2) return repeat(s, times - 1) + s;
+ var half = repeat(s, times / 2);
+ return half + half;
+ };
+
+ return function(times) {
+ var thisStr = String(ES.CheckObjectCoercible(this));
+ times = ES.ToInteger(times);
+ if (times < 0 || times === Infinity) {
+ throw new RangeError('Invalid String#repeat value');
+ }
+ return repeat(thisStr, times);
+ };
+ })(),
+
+ startsWith: function(searchStr) {
+ var thisStr = String(ES.CheckObjectCoercible(this));
+ if (_toString.call(searchStr) === '[object RegExp]') throw new TypeError('Cannot call method "startsWith" with a regex');
+ searchStr = String(searchStr);
+ var startArg = arguments.length > 1 ? arguments[1] : undefined;
+ var start = Math.max(ES.ToInteger(startArg), 0);
+ return thisStr.slice(start, start + searchStr.length) === searchStr;
+ },
+
+ endsWith: function(searchStr) {
+ var thisStr = String(ES.CheckObjectCoercible(this));
+ if (_toString.call(searchStr) === '[object RegExp]') throw new TypeError('Cannot call method "endsWith" with a regex');
+ searchStr = String(searchStr);
+ var thisLen = thisStr.length;
+ var posArg = arguments.length > 1 ? arguments[1] : undefined;
+ var pos = posArg === undefined ? thisLen : ES.ToInteger(posArg);
+ var end = Math.min(Math.max(pos, 0), thisLen);
+ return thisStr.slice(end - searchStr.length, end) === searchStr;
+ },
+
+ contains: function(searchString) {
+ var position = arguments.length > 1 ? arguments[1] : undefined;
+ // Somehow this trick makes method 100% compat with the spec.
+ return _indexOf.call(this, searchString, position) !== -1;
+ },
+
+ codePointAt: function(pos) {
+ var thisStr = String(ES.CheckObjectCoercible(this));
+ var position = ES.ToInteger(pos);
+ var length = thisStr.length;
+ if (position < 0 || position >= length) return undefined;
+ var first = thisStr.charCodeAt(position);
+ var isEnd = (position + 1 === length);
+ if (first < 0xD800 || first > 0xDBFF || isEnd) return first;
+ var second = thisStr.charCodeAt(position + 1);
+ if (second < 0xDC00 || second > 0xDFFF) return first;
+ return ((first - 0xD800) * 1024) + (second - 0xDC00) + 0x10000;
+ }
+ };
+ defineProperties(String.prototype, StringShims);
+
+ var hasStringTrimBug = '\u0085'.trim().length !== 1;
+ if (hasStringTrimBug) {
+ var originalStringTrim = String.prototype.trim;
+ delete String.prototype.trim;
+ // whitespace from: http://es5.github.io/#x15.5.4.20
+ // implementation from https://github.com/es-shims/es5-shim/blob/v3.4.0/es5-shim.js#L1304-L1324
+ var ws = [
+ '\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003',
+ '\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028',
+ '\u2029\uFEFF'
+ ].join('');
+ var trimRegexp = new RegExp('(^[' + ws + ']+)|([' + ws + ']+$)', 'g');
+ defineProperties(String.prototype, {
+ trim: function() {
+ if (this === undefined || this === null) {
+ throw new TypeError("can't convert " + this + " to object");
+ }
+ return String(this).replace(trimRegexp, "");
+ }
+ });
+ }
+
+ // see https://people.mozilla.org/~jorendorff/es6-draft.html#sec-string.prototype-@@iterator
+ var StringIterator = function(s) {
+ this._s = String(ES.CheckObjectCoercible(s));
+ this._i = 0;
+ };
+ StringIterator.prototype.next = function() {
+ var s = this._s, i = this._i;
+ if (s === undefined || i >= s.length) {
+ this._s = undefined;
+ return { value: undefined, done: true };
+ }
+ var first = s.charCodeAt(i), second, len;
+ if (first < 0xD800 || first > 0xDBFF || (i+1) == s.length) {
+ len = 1;
+ } else {
+ second = s.charCodeAt(i+1);
+ len = (second < 0xDC00 || second > 0xDFFF) ? 1 : 2;
+ }
+ this._i = i + len;
+ return { value: s.substr(i, len), done: false };
+ };
+ addIterator(StringIterator.prototype);
+ addIterator(String.prototype, function() {
+ return new StringIterator(this);
+ });
+
+ if (!startsWithIsCompliant) {
+ // Firefox has a noncompliant startsWith implementation
+ String.prototype.startsWith = StringShims.startsWith;
+ String.prototype.endsWith = StringShims.endsWith;
+ }
+
+ var ArrayShims = {
+ from: function(iterable) {
+ var mapFn = arguments.length > 1 ? arguments[1] : undefined;
+
+ var list = ES.ToObject(iterable, 'bad iterable');
+ if (mapFn !== undefined && !ES.IsCallable(mapFn)) {
+ throw new TypeError('Array.from: when provided, the second argument must be a function');
+ }
+
+ var hasThisArg = arguments.length > 2;
+ var thisArg = hasThisArg ? arguments[2] : undefined;
+
+ var usingIterator = ES.IsIterable(list);
+ // does the spec really mean that Arrays should use ArrayIterator?
+ // https://bugs.ecmascript.org/show_bug.cgi?id=2416
+ //if (Array.isArray(list)) { usingIterator=false; }
+
+ var length;
+ var result, i, value;
+ if (usingIterator) {
+ i = 0;
+ result = ES.IsCallable(this) ? Object(new this()) : [];
+ var it = usingIterator ? ES.GetIterator(list) : null;
+ var iterationValue;
+
+ do {
+ iterationValue = ES.IteratorNext(it);
+ if (!iterationValue.done) {
+ value = iterationValue.value;
+ if (mapFn) {
+ result[i] = hasThisArg ? mapFn.call(thisArg, value, i) : mapFn(value, i);
+ } else {
+ result[i] = value;
+ }
+ i += 1;
+ }
+ } while (!iterationValue.done);
+ length = i;
+ } else {
+ length = ES.ToLength(list.length);
+ result = ES.IsCallable(this) ? Object(new this(length)) : new Array(length);
+ for (i = 0; i < length; ++i) {
+ value = list[i];
+ if (mapFn) {
+ result[i] = hasThisArg ? mapFn.call(thisArg, value, i) : mapFn(value, i);
+ } else {
+ result[i] = value;
+ }
+ }
+ }
+
+ result.length = length;
+ return result;
+ },
+
+ of: function() {
+ return Array.from(arguments);
+ }
+ };
+ defineProperties(Array, ArrayShims);
+
+ var arrayFromSwallowsNegativeLengths = function () {
+ try {
+ return Array.from({ length: -1 }).length === 0;
+ } catch (e) {
+ return false;
+ }
+ };
+ // Fixes a Firefox bug in v32
+ // https://bugzilla.mozilla.org/show_bug.cgi?id=1063993
+ if (!arrayFromSwallowsNegativeLengths()) {
+ defineProperty(Array, 'from', ArrayShims.from, true);
+ }
+
+ // Our ArrayIterator is private; see
+ // https://github.com/paulmillr/es6-shim/issues/252
+ ArrayIterator = function(array, kind) {
+ this.i = 0;
+ this.array = array;
+ this.kind = kind;
+ };
+
+ defineProperties(ArrayIterator.prototype, {
+ next: function() {
+ var i = this.i, array = this.array;
+ if (!(this instanceof ArrayIterator)) {
+ throw new TypeError('Not an ArrayIterator');
+ }
+ if (array !== undefined) {
+ var len = ES.ToLength(array.length);
+ for (; i < len; i++) {
+ var kind = this.kind;
+ var retval;
+ if (kind === "key") {
+ retval = i;
+ } else if (kind === "value") {
+ retval = array[i];
+ } else if (kind === "entry") {
+ retval = [i, array[i]];
+ }
+ this.i = i + 1;
+ return { value: retval, done: false };
+ }
+ }
+ this.array = undefined;
+ return { value: undefined, done: true };
+ }
+ });
+ addIterator(ArrayIterator.prototype);
+
+ var ArrayPrototypeShims = {
+ copyWithin: function(target, start) {
+ var end = arguments[2]; // copyWithin.length must be 2
+ var o = ES.ToObject(this);
+ var len = ES.ToLength(o.length);
+ target = ES.ToInteger(target);
+ start = ES.ToInteger(start);
+ var to = target < 0 ? Math.max(len + target, 0) : Math.min(target, len);
+ var from = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
+ end = (end===undefined) ? len : ES.ToInteger(end);
+ var fin = end < 0 ? Math.max(len + end, 0) : Math.min(end, len);
+ var count = Math.min(fin - from, len - to);
+ var direction = 1;
+ if (from < to && to < (from + count)) {
+ direction = -1;
+ from += count - 1;
+ to += count - 1;
+ }
+ while (count > 0) {
+ if (_hasOwnProperty.call(o, from)) {
+ o[to] = o[from];
+ } else {
+ delete o[from];
+ }
+ from += direction;
+ to += direction;
+ count -= 1;
+ }
+ return o;
+ },
+
+ fill: function(value) {
+ var start = arguments.length > 1 ? arguments[1] : undefined;
+ var end = arguments.length > 2 ? arguments[2] : undefined;
+ var O = ES.ToObject(this);
+ var len = ES.ToLength(O.length);
+ start = ES.ToInteger(start === undefined ? 0 : start);
+ end = ES.ToInteger(end === undefined ? len : end);
+
+ var relativeStart = start < 0 ? Math.max(len + start, 0) : Math.min(start, len);
+ var relativeEnd = end < 0 ? len + end : end;
+
+ for (var i = relativeStart; i < len && i < relativeEnd; ++i) {
+ O[i] = value;
+ }
+ return O;
+ },
+
+ find: function find(predicate) {
+ var list = ES.ToObject(this);
+ var length = ES.ToLength(list.length);
+ if (!ES.IsCallable(predicate)) {
+ throw new TypeError('Array#find: predicate must be a function');
+ }
+ var thisArg = arguments[1];
+ for (var i = 0, value; i < length; i++) {
+ value = list[i];
+ if (predicate.call(thisArg, value, i, list)) { return value; }
+ }
+ return undefined;
+ },
+
+ findIndex: function findIndex(predicate) {
+ var list = ES.ToObject(this);
+ var length = ES.ToLength(list.length);
+ if (!ES.IsCallable(predicate)) {
+ throw new TypeError('Array#findIndex: predicate must be a function');
+ }
+ var thisArg = arguments[1];
+ for (var i = 0; i < length; i++) {
+ if (predicate.call(thisArg, list[i], i, list)) { return i; }
+ }
+ return -1;
+ },
+
+ keys: function() {
+ return new ArrayIterator(this, "key");
+ },
+
+ values: function() {
+ return new ArrayIterator(this, "value");
+ },
+
+ entries: function() {
+ return new ArrayIterator(this, "entry");
+ }
+ };
+ defineProperties(Array.prototype, ArrayPrototypeShims);
+ addIterator(Array.prototype, function() { return this.values(); });
+ // Chrome defines keys/values/entries on Array, but doesn't give us
+ // any way to identify its iterator. So add our own shimmed field.
+ if (Object.getPrototypeOf) {
+ addIterator(Object.getPrototypeOf([].values()));
+ }
+
+ var maxSafeInteger = Math.pow(2, 53) - 1;
+ defineProperties(Number, {
+ MAX_SAFE_INTEGER: maxSafeInteger,
+ MIN_SAFE_INTEGER: -maxSafeInteger,
+ EPSILON: 2.220446049250313e-16,
+
+ parseInt: globals.parseInt,
+ parseFloat: globals.parseFloat,
+
+ isFinite: function(value) {
+ return typeof value === 'number' && global_isFinite(value);
+ },
+
+ isInteger: function(value) {
+ return Number.isFinite(value) &&
+ ES.ToInteger(value) === value;
+ },
+
+ isSafeInteger: function(value) {
+ return Number.isInteger(value) && Math.abs(value) <= Number.MAX_SAFE_INTEGER;
+ },
+
+ isNaN: function(value) {
+ // NaN !== NaN, but they are identical.
+ // NaNs are the only non-reflexive value, i.e., if x !== x,
+ // then x is NaN.
+ // isNaN is broken: it converts its argument to number, so
+ // isNaN('foo') => true
+ return value !== value;
+ }
+
+ });
+
+ // Work around bugs in Array#find and Array#findIndex -- early
+ // implementations skipped holes in sparse arrays. (Note that the
+ // implementations of find/findIndex indirectly use shimmed
+ // methods of Number, so this test has to happen down here.)
+ if (![, 1].find(function(item, idx) { return idx === 0; })) {
+ defineProperty(Array.prototype, 'find', ArrayPrototypeShims.find, true);
+ }
+ if ([, 1].findIndex(function(item, idx) { return idx === 0; }) !== 0) {
+ defineProperty(Array.prototype, 'findIndex', ArrayPrototypeShims.findIndex, true);
+ }
+
+ if (supportsDescriptors) {
+ defineProperties(Object, {
+ getPropertyDescriptor: function(subject, name) {
+ var pd = Object.getOwnPropertyDescriptor(subject, name);
+ var proto = Object.getPrototypeOf(subject);
+ while (pd === undefined && proto !== null) {
+ pd = Object.getOwnPropertyDescriptor(proto, name);
+ proto = Object.getPrototypeOf(proto);
+ }
+ return pd;
+ },
+
+ getPropertyNames: function(subject) {
+ var result = Object.getOwnPropertyNames(subject);
+ var proto = Object.getPrototypeOf(subject);
+
+ var addProperty = function(property) {
+ if (result.indexOf(property) === -1) {
+ result.push(property);
+ }
+ };
+
+ while (proto !== null) {
+ Object.getOwnPropertyNames(proto).forEach(addProperty);
+ proto = Object.getPrototypeOf(proto);
+ }
+ return result;
+ }
+ });
+
+ defineProperties(Object, {
+ // 19.1.3.1
+ assign: function(target, source) {
+ if (!ES.TypeIsObject(target)) {
+ throw new TypeError('target must be an object');
+ }
+ return Array.prototype.reduce.call(arguments, function(target, source) {
+ return Object.keys(Object(source)).reduce(function(target, key) {
+ target[key] = source[key];
+ return target;
+ }, target);
+ });
+ },
+
+ is: function(a, b) {
+ return ES.SameValue(a, b);
+ },
+
+ // 19.1.3.9
+ // shim from https://gist.github.com/WebReflection/5593554
+ setPrototypeOf: (function(Object, magic) {
+ var set;
+
+ var checkArgs = function(O, proto) {
+ if (!ES.TypeIsObject(O)) {
+ throw new TypeError('cannot set prototype on a non-object');
+ }
+ if (!(proto===null || ES.TypeIsObject(proto))) {
+ throw new TypeError('can only set prototype to an object or null'+proto);
+ }
+ };
+
+ var setPrototypeOf = function(O, proto) {
+ checkArgs(O, proto);
+ set.call(O, proto);
+ return O;
+ };
+
+ try {
+ // this works already in Firefox and Safari
+ set = Object.getOwnPropertyDescriptor(Object.prototype, magic).set;
+ set.call({}, null);
+ } catch (e) {
+ if (Object.prototype !== {}[magic]) {
+ // IE < 11 cannot be shimmed
+ return;
+ }
+ // probably Chrome or some old Mobile stock browser
+ set = function(proto) {
+ this[magic] = proto;
+ };
+ // please note that this will **not** work
+ // in those browsers that do not inherit
+ // __proto__ by mistake from Object.prototype
+ // in these cases we should probably throw an error
+ // or at least be informed about the issue
+ setPrototypeOf.polyfill = setPrototypeOf(
+ setPrototypeOf({}, null),
+ Object.prototype
+ ) instanceof Object;
+ // setPrototypeOf.polyfill === true means it works as meant
+ // setPrototypeOf.polyfill === false means it's not 100% reliable
+ // setPrototypeOf.polyfill === undefined
+ // or
+ // setPrototypeOf.polyfill == null means it's not a polyfill
+ // which means it works as expected
+ // we can even delete Object.prototype.__proto__;
+ }
+ return setPrototypeOf;
+ })(Object, '__proto__')
+ });
+ }
+
+ // Workaround bug in Opera 12 where setPrototypeOf(x, null) doesn't work,
+ // but Object.create(null) does.
+ if (Object.setPrototypeOf && Object.getPrototypeOf &&
+ Object.getPrototypeOf(Object.setPrototypeOf({}, null)) !== null &&
+ Object.getPrototypeOf(Object.create(null)) === null) {
+ (function() {
+ var FAKENULL = Object.create(null);
+ var gpo = Object.getPrototypeOf, spo = Object.setPrototypeOf;
+ Object.getPrototypeOf = function(o) {
+ var result = gpo(o);
+ return result === FAKENULL ? null : result;
+ };
+ Object.setPrototypeOf = function(o, p) {
+ if (p === null) { p = FAKENULL; }
+ return spo(o, p);
+ };
+ Object.setPrototypeOf.polyfill = false;
+ })();
+ }
+
+ try {
+ Object.keys('foo');
+ } catch (e) {
+ var originalObjectKeys = Object.keys;
+ Object.keys = function (obj) {
+ return originalObjectKeys(ES.ToObject(obj));
+ };
+ }
+
+ var MathShims = {
+ acosh: function(value) {
+ value = Number(value);
+ if (Number.isNaN(value) || value < 1) return NaN;
+ if (value === 1) return 0;
+ if (value === Infinity) return value;
+ return Math.log(value + Math.sqrt(value * value - 1));
+ },
+
+ asinh: function(value) {
+ value = Number(value);
+ if (value === 0 || !global_isFinite(value)) {
+ return value;
+ }