https://santaclausgolfclub.fi/site/modules/PrivacyWire/js/ie_polyfill.js

1if (!Array.from) {
2    Array.from = (function () {
3        var symbolIterator;
4        try {
5            symbolIterator = Symbol.iterator
6                ? Symbol.iterator
7                : 'Symbol(Symbol.iterator)';
8        } catch (e) {
9            symbolIterator = 'Symbol(Symbol.iterator)';
10        }
11
12        var toStr = Object.prototype.toString;
13        var isCallable = function (fn) {
14            return (
15                typeof fn === 'function' ||
16                toStr.call(fn) === '[object Function]'
17            );
18        };
19        var toInteger = function (value) {
20            var number = Number(value);
21            if (isNaN(number)) return 0;
22            if (number === 0 || !isFinite(number)) return number;
23            return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
24        };
25        var maxSafeInteger = Math.pow(2, 53) - 1;
26        var toLength = function (value) {
27            var len = toInteger(value);
28            return Math.min(Math.max(len, 0), maxSafeInteger);
29        };
30
31        var setGetItemHandler = function setGetItemHandler(isIterator, items) {
32            var iterator = isIterator && items[symbolIterator]();
33            return function getItem(k) {
34                return isIterator ? iterator.next() : items[k];
35            };
36        };
37
38        var getArray = function getArray(
39            T,
40            A,
41            len,
42            getItem,
43            isIterator,
44            mapFn
45        ) {
46            // 16. Let k be 0.
47            var k = 0;
48
49            // 17. Repeat, while k < len… or while iterator is done (also steps a - h)
50            while (k < len || isIterator) {
51                var item = getItem(k);
52                var kValue = isIterator ? item.value : item;
53
54                if (isIterator && item.done) {
55                    return A;
56                } else {
57                    if (mapFn) {
58                        A[k] =
59                            typeof T === 'undefined'
60                                ? mapFn(kValue, k)
61                                : mapFn.call(T, kValue, k);
62                    } else {
63                        A[k] = kValue;
64                    }
65                }
66                k += 1;
67            }
68
69            if (isIterator) {
70                throw new TypeError(
71                    'Array.from: provided arrayLike or iterator has length more then 2 ** 52 - 1'
72                );
73            } else {
74                A.length = len;
75            }
76
77            return A;
78        };
79
80        // The length property of the from method is 1.
81        return function from(arrayLikeOrIterator /*, mapFn, thisArg */) {
82            // 1. Let C be the this value.
83            var C = this;
84
85            // 2. Let items be ToObject(arrayLikeOrIterator).
86            var items = Object(arrayLikeOrIterator);
87            var isIterator = isCallable(items[symbolIterator]);
88
89            // 3. ReturnIfAbrupt(items).
90            if (arrayLikeOrIterator == null && !isIterator) {
91                throw new TypeError(
92                    'Array.from requires an array-like object or iterator - not null or undefined'
93                );
94            }
95
96            // 4. If mapfn is undefined, then let mapping be false.
97            var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
98            var T;
99            if (typeof mapFn !== 'undefined') {
100                // 5. else
101                // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
102                if (!isCallable(mapFn)) {
103                    throw new TypeError(
104                        'Array.from: when provided, the second argument must be a function'
105                    );
106                }
107
108                // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
109                if (arguments.length > 2) {
110                    T = arguments[2];
111                }
112            }
113
114            // 10. Let lenValue be Get(items, "length").
115            // 11. Let len be ToLength(lenValue).
116            var len = toLength(items.length);
117
118            // 13. If IsConstructor(C) is true, then
119            // 13. a. Let A be the result of calling the [[Construct]] internal method
120            // of C with an argument list containing the single item len.
121            // 14. a. Else, Let A be ArrayCreate(len).
122            var A = isCallable(C) ? Object(new C(len)) : new Array(len);
123
124            return getArray(
125                T,
126                A,
127                len,
128                setGetItemHandler(isIterator, items),
129                isIterator,
130                mapFn
131            );
132        };
133    })();
134}