/*

 *  base64.js

 *

 *  Licensed under the BSD 3-Clause License.

 *    http://opensource.org/licenses/BSD-3-Clause

 *

 *  References:

 *    http://en.wikipedia.org/wiki/Base64

 */

; (function (global, factory) {

    typeof exports === 'object' && typeof module !== 'undefined'

        ? module.exports = factory(global)

        : typeof define === 'function' && define.amd

            ? define(factory) : factory(global)

}((

    typeof self !== 'undefined' ? self

        : typeof window !== 'undefined' ? window

            : typeof global !== 'undefined' ? global

                : this

), function (global) {

    'use strict';

    // existing version for noConflict()

    global = global || {};

    var _Base64 = global.Base64;

    var version = "2.5.1";

    // if node.js and NOT React Native, we use Buffer

    var buffer;

    if (typeof module !== 'undefined' && module.exports) {

        try {

            buffer = eval("require('buffer').Buffer");

        } catch (err) {

            buffer = undefined;

        }

    }

    // constants

    var b64chars

        = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';

    var b64tab = function (bin) {

        var t = {};

        for (var i = , l = bin.length; i < l; i++) t[bin.charAt(i)] = i;

        return t;

    }(b64chars);

    var fromCharCode = String.fromCharCode;

    // encoder stuff

    var cb_utob = function (c) {

        if (c.length < ) {

            var cc = c.charCodeAt();

            return cc < 0x80 ? c

                : cc < 0x800 ? (fromCharCode(0xc0 | (cc >>> ))

                    + fromCharCode(0x80 | (cc & 0x3f)))

                    : (fromCharCode(0xe0 | ((cc >>> ) & 0x0f))

                        + fromCharCode(0x80 | ((cc >>> ) & 0x3f))

                        + fromCharCode(0x80 | (cc & 0x3f)));

        } else {

            var cc = 0x10000

                + (c.charCodeAt() - 0xD800) * 0x400

                + (c.charCodeAt() - 0xDC00);

            return (fromCharCode(0xf0 | ((cc >>> ) & 0x07))

                + fromCharCode(0x80 | ((cc >>> ) & 0x3f))

                + fromCharCode(0x80 | ((cc >>> ) & 0x3f))

                + fromCharCode(0x80 | (cc & 0x3f)));

        }

    };

    var re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;

    var utob = function (u) {

        return u.replace(re_utob, cb_utob);

    };

    var cb_encode = function (ccc) {

        var padlen = [, , ][ccc.length % ],

            ord = ccc.charCodeAt() <<

                | ((ccc.length >  ? ccc.charCodeAt() : ) << )

                | ((ccc.length >  ? ccc.charCodeAt() : )),

            chars = [

                b64chars.charAt(ord >>> ),

                b64chars.charAt((ord >>> ) & ),

                padlen >=  ? '=' : b64chars.charAt((ord >>> ) & ),

                padlen >=  ? '=' : b64chars.charAt(ord & )

            ];

        return chars.join('');

    };

    var btoa = global.btoa ? function (b) {

        return global.btoa(b);

    } : function (b) {

        return b.replace(/[\s\S]{,}/g, cb_encode);

    };

    var _encode = function (u) {

        const isUint8Array = Object.prototype.toString.call(u) === '[object Uint8Array]';

        return isUint8Array ? u.toString('base64')

            : btoa(utob(String(u)));

    }

    var encode = function (u, urisafe) {

        return !urisafe

            ? _encode(u)

            : _encode(String(u)).replace(/[+\/]/g, function (m0) {

                return m0 == '+' ? '-' : '_';

            }).replace(/=/g, '');

    };

    var encodeURI = function (u) { return encode(u, true) };

    // decoder stuff

    var re_btou = new RegExp([

        '[\xC0-\xDF][\x80-\xBF]',

        '[\xE0-\xEF][\x80-\xBF]{2}',

        '[\xF0-\xF7][\x80-\xBF]{3}'

    ].join('|'), 'g');

    var cb_btou = function (cccc) {

        switch (cccc.length) {

            case :

                var cp = ((0x07 & cccc.charCodeAt()) << )

                    | ((0x3f & cccc.charCodeAt()) << )

                    | ((0x3f & cccc.charCodeAt()) << )

                    | (0x3f & cccc.charCodeAt()),

                    offset = cp - 0x10000;

                return (fromCharCode((offset >>> ) + 0xD800)

                    + fromCharCode((offset & 0x3FF) + 0xDC00));

            case :

                return fromCharCode(

                    ((0x0f & cccc.charCodeAt()) << )

                    | ((0x3f & cccc.charCodeAt()) << )

                    | (0x3f & cccc.charCodeAt())

                );

            default:

                return fromCharCode(

                    ((0x1f & cccc.charCodeAt()) << )

                    | (0x3f & cccc.charCodeAt())

                );

        }

    };

    var btou = function (b) {

        return b.replace(re_btou, cb_btou);

    };

    var cb_decode = function (cccc) {

        var len = cccc.length,

            padlen = len % ,

            n = (len >  ? b64tab[cccc.charAt()] <<  : )

                | (len >  ? b64tab[cccc.charAt()] <<  : )

                | (len >  ? b64tab[cccc.charAt()] <<  : )

                | (len >  ? b64tab[cccc.charAt()] : ),

            chars = [

                fromCharCode(n >>> ),

                fromCharCode((n >>> ) & 0xff),

                fromCharCode(n & 0xff)

            ];

        chars.length -= [, , , ][padlen];

        return chars.join('');

    };

    var _atob = global.atob ? function (a) {

        return global.atob(a);

    } : function (a) {

        return a.replace(/\S{,}/g, cb_decode);

    };

    var atob = function (a) {

        return _atob(String(a).replace(/[^A-Za-z0-\+\/]/g, ''));

    };

    var _decode = buffer ?

        buffer.from && Uint8Array && buffer.from !== Uint8Array.from

            ? function (a) {

                return (a.constructor === buffer.constructor

                    ? a : buffer.from(a, 'base64')).toString();

            }

            : function (a) {

                return (a.constructor === buffer.constructor

                    ? a : new buffer(a, 'base64')).toString();

            }

        : function (a) { return btou(_atob(a)) };

    var decode = function (a) {

        return _decode(

            String(a).replace(/[-_]/g, function (m0) { return m0 == '-' ? '+' : '/' })

                .replace(/[^A-Za-z0-\+\/]/g, '')

        );

    };

    var noConflict = function () {

        var Base64 = global.Base64;

        global.Base64 = _Base64;

        return Base64;

    };

    // export Base64

    global.Base64 = {

        VERSION: version,

        atob: atob,

        btoa: btoa,

        fromBase64: decode,

        toBase64: encode,

        utob: utob,

        encode: encode,

        encodeURI: encodeURI,

        btou: btou,

        decode: decode,

        noConflict: noConflict,

        __buffer__: buffer

    };

    // if ES5 is available, make Base64.extendString() available

    if (typeof Object.defineProperty === 'function') {

        var noEnum = function (v) {

            return { value: v, enumerable: false, writable: true, configurable: true };

        };

        global.Base64.extendString = function () {

            Object.defineProperty(

                String.prototype, 'fromBase64', noEnum(function () {

                    return decode(this)

                }));

            Object.defineProperty(

                String.prototype, 'toBase64', noEnum(function (urisafe) {

                    return encode(this, urisafe)

                }));

            Object.defineProperty(

                String.prototype, 'toBase64URI', noEnum(function () {

                    return encode(this, true)

                }));

        };

    }

    //

    // export Base64 to the namespace

    //

    if (global['Meteor']) { // Meteor.js

        Base64 = global.Base64;

    }

    // module.exports and AMD are mutually exclusive.

    // module.exports has precedence.

    if (typeof module !== 'undefined' && module.exports) {

        module.exports.Base64 = global.Base64;

    }

    else if (typeof define === 'function' && define.amd) {

        // AMD. Register as an anonymous module.

        define([], function () { return global.Base64 });

    }

    // that's it!

    return { Base64: global.Base64 }

}));

Base64.encode(str)