libraries/stdlib/js-v1/src/js/polyfills.js

/*
 * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
 * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
 */

if (typeof String.prototype.startsWith === "undefined") {
    Object.defineProperty(String.prototype, "startsWith", {
        value: function (searchString, position) {
            position = position || 0;
            return this.lastIndexOf(searchString, position) === position;
        }
    });
}
if (typeof String.prototype.endsWith === "undefined") {
    Object.defineProperty(String.prototype, "endsWith", {
        value: function (searchString, position) {
            var subjectString = this.toString();
            if (position === undefined || position > subjectString.length) {
                position = subjectString.length;
            }
            position -= searchString.length;
            var lastIndex = subjectString.indexOf(searchString, position);
            return lastIndex !== -1 && lastIndex === position;
        }
    });
}
// ES6 Math polyfills
if (typeof Math.sign === "undefined") {
    Math.sign = function(x) {
        x = +x; // convert to a number
        if (x === 0 || isNaN(x)) {
            return Number(x);
        }
        return x > 0 ? 1 : -1;
    };
}
if (typeof Math.trunc === "undefined") {
    Math.trunc = function(x) {
        if (isNaN(x)) {
            return NaN;
        }
        if (x > 0) {
            return Math.floor(x);
        }
        return Math.ceil(x);
    };
}

(function() {
    var epsilon = 2.220446049250313E-16;
    var taylor_2_bound = Math.sqrt(epsilon);
    var taylor_n_bound = Math.sqrt(taylor_2_bound);
    var upper_taylor_2_bound = 1/taylor_2_bound;
    var upper_taylor_n_bound = 1/taylor_n_bound;

    if (typeof Math.sinh === "undefined") {
        Math.sinh = function(x) {
            if (Math.abs(x) < taylor_n_bound) {
                var result = x;
                if (Math.abs(x) > taylor_2_bound) {
                    result += (x * x * x) / 6;
                }
                return result;
            } else {
                var y = Math.exp(x);
                var y1 = 1 / y;
                if (!isFinite(y)) return Math.exp(x - Math.LN2);
                if (!isFinite(y1)) return -Math.exp(-x - Math.LN2);
                return (y - y1) / 2;
            }
        };
    }
    if (typeof Math.cosh === "undefined") {
        Math.cosh = function(x) {
            var y = Math.exp(x);
            var y1 = 1 / y;
            if (!isFinite(y) || !isFinite(y1)) return Math.exp(Math.abs(x) - Math.LN2);
            return (y + y1) / 2;
        };
    }

    if (typeof Math.tanh === "undefined") {
        Math.tanh = function(x){
            if (Math.abs(x) < taylor_n_bound) {
                var result = x;
                if (Math.abs(x) > taylor_2_bound) {
                    result -= (x * x * x) / 3;
                }
                return result;
            }
            else {
                var a = Math.exp(+x), b = Math.exp(-x);
                return a === Infinity ? 1 : b === Infinity ? -1 : (a - b) / (a + b);
            }
        };
    }

    // Inverse hyperbolic function implementations derived from boost special math functions,
    // Copyright Eric Ford & Hubert Holin 2001.

    if (typeof Math.asinh === "undefined") {
        var asinh = function(x) {
            if (x >= +taylor_n_bound)
            {
                if (x > upper_taylor_n_bound)
                {
                    if (x > upper_taylor_2_bound)
                    {
                        // approximation by laurent series in 1/x at 0+ order from -1 to 0
                        return Math.log(x) + Math.LN2;
                    }
                    else
                    {
                        // approximation by laurent series in 1/x at 0+ order from -1 to 1
                        return Math.log(x * 2 + (1 / (x * 2)));
                    }
                }
                else
                {
                    return Math.log(x + Math.sqrt(x * x + 1));
                }
            }
            else if (x <= -taylor_n_bound)
            {
                return -asinh(-x);
            }
            else
            {
                // approximation by taylor series in x at 0 up to order 2
                var result = x;
                if (Math.abs(x) >= taylor_2_bound)
                {
                    var x3 = x * x * x;
                    // approximation by taylor series in x at 0 up to order 4
                    result -= x3 / 6;
                }
                return result;
            }
        };
        Math.asinh = asinh;
    }
    if (typeof Math.acosh === "undefined") {
        Math.acosh = function(x) {
            if (x < 1)
            {
                return NaN;
            }
            else if (x - 1 >= taylor_n_bound)
            {
                if (x > upper_taylor_2_bound)
                {
                    // approximation by laurent series in 1/x at 0+ order from -1 to 0
                    return Math.log(x) + Math.LN2;
                }
                else
                {
                    return Math.log(x + Math.sqrt(x * x - 1));
                }
            }
            else
            {
                var y = Math.sqrt(x - 1);
                // approximation by taylor series in y at 0 up to order 2
                var result = y;
                if (y >= taylor_2_bound)
                {
                    var y3 = y * y * y;
                    // approximation by taylor series in y at 0 up to order 4
                    result -= y3 / 12;
                }

                return Math.sqrt(2) * result;
            }
        };
    }
    if (typeof Math.atanh === "undefined") {
        Math.atanh = function(x) {
            if (Math.abs(x) < taylor_n_bound) {
                var result = x;
                if (Math.abs(x) > taylor_2_bound) {
                    result += (x * x * x) / 3;
                }
                return result;
            }
            return Math.log((1 + x) / (1 - x)) / 2;
        };
    }
    if (typeof Math.log1p === "undefined") {
        Math.log1p = function(x) {
            if (Math.abs(x) < taylor_n_bound) {
                var x2 = x * x;
                var x3 = x2 * x;
                var x4 = x3 * x;
                // approximation by taylor series in x at 0 up to order 4
                return (-x4 / 4 + x3 / 3 - x2 / 2 + x);
            }
            return Math.log(x + 1);
        };
    }
    if (typeof Math.expm1 === "undefined") {
        Math.expm1 = function(x) {
            if (Math.abs(x) < taylor_n_bound) {
                var x2 = x * x;
                var x3 = x2 * x;
                var x4 = x3 * x;
                // approximation by taylor series in x at 0 up to order 4
                return (x4 / 24 + x3 / 6 + x2 / 2 + x);
            }
            return Math.exp(x) - 1;
        };
    }
})();
if (typeof Math.hypot === "undefined") {
    Math.hypot = function() {
        var y = 0;
        var length = arguments.length;

        for (var i = 0; i < length; i++) {
            if (arguments[i] === Infinity || arguments[i] === -Infinity) {
                return Infinity;
            }
            y += arguments[i] * arguments[i];
        }
        return Math.sqrt(y);
    };
}
if (typeof Math.log10 === "undefined") {
    Math.log10 = function(x) {
        return Math.log(x) * Math.LOG10E;
    };
}
if (typeof Math.log2 === "undefined") {
    Math.log2 = function(x) {
        return Math.log(x) * Math.LOG2E;
    };
}
if (typeof Math.clz32 === "undefined") {
    Math.clz32 = (function(log, LN2) {
        return function(x) {
            var asUint = x >>> 0;
            if (asUint === 0) {
                return 32;
            }
            return 31 - (log(asUint) / LN2 | 0) | 0; // the "| 0" acts like math.floor
        };
    })(Math.log, Math.LN2);
}

// For HtmlUnit and PhantomJs
if (typeof ArrayBuffer.isView === "undefined") {
    ArrayBuffer.isView = function(a) {
        return a != null && a.__proto__ != null && a.__proto__.__proto__ === Int8Array.prototype.__proto__;
    };
}

if (typeof Array.prototype.fill === "undefined") {
    // Polyfill from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill#Polyfill
    Object.defineProperty(Array.prototype, 'fill', {
        value: function (value) {

            // Steps 1-2.
            if (this == null) {
                throw new TypeError('this is null or not defined');
            }

            var O = Object(this);

            // Steps 3-5.
            var len = O.length >>> 0;

            // Steps 6-7.
            var start = arguments[1];
            var relativeStart = start >> 0;

            // Step 8.
            var k = relativeStart < 0 ?
                    Math.max(len + relativeStart, 0) :
                    Math.min(relativeStart, len);

            // Steps 9-10.
            var end = arguments[2];
            var relativeEnd = end === undefined ?
                              len : end >> 0;

            // Step 11.
            var finalValue = relativeEnd < 0 ?
                             Math.max(len + relativeEnd, 0) :
                             Math.min(relativeEnd, len);

            // Step 12.
            while (k < finalValue) {
                O[k] = value;
                k++;
            }

            // Step 13.
            return O;
        }
    });
}

(function() {
    function normalizeOffset(offset, length) {
        if (offset < 0) return Math.max(0, offset + length);
        return Math.min(offset, length);
    }
    function typedArraySlice(begin, end) {
        if (typeof end === "undefined") {
            end = this.length;
        }
        begin = normalizeOffset(begin || 0, this.length);
        end = Math.max(begin, normalizeOffset(end, this.length));
        return new this.constructor(this.subarray(begin, end));
    }

    var arrays = [Int8Array, Int16Array, Uint16Array, Int32Array, Float32Array, Float64Array];
    for (var i = 0; i < arrays.length; ++i) {
        var TypedArray = arrays[i];
        if (typeof TypedArray.prototype.fill === "undefined") {
            Object.defineProperty(TypedArray.prototype, 'fill', {
                value: Array.prototype.fill
            });
        }
        if (typeof TypedArray.prototype.slice === "undefined") {
            Object.defineProperty(TypedArray.prototype, 'slice', {
                value: typedArraySlice
            });
        }
    }

    // Patch apply to work with TypedArrays if needed.
    try {
        (function() {}).apply(null, new Int32Array(0))
    } catch (e) {
        var apply = Function.prototype.apply;
        Object.defineProperty(Function.prototype, 'apply', {
            value: function(self, array) {
                return apply.call(this, self, [].slice.call(array));
            }
        });
    }


    // Patch map to work with TypedArrays if needed.
    for (var i = 0; i < arrays.length; ++i) {
        var TypedArray = arrays[i];
        if (typeof TypedArray.prototype.map === "undefined") {
            Object.defineProperty(TypedArray.prototype, 'map', {
                value: function(callback, self) {
                    return [].slice.call(this).map(callback, self);
                }
            });
        }
    }

    // Patch sort to work with TypedArrays if needed.
    // TODO: consider to remove following function and replace it with `Kotlin.doubleCompareTo` (see misc.js)
    var totalOrderComparator = function (a, b) {
        if (a < b) return -1;
        if (a > b) return 1;

        if (a === b) {
            if (a !== 0) return 0;

            var ia = 1 / a;
            return ia === 1 / b ? 0 : (ia < 0 ? -1 : 1);
        }

        return a !== a ? (b !== b ? 0 : 1) : -1
    };

    for (var i = 0; i < arrays.length; ++i) {
        var TypedArray = arrays[i];
        if (typeof TypedArray.prototype.sort === "undefined") {
            Object.defineProperty(TypedArray.prototype, 'sort', {
                value: function(compareFunction) {
                    return Array.prototype.sort.call(this, compareFunction || totalOrderComparator);
                }
            });
        }
    }
})();