From 3f136a7516eb16129fbffc0623455bc5a6d13702 Mon Sep 17 00:00:00 2001 From: Tony Jin Date: Thu, 1 Mar 2018 17:39:31 -0800 Subject: [PATCH] Fix: Polyfill Reflect.construct and Array.from for IE11 (#694) Extending Error to PreviewError requires `babel-plugin-transform-builtin-extend`, which requires Reflect.construct and Array.from. This patch polyfills Reflect.construct, deriving from the core-js polyfill, and Array.from, using the MDN-suggested polyfill. --- src/lib/polyfill.js | 167 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 167 insertions(+) diff --git a/src/lib/polyfill.js b/src/lib/polyfill.js index 970ea9235..979c837c8 100644 --- a/src/lib/polyfill.js +++ b/src/lib/polyfill.js @@ -217,4 +217,171 @@ Number.isNaN = function(value) { return value !== value; }; + +// Reflect.construct polyfill for IE11, adapted from +// https://github.com/zloirock/core-js/blob/master/modules/es6.reflect.construct.js +(function() { + function aFunction(it) { + if (typeof it != 'function') throw TypeError(it + ' is not a function!'); + return it; + } + function isObject(it) { + return typeof it === 'object' ? it !== null : typeof it === 'function'; + } + function anObject(it) { + if (!isObject(it)) throw TypeError(it + ' is not an object!'); + return it; + } + function fails(exec) { + try { + return !!exec(); + } catch (e) { + return true; + } + } + var rConstruct = (typeof Reflect !== 'undefined' ? Reflect : {}).construct; + + // MS Edge supports only 2 arguments and argumentsList argument is optional + // FF Nightly sets third argument as `new.target`, but does not create `this` from it + var NEW_TARGET_BUG = fails(function() { + function F() { + /* empty */ + } + return !( + rConstruct( + function() { + /* empty */ + }, + [], + F + ) instanceof F + ); + }); + var ARGS_BUG = !fails(function() { + rConstruct(function() { + /* empty */ + }); + }); + function construct(Target, args /* , newTarget */) { + aFunction(Target); + anObject(args); + var newTarget = arguments.length < 3 ? Target : aFunction(arguments[2]); + if (ARGS_BUG && !NEW_TARGET_BUG) return rConstruct(Target, args, newTarget); + if (Target == newTarget) { + // w/o altered newTarget, optimization for 0-4 arguments + switch (args.length) { + case 0: + return new Target(); + case 1: + return new Target(args[0]); + case 2: + return new Target(args[0], args[1]); + case 3: + return new Target(args[0], args[1], args[2]); + case 4: + return new Target(args[0], args[1], args[2], args[3]); + } + // w/o altered newTarget, lot of arguments case + var $args = [null]; + $args.push.apply($args, args); + return new (Function.bind.apply(Target, $args))(); + } + // with altered newTarget, not support built-in constructors + var proto = newTarget.prototype; + var instance = Object.create(isObject(proto) ? proto : Object.prototype); + var result = Function.apply.call(Target, instance, args); + return isObject(result) ? result : instance; + } + + if (typeof Reflect !== 'undefined') { + Reflect.construct = construct; + } else { + Reflect = { + construct + }; + } +})(); + +// Production steps of ECMA-262, Edition 6, 22.1.2.1 +if (!Array.from) { + Array.from = (function() { + var toStr = Object.prototype.toString; + var isCallable = function(fn) { + return typeof fn === 'function' || toStr.call(fn) === '[object Function]'; + }; + var toInteger = function(value) { + var number = Number(value); + if (isNaN(number)) { + return 0; + } + if (number === 0 || !isFinite(number)) { + return number; + } + return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number)); + }; + var maxSafeInteger = Math.pow(2, 53) - 1; + var toLength = function(value) { + var len = toInteger(value); + return Math.min(Math.max(len, 0), maxSafeInteger); + }; + + // The length property of the from method is 1. + return function from(arrayLike /*, mapFn, thisArg */) { + // 1. Let C be the this value. + var C = this; + + // 2. Let items be ToObject(arrayLike). + var items = Object(arrayLike); + + // 3. ReturnIfAbrupt(items). + if (arrayLike == null) { + throw new TypeError('Array.from requires an array-like object - not null or undefined'); + } + + // 4. If mapfn is undefined, then let mapping be false. + var mapFn = arguments.length > 1 ? arguments[1] : void undefined; + var T; + if (typeof mapFn !== 'undefined') { + // 5. else + // 5. a If IsCallable(mapfn) is false, throw a TypeError exception. + if (!isCallable(mapFn)) { + throw new TypeError('Array.from: when provided, the second argument must be a function'); + } + + // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined. + if (arguments.length > 2) { + T = arguments[2]; + } + } + + // 10. Let lenValue be Get(items, "length"). + // 11. Let len be ToLength(lenValue). + var len = toLength(items.length); + + // 13. If IsConstructor(C) is true, then + // 13. a. Let A be the result of calling the [[Construct]] internal method + // of C with an argument list containing the single item len. + // 14. a. Else, Let A be ArrayCreate(len). + var A = isCallable(C) ? Object(new C(len)) : new Array(len); + + // 16. Let k be 0. + var k = 0; + // 17. Repeat, while k < len… (also steps a - h) + var kValue; + while (k < len) { + kValue = items[k]; + if (mapFn) { + A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k); + } else { + A[k] = kValue; + } + k += 1; + } + // 18. Let putStatus be Put(A, "length", len, true). + A.length = len; + // 20. Return A. + return A; + }; + })(); +} /* eslint-enable */