@foxone/mixin-sdk-jsbridge/es/index.js

import {parseUrl}from'peeler-js/es/parseUrl';import {Logger}from'peeler-js/es/logger';import {getUA}from'peeler-js/es/getUA';import Request from'ajax-maker';import {storage}from'peeler-js/es/storage';import {isType}from'peeler-js/es/isType';import {Base64}from'js-base64';import require$$0 from'crypto';const logger = new Logger({
    debug: true,
    logLevel: 'detail',
    logPrefix: getPrefix()
});
function getPrefix(scope, suffix) {
    let str = 'Mixin-JSBridge';
    if (scope && suffix) {
        str = `${str} ${scope}-${suffix}`;
    }
    else if (scope) {
        str = `${str} ${scope}`;
    }
    else if (suffix) {
        str = `${str} ${suffix}`;
    }
    return str;
}
function getLogger(scope) {
    return function (suffix) {
        return logger.setPrefix(getPrefix(scope, suffix));
    };
}function env() {
    var _a;
    const ua = (_a = window === null || window === void 0 ? void 0 : window.navigator) === null || _a === void 0 ? void 0 : _a.userAgent;
    return Object.assign({}, getUA(ua));
}function parseError(err) {
    var _a, _b, _c;
    const name = err === null || err === void 0 ? void 0 : err.name;
    const message = (_c = (_a = err === null || err === void 0 ? void 0 : err.message) !== null && _a !== void 0 ? _a : (_b = err === null || err === void 0 ? void 0 : err.toString) === null || _b === void 0 ? void 0 : _b.call(err)) !== null && _c !== void 0 ? _c : err;
    const stack = err === null || err === void 0 ? void 0 : err.stack;
    return {
        name,
        message,
        stack
    };
}const { request, setting } = new Request({
    codeMap: {
        suc_code: 200,
        err_code: -1
    },
    codeField: 'code'
});let storageType = 'localStorage';
const logger$1 = getLogger('storage');
const store = {
    get: (key) => storage.get(key, storageType),
    set: (key, val) => {
        try {
            if (typeof val !== 'string') {
                val = JSON.stringify(val);
            }
            return storage.set(key, val, storageType);
        }
        catch (err) {
            logger$1().warn('set storage error', err);
            return false;
        }
    },
    clear: (key) => storage.clear(key, storageType)
};function isObject(val) {
    return isType('object')(val);
}function uuid() {
    let d = new Date().getTime();
    const uuid = 'xxxxxxxx-yyyy-yyyy-yyyy-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
        const r = (d + Math.random() * 16) % 16 | 0;
        d = Math.floor(d / 16);
        return (c === 'x'
            ? r
            : (r & 0x7) | 0x8).toString(16);
    });
    return uuid;
}const logger$2 = getLogger('messager');
function messager(type) {
    var _a, _b, _c, _d, _e, _f, _g;
    const envInfo = env();
    const handler = envInfo.isIOS
        ? type === 'getContext'
            ? () => JSON.parse(prompt('MixinContext.getContext()'))
            : (_c = (_b = (_a = window === null || window === void 0 ? void 0 : window.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b[type]) === null || _c === void 0 ? void 0 : _c.postMessage.bind((_e = (_d = window === null || window === void 0 ? void 0 : window.webkit) === null || _d === void 0 ? void 0 : _d.messageHandlers) === null || _e === void 0 ? void 0 : _e[type])
        : (_g = (_f = window === null || window === void 0 ? void 0 : window.MixinContext) === null || _f === void 0 ? void 0 : _f[type]) === null || _g === void 0 ? void 0 : _g.bind(window === null || window === void 0 ? void 0 : window.MixinContext);
    return handler !== null && handler !== void 0 ? handler : (() => logger$2().warn(`The messager "${type}" is not support yet!`));
}var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

function createCommonjsModule(fn) {
  var module = { exports: {} };
	return fn(module, module.exports), module.exports;
}

function commonjsRequire (target) {
	throw new Error('Could not dynamically require "' + target + '". Please configure the dynamicRequireTargets option of @rollup/plugin-commonjs appropriately for this require call to behave properly.');
}var core = createCommonjsModule(function (module, exports) {
(function (root, factory) {
	{
		// CommonJS
		module.exports = exports = factory();
	}
}(commonjsGlobal, function () {

	/*globals window, global, require*/

	/**
	 * CryptoJS core components.
	 */
	var CryptoJS = CryptoJS || (function (Math, undefined$1) {

	    var crypto;

	    // Native crypto from window (Browser)
	    if (typeof window !== 'undefined' && window.crypto) {
	        crypto = window.crypto;
	    }

	    // Native (experimental IE 11) crypto from window (Browser)
	    if (!crypto && typeof window !== 'undefined' && window.msCrypto) {
	        crypto = window.msCrypto;
	    }

	    // Native crypto from global (NodeJS)
	    if (!crypto && typeof commonjsGlobal !== 'undefined' && commonjsGlobal.crypto) {
	        crypto = commonjsGlobal.crypto;
	    }

	    // Native crypto import via require (NodeJS)
	    if (!crypto && typeof commonjsRequire === 'function') {
	        try {
	            crypto = require$$0;
	        } catch (err) {}
	    }

	    /*
	     * Cryptographically secure pseudorandom number generator
	     *
	     * As Math.random() is cryptographically not safe to use
	     */
	    var cryptoSecureRandomInt = function () {
	        if (crypto) {
	            // Use getRandomValues method (Browser)
	            if (typeof crypto.getRandomValues === 'function') {
	                try {
	                    return crypto.getRandomValues(new Uint32Array(1))[0];
	                } catch (err) {}
	            }

	            // Use randomBytes method (NodeJS)
	            if (typeof crypto.randomBytes === 'function') {
	                try {
	                    return crypto.randomBytes(4).readInt32LE();
	                } catch (err) {}
	            }
	        }

	        throw new Error('Native crypto module could not be used to get secure random number.');
	    };

	    /*
	     * Local polyfill of Object.create

	     */
	    var create = Object.create || (function () {
	        function F() {}

	        return function (obj) {
	            var subtype;

	            F.prototype = obj;

	            subtype = new F();

	            F.prototype = null;

	            return subtype;
	        };
	    }());

	    /**
	     * CryptoJS namespace.
	     */
	    var C = {};

	    /**
	     * Library namespace.
	     */
	    var C_lib = C.lib = {};

	    /**
	     * Base object for prototypal inheritance.
	     */
	    var Base = C_lib.Base = (function () {


	        return {
	            /**
	             * Creates a new object that inherits from this object.
	             *
	             * @param {Object} overrides Properties to copy into the new object.
	             *
	             * @return {Object} The new object.
	             *
	             * @static
	             *
	             * @example
	             *
	             *     var MyType = CryptoJS.lib.Base.extend({
	             *         field: 'value',
	             *
	             *         method: function () {
	             *         }
	             *     });
	             */
	            extend: function (overrides) {
	                // Spawn
	                var subtype = create(this);

	                // Augment
	                if (overrides) {
	                    subtype.mixIn(overrides);
	                }

	                // Create default initializer
	                if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
	                    subtype.init = function () {
	                        subtype.$super.init.apply(this, arguments);
	                    };
	                }

	                // Initializer's prototype is the subtype object
	                subtype.init.prototype = subtype;

	                // Reference supertype
	                subtype.$super = this;

	                return subtype;
	            },

	            /**
	             * Extends this object and runs the init method.
	             * Arguments to create() will be passed to init().
	             *
	             * @return {Object} The new object.
	             *
	             * @static
	             *
	             * @example
	             *
	             *     var instance = MyType.create();
	             */
	            create: function () {
	                var instance = this.extend();
	                instance.init.apply(instance, arguments);

	                return instance;
	            },

	            /**
	             * Initializes a newly created object.
	             * Override this method to add some logic when your objects are created.
	             *
	             * @example
	             *
	             *     var MyType = CryptoJS.lib.Base.extend({
	             *         init: function () {
	             *             // ...
	             *         }
	             *     });
	             */
	            init: function () {
	            },

	            /**
	             * Copies properties into this object.
	             *
	             * @param {Object} properties The properties to mix in.
	             *
	             * @example
	             *
	             *     MyType.mixIn({
	             *         field: 'value'
	             *     });
	             */
	            mixIn: function (properties) {
	                for (var propertyName in properties) {
	                    if (properties.hasOwnProperty(propertyName)) {
	                        this[propertyName] = properties[propertyName];
	                    }
	                }

	                // IE won't copy toString using the loop above
	                if (properties.hasOwnProperty('toString')) {
	                    this.toString = properties.toString;
	                }
	            },

	            /**
	             * Creates a copy of this object.
	             *
	             * @return {Object} The clone.
	             *
	             * @example
	             *
	             *     var clone = instance.clone();
	             */
	            clone: function () {
	                return this.init.prototype.extend(this);
	            }
	        };
	    }());

	    /**
	     * An array of 32-bit words.
	     *
	     * @property {Array} words The array of 32-bit words.
	     * @property {number} sigBytes The number of significant bytes in this word array.
	     */
	    var WordArray = C_lib.WordArray = Base.extend({
	        /**
	         * Initializes a newly created word array.
	         *
	         * @param {Array} words (Optional) An array of 32-bit words.
	         * @param {number} sigBytes (Optional) The number of significant bytes in the words.
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.lib.WordArray.create();
	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
	         *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
	         */
	        init: function (words, sigBytes) {
	            words = this.words = words || [];

	            if (sigBytes != undefined$1) {
	                this.sigBytes = sigBytes;
	            } else {
	                this.sigBytes = words.length * 4;
	            }
	        },

	        /**
	         * Converts this word array to a string.
	         *
	         * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
	         *
	         * @return {string} The stringified word array.
	         *
	         * @example
	         *
	         *     var string = wordArray + '';
	         *     var string = wordArray.toString();
	         *     var string = wordArray.toString(CryptoJS.enc.Utf8);
	         */
	        toString: function (encoder) {
	            return (encoder || Hex).stringify(this);
	        },

	        /**
	         * Concatenates a word array to this word array.
	         *
	         * @param {WordArray} wordArray The word array to append.
	         *
	         * @return {WordArray} This word array.
	         *
	         * @example
	         *
	         *     wordArray1.concat(wordArray2);
	         */
	        concat: function (wordArray) {
	            // Shortcuts
	            var thisWords = this.words;
	            var thatWords = wordArray.words;
	            var thisSigBytes = this.sigBytes;
	            var thatSigBytes = wordArray.sigBytes;

	            // Clamp excess bits
	            this.clamp();

	            // Concat
	            if (thisSigBytes % 4) {
	                // Copy one byte at a time
	                for (var i = 0; i < thatSigBytes; i++) {
	                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
	                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
	                }
	            } else {
	                // Copy one word at a time
	                for (var i = 0; i < thatSigBytes; i += 4) {
	                    thisWords[(thisSigBytes + i) >>> 2] = thatWords[i >>> 2];
	                }
	            }
	            this.sigBytes += thatSigBytes;

	            // Chainable
	            return this;
	        },

	        /**
	         * Removes insignificant bits.
	         *
	         * @example
	         *
	         *     wordArray.clamp();
	         */
	        clamp: function () {
	            // Shortcuts
	            var words = this.words;
	            var sigBytes = this.sigBytes;

	            // Clamp
	            words[sigBytes >>> 2] &= 0xffffffff << (32 - (sigBytes % 4) * 8);
	            words.length = Math.ceil(sigBytes / 4);
	        },

	        /**
	         * Creates a copy of this word array.
	         *
	         * @return {WordArray} The clone.
	         *
	         * @example
	         *
	         *     var clone = wordArray.clone();
	         */
	        clone: function () {
	            var clone = Base.clone.call(this);
	            clone.words = this.words.slice(0);

	            return clone;
	        },

	        /**
	         * Creates a word array filled with random bytes.
	         *
	         * @param {number} nBytes The number of random bytes to generate.
	         *
	         * @return {WordArray} The random word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.lib.WordArray.random(16);
	         */
	        random: function (nBytes) {
	            var words = [];

	            for (var i = 0; i < nBytes; i += 4) {
	                words.push(cryptoSecureRandomInt());
	            }

	            return new WordArray.init(words, nBytes);
	        }
	    });

	    /**
	     * Encoder namespace.
	     */
	    var C_enc = C.enc = {};

	    /**
	     * Hex encoding strategy.
	     */
	    var Hex = C_enc.Hex = {
	        /**
	         * Converts a word array to a hex string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The hex string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
	         */
	        stringify: function (wordArray) {
	            // Shortcuts
	            var words = wordArray.words;
	            var sigBytes = wordArray.sigBytes;

	            // Convert
	            var hexChars = [];
	            for (var i = 0; i < sigBytes; i++) {
	                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
	                hexChars.push((bite >>> 4).toString(16));
	                hexChars.push((bite & 0x0f).toString(16));
	            }

	            return hexChars.join('');
	        },

	        /**
	         * Converts a hex string to a word array.
	         *
	         * @param {string} hexStr The hex string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Hex.parse(hexString);
	         */
	        parse: function (hexStr) {
	            // Shortcut
	            var hexStrLength = hexStr.length;

	            // Convert
	            var words = [];
	            for (var i = 0; i < hexStrLength; i += 2) {
	                words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << (24 - (i % 8) * 4);
	            }

	            return new WordArray.init(words, hexStrLength / 2);
	        }
	    };

	    /**
	     * Latin1 encoding strategy.
	     */
	    var Latin1 = C_enc.Latin1 = {
	        /**
	         * Converts a word array to a Latin1 string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The Latin1 string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
	         */
	        stringify: function (wordArray) {
	            // Shortcuts
	            var words = wordArray.words;
	            var sigBytes = wordArray.sigBytes;

	            // Convert
	            var latin1Chars = [];
	            for (var i = 0; i < sigBytes; i++) {
	                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
	                latin1Chars.push(String.fromCharCode(bite));
	            }

	            return latin1Chars.join('');
	        },

	        /**
	         * Converts a Latin1 string to a word array.
	         *
	         * @param {string} latin1Str The Latin1 string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
	         */
	        parse: function (latin1Str) {
	            // Shortcut
	            var latin1StrLength = latin1Str.length;

	            // Convert
	            var words = [];
	            for (var i = 0; i < latin1StrLength; i++) {
	                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (24 - (i % 4) * 8);
	            }

	            return new WordArray.init(words, latin1StrLength);
	        }
	    };

	    /**
	     * UTF-8 encoding strategy.
	     */
	    var Utf8 = C_enc.Utf8 = {
	        /**
	         * Converts a word array to a UTF-8 string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The UTF-8 string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
	         */
	        stringify: function (wordArray) {
	            try {
	                return decodeURIComponent(escape(Latin1.stringify(wordArray)));
	            } catch (e) {
	                throw new Error('Malformed UTF-8 data');
	            }
	        },

	        /**
	         * Converts a UTF-8 string to a word array.
	         *
	         * @param {string} utf8Str The UTF-8 string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
	         */
	        parse: function (utf8Str) {
	            return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
	        }
	    };

	    /**
	     * Abstract buffered block algorithm template.
	     *
	     * The property blockSize must be implemented in a concrete subtype.
	     *
	     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
	     */
	    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
	        /**
	         * Resets this block algorithm's data buffer to its initial state.
	         *
	         * @example
	         *
	         *     bufferedBlockAlgorithm.reset();
	         */
	        reset: function () {
	            // Initial values
	            this._data = new WordArray.init();
	            this._nDataBytes = 0;
	        },

	        /**
	         * Adds new data to this block algorithm's buffer.
	         *
	         * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
	         *
	         * @example
	         *
	         *     bufferedBlockAlgorithm._append('data');
	         *     bufferedBlockAlgorithm._append(wordArray);
	         */
	        _append: function (data) {
	            // Convert string to WordArray, else assume WordArray already
	            if (typeof data == 'string') {
	                data = Utf8.parse(data);
	            }

	            // Append
	            this._data.concat(data);
	            this._nDataBytes += data.sigBytes;
	        },

	        /**
	         * Processes available data blocks.
	         *
	         * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
	         *
	         * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
	         *
	         * @return {WordArray} The processed data.
	         *
	         * @example
	         *
	         *     var processedData = bufferedBlockAlgorithm._process();
	         *     var processedData = bufferedBlockAlgorithm._process(!!'flush');
	         */
	        _process: function (doFlush) {
	            var processedWords;

	            // Shortcuts
	            var data = this._data;
	            var dataWords = data.words;
	            var dataSigBytes = data.sigBytes;
	            var blockSize = this.blockSize;
	            var blockSizeBytes = blockSize * 4;

	            // Count blocks ready
	            var nBlocksReady = dataSigBytes / blockSizeBytes;
	            if (doFlush) {
	                // Round up to include partial blocks
	                nBlocksReady = Math.ceil(nBlocksReady);
	            } else {
	                // Round down to include only full blocks,
	                // less the number of blocks that must remain in the buffer
	                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
	            }

	            // Count words ready
	            var nWordsReady = nBlocksReady * blockSize;

	            // Count bytes ready
	            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);

	            // Process blocks
	            if (nWordsReady) {
	                for (var offset = 0; offset < nWordsReady; offset += blockSize) {
	                    // Perform concrete-algorithm logic
	                    this._doProcessBlock(dataWords, offset);
	                }

	                // Remove processed words
	                processedWords = dataWords.splice(0, nWordsReady);
	                data.sigBytes -= nBytesReady;
	            }

	            // Return processed words
	            return new WordArray.init(processedWords, nBytesReady);
	        },

	        /**
	         * Creates a copy of this object.
	         *
	         * @return {Object} The clone.
	         *
	         * @example
	         *
	         *     var clone = bufferedBlockAlgorithm.clone();
	         */
	        clone: function () {
	            var clone = Base.clone.call(this);
	            clone._data = this._data.clone();

	            return clone;
	        },

	        _minBufferSize: 0
	    });

	    /**
	     * Abstract hasher template.
	     *
	     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
	     */
	    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({
	        /**
	         * Configuration options.
	         */
	        cfg: Base.extend(),

	        /**
	         * Initializes a newly created hasher.
	         *
	         * @param {Object} cfg (Optional) The configuration options to use for this hash computation.
	         *
	         * @example
	         *
	         *     var hasher = CryptoJS.algo.SHA256.create();
	         */
	        init: function (cfg) {
	            // Apply config defaults
	            this.cfg = this.cfg.extend(cfg);

	            // Set initial values
	            this.reset();
	        },

	        /**
	         * Resets this hasher to its initial state.
	         *
	         * @example
	         *
	         *     hasher.reset();
	         */
	        reset: function () {
	            // Reset data buffer
	            BufferedBlockAlgorithm.reset.call(this);

	            // Perform concrete-hasher logic
	            this._doReset();
	        },

	        /**
	         * Updates this hasher with a message.
	         *
	         * @param {WordArray|string} messageUpdate The message to append.
	         *
	         * @return {Hasher} This hasher.
	         *
	         * @example
	         *
	         *     hasher.update('message');
	         *     hasher.update(wordArray);
	         */
	        update: function (messageUpdate) {
	            // Append
	            this._append(messageUpdate);

	            // Update the hash
	            this._process();

	            // Chainable
	            return this;
	        },

	        /**
	         * Finalizes the hash computation.
	         * Note that the finalize operation is effectively a destructive, read-once operation.
	         *
	         * @param {WordArray|string} messageUpdate (Optional) A final message update.
	         *
	         * @return {WordArray} The hash.
	         *
	         * @example
	         *
	         *     var hash = hasher.finalize();
	         *     var hash = hasher.finalize('message');
	         *     var hash = hasher.finalize(wordArray);
	         */
	        finalize: function (messageUpdate) {
	            // Final message update
	            if (messageUpdate) {
	                this._append(messageUpdate);
	            }

	            // Perform concrete-hasher logic
	            var hash = this._doFinalize();

	            return hash;
	        },

	        blockSize: 512/32,

	        /**
	         * Creates a shortcut function to a hasher's object interface.
	         *
	         * @param {Hasher} hasher The hasher to create a helper for.
	         *
	         * @return {Function} The shortcut function.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
	         */
	        _createHelper: function (hasher) {
	            return function (message, cfg) {
	                return new hasher.init(cfg).finalize(message);
	            };
	        },

	        /**
	         * Creates a shortcut function to the HMAC's object interface.
	         *
	         * @param {Hasher} hasher The hasher to use in this HMAC helper.
	         *
	         * @return {Function} The shortcut function.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
	         */
	        _createHmacHelper: function (hasher) {
	            return function (message, key) {
	                return new C_algo.HMAC.init(hasher, key).finalize(message);
	            };
	        }
	    });

	    /**
	     * Algorithm namespace.
	     */
	    var C_algo = C.algo = {};

	    return C;
	}(Math));


	return CryptoJS;

}));
});var encBase64 = createCommonjsModule(function (module, exports) {
(function (root, factory) {
	{
		// CommonJS
		module.exports = exports = factory(core);
	}
}(commonjsGlobal, function (CryptoJS) {

	(function () {
	    // Shortcuts
	    var C = CryptoJS;
	    var C_lib = C.lib;
	    var WordArray = C_lib.WordArray;
	    var C_enc = C.enc;

	    /**
	     * Base64 encoding strategy.
	     */
	    var Base64 = C_enc.Base64 = {
	        /**
	         * Converts a word array to a Base64 string.
	         *
	         * @param {WordArray} wordArray The word array.
	         *
	         * @return {string} The Base64 string.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
	         */
	        stringify: function (wordArray) {
	            // Shortcuts
	            var words = wordArray.words;
	            var sigBytes = wordArray.sigBytes;
	            var map = this._map;

	            // Clamp excess bits
	            wordArray.clamp();

	            // Convert
	            var base64Chars = [];
	            for (var i = 0; i < sigBytes; i += 3) {
	                var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;
	                var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
	                var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;

	                var triplet = (byte1 << 16) | (byte2 << 8) | byte3;

	                for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {
	                    base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
	                }
	            }

	            // Add padding
	            var paddingChar = map.charAt(64);
	            if (paddingChar) {
	                while (base64Chars.length % 4) {
	                    base64Chars.push(paddingChar);
	                }
	            }

	            return base64Chars.join('');
	        },

	        /**
	         * Converts a Base64 string to a word array.
	         *
	         * @param {string} base64Str The Base64 string.
	         *
	         * @return {WordArray} The word array.
	         *
	         * @static
	         *
	         * @example
	         *
	         *     var wordArray = CryptoJS.enc.Base64.parse(base64String);
	         */
	        parse: function (base64Str) {
	            // Shortcuts
	            var base64StrLength = base64Str.length;
	            var map = this._map;
	            var reverseMap = this._reverseMap;

	            if (!reverseMap) {
	                    reverseMap = this._reverseMap = [];
	                    for (var j = 0; j < map.length; j++) {
	                        reverseMap[map.charCodeAt(j)] = j;
	                    }
	            }

	            // Ignore padding
	            var paddingChar = map.charAt(64);
	            if (paddingChar) {
	                var paddingIndex = base64Str.indexOf(paddingChar);
	                if (paddingIndex !== -1) {
	                    base64StrLength = paddingIndex;
	                }
	            }

	            // Convert
	            return parseLoop(base64Str, base64StrLength, reverseMap);

	        },

	        _map: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='
	    };

	    function parseLoop(base64Str, base64StrLength, reverseMap) {
	      var words = [];
	      var nBytes = 0;
	      for (var i = 0; i < base64StrLength; i++) {
	          if (i % 4) {
	              var bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
	              var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
	              var bitsCombined = bits1 | bits2;
	              words[nBytes >>> 2] |= bitsCombined << (24 - (nBytes % 4) * 8);
	              nBytes++;
	          }
	      }
	      return WordArray.create(words, nBytes);
	    }
	}());


	return CryptoJS.enc.Base64;

}));
});var sha256 = createCommonjsModule(function (module, exports) {
(function (root, factory) {
	{
		// CommonJS
		module.exports = exports = factory(core);
	}
}(commonjsGlobal, function (CryptoJS) {

	(function (Math) {
	    // Shortcuts
	    var C = CryptoJS;
	    var C_lib = C.lib;
	    var WordArray = C_lib.WordArray;
	    var Hasher = C_lib.Hasher;
	    var C_algo = C.algo;

	    // Initialization and round constants tables
	    var H = [];
	    var K = [];

	    // Compute constants
	    (function () {
	        function isPrime(n) {
	            var sqrtN = Math.sqrt(n);
	            for (var factor = 2; factor <= sqrtN; factor++) {
	                if (!(n % factor)) {
	                    return false;
	                }
	            }

	            return true;
	        }

	        function getFractionalBits(n) {
	            return ((n - (n | 0)) * 0x100000000) | 0;
	        }

	        var n = 2;
	        var nPrime = 0;
	        while (nPrime < 64) {
	            if (isPrime(n)) {
	                if (nPrime < 8) {
	                    H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));
	                }
	                K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));

	                nPrime++;
	            }

	            n++;
	        }
	    }());

	    // Reusable object
	    var W = [];

	    /**
	     * SHA-256 hash algorithm.
	     */
	    var SHA256 = C_algo.SHA256 = Hasher.extend({
	        _doReset: function () {
	            this._hash = new WordArray.init(H.slice(0));
	        },

	        _doProcessBlock: function (M, offset) {
	            // Shortcut
	            var H = this._hash.words;

	            // Working variables
	            var a = H[0];
	            var b = H[1];
	            var c = H[2];
	            var d = H[3];
	            var e = H[4];
	            var f = H[5];
	            var g = H[6];
	            var h = H[7];

	            // Computation
	            for (var i = 0; i < 64; i++) {
	                if (i < 16) {
	                    W[i] = M[offset + i] | 0;
	                } else {
	                    var gamma0x = W[i - 15];
	                    var gamma0  = ((gamma0x << 25) | (gamma0x >>> 7))  ^
	                                  ((gamma0x << 14) | (gamma0x >>> 18)) ^
	                                   (gamma0x >>> 3);

	                    var gamma1x = W[i - 2];
	                    var gamma1  = ((gamma1x << 15) | (gamma1x >>> 17)) ^
	                                  ((gamma1x << 13) | (gamma1x >>> 19)) ^
	                                   (gamma1x >>> 10);

	                    W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
	                }

	                var ch  = (e & f) ^ (~e & g);
	                var maj = (a & b) ^ (a & c) ^ (b & c);

	                var sigma0 = ((a << 30) | (a >>> 2)) ^ ((a << 19) | (a >>> 13)) ^ ((a << 10) | (a >>> 22));
	                var sigma1 = ((e << 26) | (e >>> 6)) ^ ((e << 21) | (e >>> 11)) ^ ((e << 7)  | (e >>> 25));

	                var t1 = h + sigma1 + ch + K[i] + W[i];
	                var t2 = sigma0 + maj;

	                h = g;
	                g = f;
	                f = e;
	                e = (d + t1) | 0;
	                d = c;
	                c = b;
	                b = a;
	                a = (t1 + t2) | 0;
	            }

	            // Intermediate hash value
	            H[0] = (H[0] + a) | 0;
	            H[1] = (H[1] + b) | 0;
	            H[2] = (H[2] + c) | 0;
	            H[3] = (H[3] + d) | 0;
	            H[4] = (H[4] + e) | 0;
	            H[5] = (H[5] + f) | 0;
	            H[6] = (H[6] + g) | 0;
	            H[7] = (H[7] + h) | 0;
	        },

	        _doFinalize: function () {
	            // Shortcuts
	            var data = this._data;
	            var dataWords = data.words;

	            var nBitsTotal = this._nDataBytes * 8;
	            var nBitsLeft = data.sigBytes * 8;

	            // Add padding
	            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
	            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
	            data.sigBytes = dataWords.length * 4;

	            // Hash final blocks
	            this._process();

	            // Return final computed hash
	            return this._hash;
	        },

	        clone: function () {
	            var clone = Hasher.clone.call(this);
	            clone._hash = this._hash.clone();

	            return clone;
	        }
	    });

	    /**
	     * Shortcut function to the hasher's object interface.
	     *
	     * @param {WordArray|string} message The message to hash.
	     *
	     * @return {WordArray} The hash.
	     *
	     * @static
	     *
	     * @example
	     *
	     *     var hash = CryptoJS.SHA256('message');
	     *     var hash = CryptoJS.SHA256(wordArray);
	     */
	    C.SHA256 = Hasher._createHelper(SHA256);

	    /**
	     * Shortcut function to the HMAC's object interface.
	     *
	     * @param {WordArray|string} message The message to hash.
	     * @param {WordArray|string} key The secret key.
	     *
	     * @return {WordArray} The HMAC.
	     *
	     * @static
	     *
	     * @example
	     *
	     *     var hmac = CryptoJS.HmacSHA256(message, key);
	     */
	    C.HmacSHA256 = Hasher._createHmacHelper(SHA256);
	}(Math));


	return CryptoJS.SHA256;

}));
});const AUTHSCOPE = {
    phone: 'PHONE:READ',
    profile: 'PROFILE:READ',
    contacts: 'CONTACTS:READ',
    assets: 'ASSETS:READ',
    snapshots: 'SNAPSHOTS:READ',
    messages: 'MESSAGES:REPRESENT'
};
function base64URLEncode(str) {
    return str
        .replace(/\+/g, '-')
        .replace(/\//g, '_')
        .replace(/=/g, '');
}
function generateRandomString(len) {
    let text = '';
    const possible = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    for (let i = 0; i < len; i++) {
        text += possible.charAt(Math.floor(Math.random() * possible.length));
    }
    return text;
}
function getAccessCode(params) {
    // eslint-disable-next-line prefer-const
    let { client_id, oauth_url = 'https://mixin.one/oauth/authorize', redirect_url = window.location.href, state, auth = {}, code_challenge = true } = params;
    const randomCode = generateRandomString(32);
    const verifier = base64URLEncode(Base64.encode(randomCode));
    let challenge = base64URLEncode(sha256(randomCode).toString(encBase64));
    verifier && store.set('$_mixin-code-verifier', verifier);
    let SCOPESTR = '';
    Object.keys(auth).forEach(scope => {
        if (!auth[scope])
            return;
        const scopeValue = AUTHSCOPE[scope];
        if (!SCOPESTR)
            SCOPESTR = scopeValue;
        else
            SCOPESTR += `+${scopeValue}`;
    });
    client_id = client_id ? `&client_id=${client_id}` : '';
    redirect_url = redirect_url ? `&redirect_url=${encodeURIComponent(redirect_url)}` : '';
    SCOPESTR = SCOPESTR ? `&scope=${SCOPESTR}` : '';
    challenge = (code_challenge && challenge) ? `&code_challenge=${challenge}` : '';
    let url = `${oauth_url}/?response_type=code${client_id}${redirect_url}${SCOPESTR}${challenge}`;
    if (state) {
        const str = encodeURIComponent(state);
        url += `&state=${str}`;
    }
    window.location.href = url;
}
function getAccessToken(params) {
    const data = Object.assign({}, params);
    return request({
        url: 'https://mixin-api.zeromesh.net/oauth/token',
        method: 'POST',
        data,
        withCredentials: false
    })
        .then(res => res.data.access_token);
}/*! *****************************************************************************
Copyright (c) Microsoft Corporation.

Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted.

THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
PERFORMANCE OF THIS SOFTWARE.
***************************************************************************** */

function __rest(s, e) {
    var t = {};
    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
        t[p] = s[p];
    if (s != null && typeof Object.getOwnPropertySymbols === "function")
        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
                t[p[i]] = s[p[i]];
        }
    return t;
}const logger$3 = getLogger('scheme');
const SCHEME = {
    prefix: 'mixin',
    loadScheme: function (url, open) {
        if (!url) {
            logger$3('loadScheme').error('The URL cannot be a falsy value!');
            return;
        }
        if (open) {
            window.open(url);
        }
        else {
            window.location.href = url;
        }
        return url;
    },
    getQuery: function (query) {
        if (!query) {
            return '';
        }
        let res = '';
        for (const k in query) {
            const val = query[k];
            if (val === null || val === undefined)
                continue;
            res += `&${k}=${val}`;
        }
        return res.replace(/^&?/, '?');
    },
    pay: function (params) {
        const _params = this.getQuery(params);
        const _url = `${this.prefix}://pay${_params}`;
        logger$3('pay').log(_url);
        return this.loadScheme(_url);
    },
    transfer: function (recipient) {
        const _url = `${this.prefix}://transfer/${recipient}`;
        logger$3('transfer').log(_url);
        return this.loadScheme(_url);
    },
    snapshots: function (params) {
        const { trace_id, snapshot_id } = params;
        if (!trace_id && !snapshot_id) {
            logger$3('snapshots').error('Must contain "trace_id" or "snapshot_id"!');
            return;
        }
        const _url = `${this.prefix}://snapshots${trace_id ? `?trace=${trace_id}` : `/${snapshot_id}`}`;
        logger$3('snapshots').log(_url);
        return this.loadScheme(_url);
    },
    withdrawal: function (params) {
        const _params = this.getQuery(params);
        const _url = `${this.prefix}://withdrawal${_params}`;
        logger$3('withdrawal').log(_url);
        return this.loadScheme(_url);
    },
    address: function (params) {
        const _params = this.getQuery(params);
        const _url = `${this.prefix}://address${_params}`;
        logger$3('address').log(_url);
        return this.loadScheme(_url);
    },
    send: function (params) {
        const data = encodeURIComponent(Base64.encode(typeof params.data === 'string' ? params.data : JSON.stringify(params.data)));
        const _params = this.getQuery(Object.assign(Object.assign({}, params), { data }));
        const _url = `${this.prefix}://send${_params}`;
        logger$3('send').log(_url);
        return this.loadScheme(_url, true);
    },
    users: function (user_id) {
        const _url = `${this.prefix}://users/${user_id}`;
        logger$3('users').log(_url);
        return this.loadScheme(_url);
    },
    apps: function (app_id, params) {
        const _params = this.getQuery(params);
        const _url = `${this.prefix}://apps/${app_id}${_params}`;
        logger$3('apps').log(_url);
        return this.loadScheme(_url);
    },
    conversations: function (conversation_id) {
        const _url = `${this.prefix}://conversations/${conversation_id}`;
        logger$3('conversations').log(_url);
        return this.loadScheme(_url);
    }
};
var scheme = {
    prefix: SCHEME.prefix,
    pay: function (params) {
        if (!params.recipient || !params.asset || !params.amount) {
            logger$3('pay').error('The "recipient", "asset" and "amount" is required!');
            return;
        }
        try {
            if (!params.trace)
                params.trace = uuid();
            if (params.memo) {
                if (isObject(params.memo)) {
                    params.memo = JSON.stringify(params.memo);
                }
                params.memo = Base64.encode(params.memo);
                if (params.memo.length > 140) {
                    logger$3('pay').warn('The memo max length is 140!');
                }
            }
            return {
                url: SCHEME.pay(params),
                params
            };
        }
        catch (err) {
            logger$3('pay').error(err);
        }
    },
    transfer: function (recipient) {
        if (!recipient) {
            logger$3('transfer').error('The "recipient" is required!');
            return;
        }
        try {
            return SCHEME.transfer(recipient);
        }
        catch (err) {
            logger$3('transfer').error(err);
        }
    },
    snapshot: function (params) {
        try {
            return SCHEME.snapshots(params);
        }
        catch (err) {
            logger$3('snapshot').error(err);
        }
    },
    withdrawal: function (params) {
        try {
            if (!params.trace)
                params.trace = uuid();
            if (params.memo) {
                if (isObject(params.memo)) {
                    params.memo = JSON.stringify(params.memo);
                }
                params.memo = Base64.encode(params.memo);
                if (params.memo.length > 140) {
                    logger$3('withdrawal').warn('The memo max length is 140!');
                }
            }
            return {
                url: SCHEME.withdrawal(params),
                params
            };
        }
        catch (err) {
            logger$3('withdrawal').error(err);
        }
    },
    addWithdrawalAddress: function (params) {
        if (!params.asset || !params.label || !params.destination) {
            logger$3('addWithdrawalAddress').error('The "asset", "label" and "destination" is required!');
            return;
        }
        try {
            return SCHEME.address(params);
        }
        catch (err) {
            logger$3('addWithdrawalAddress').error(err);
        }
    },
    delWithdrawalAddress: function (params) {
        if (!params.asset || !params.address) {
            logger$3('delWithdrawalAddress').error('The "asset" and "address" is required!');
            return;
        }
        try {
            return SCHEME.address(Object.assign(Object.assign({}, params), { action: 'delete' }));
        }
        catch (err) {
            logger$3('delWithdrawalAddress').error(err);
        }
    },
    shareText: function (txt) {
        if (!txt) {
            logger$3('shareText').error('The share text is required!');
            return;
        }
        try {
            return SCHEME.send({
                category: 'text',
                data: txt
            });
        }
        catch (err) {
            logger$3('shareText').error(err);
        }
    },
    shareImage: function (url) {
        if (!url) {
            logger$3('shareImage').error('The share image url is required!');
            return;
        }
        try {
            return SCHEME.send({
                category: 'image',
                data: { url }
            });
        }
        catch (err) {
            logger$3('shareImage').error(err);
        }
    },
    shareContact: function (user_id) {
        if (!user_id) {
            logger$3('shareContact').error('The "user_id" is required!');
            return;
        }
        try {
            return SCHEME.send({
                category: 'contact',
                data: { user_id }
            });
        }
        catch (err) {
            logger$3('shareContact').error(err);
        }
    },
    shareCard: function (data) {
        if (!data.action || !data.app_id) {
            logger$3('shareCard').error('The "action" and "app_id" is required!');
            return;
        }
        try {
            return SCHEME.send({
                category: 'app_card',
                data
            });
        }
        catch (err) {
            logger$3('shareCard').error(err);
        }
    },
    shareLive: function (data) {
        if (!data.url) {
            logger$3('shareLive').error('The "url" is required!');
            return;
        }
        try {
            if (!data.height)
                data.height = 720;
            if (!data.width)
                data.width = 1280;
            return SCHEME.send({
                category: 'live',
                data
            });
        }
        catch (err) {
            logger$3('shareLive').error(err);
        }
    },
    sharePost: function (content) {
        if (!content) {
            logger$3('sharePost').error('The share content is required!');
            return;
        }
        try {
            return SCHEME.send({
                category: 'post',
                data: content
            });
        }
        catch (err) {
            logger$3('sharePost').error(err);
        }
    },
    popupUser: function (user_id) {
        if (!user_id) {
            logger$3('popupUser').error('The "user_id" is required!');
            return;
        }
        try {
            return SCHEME.users(user_id);
        }
        catch (err) {
            logger$3('popupUser').error(err);
        }
    },
    popupBot: function (params) {
        const { app_id } = params, rest = __rest(params, ["app_id"]);
        if (!app_id) {
            logger$3('popupBot').error('The "app_id" is required!');
            return;
        }
        try {
            return SCHEME.apps(app_id, rest);
        }
        catch (err) {
            logger$3('popupBot').error(err);
        }
    },
    conversation: function (conversation_id) {
        if (!conversation_id) {
            logger$3('conversation').error('The "conversation_id" is required!');
            return;
        }
        try {
            return SCHEME.conversations(conversation_id);
        }
        catch (err) {
            logger$3('conversation').error(err);
        }
    }
};const SUPPORT_APIS = {
    address_add: false,
    address_del: false,
    conversation: false,
    getContext: false,
    getUserInfo: true,
    login: true,
    logout: true,
    payment: false,
    playlist: false,
    popup_user: false,
    popup_bot: false,
    reloadTheme: false,
    requestToken: true,
    share_text: false,
    share_image: false,
    share_contact: false,
    share_app_card: false,
    share_live: false,
    share_post: false,
    showToast: false,
    snapshot: false,
    transfer: false,
    withdrawal: false,
};
class Bridge {
    constructor(config) {
        const { debug, logLevel } = config || {};
        if (debug !== void 0)
            logger.setDebug(debug);
        if (logLevel !== void 0)
            logger.setLevel(logLevel);
        this.config = config;
        this._token = void 0;
        this._userInfo = void 0;
        this.logger = getLogger();
        // public
        this.getContext = this.getContext.bind(this);
        this.reloadTheme = this.reloadTheme.bind(this);
        this.playlist = this.playlist.bind(this);
        this.login = this.login.bind(this);
        this.logout = this.logout.bind(this);
        this.requestToken = this.requestToken.bind(this);
        this.getUserInfo = this.getUserInfo.bind(this);
        // private
        this.getCode = this.getCode.bind(this);
        this.handlerError = this.handlerError.bind(this);
    }
    /**
     * get the app version
     */
    get version() {
        let app;
        try {
            app = this.getContext();
        }
        catch (err) {
            this.logger('version').info(err);
        }
        return app === null || app === void 0 ? void 0 : app.app_version;
    }
    /**
     * get the code which be used to get access-token
     */
    get code() {
        return this.getCode();
    }
    /**
     * get the code-verifier which be used to get access-token
     */
    get codeVerifier() {
        return store.get('$_mixin-code-verifier');
    }
    /**
     * get conversation id
     */
    get conversationId() {
        var _a, _b;
        return (_b = (_a = this.getContext()) === null || _a === void 0 ? void 0 : _a.conversation_id) !== null && _b !== void 0 ? _b : void 0;
    }
    /**
     * get API support info
     */
    get supportAPIs() {
        const res = Object.assign({}, SUPPORT_APIS);
        if (this.isMixin) {
            const featVersion = {
                mixin: {
                    address_add: 0,
                    address_del: 0,
                    conversation: 311,
                    getContext: 0,
                    getUserInfo: 0,
                    login: 0,
                    logout: 0,
                    payment: 0,
                    playlist: 300,
                    popup_user: 0,
                    popup_bot: 290,
                    reloadTheme: 0,
                    requestToken: 0,
                    share_text: 0,
                    share_image: 0,
                    share_contact: 0,
                    share_app_card: 0,
                    share_live: 0,
                    share_post: 0,
                    showToast: 0,
                    snapshot: 0,
                    transfer: 0,
                    withdrawal: 0
                },
                reborn: {
                    address_add: 0,
                    address_del: 0,
                    conversation: 1121,
                    getContext: 0,
                    getUserInfo: 0,
                    login: 0,
                    logout: 0,
                    payment: 0,
                    playlist: 1100,
                    popup_user: 0,
                    popup_bot: 1100,
                    reloadTheme: 0,
                    requestToken: 0,
                    share_text: 0,
                    share_image: 0,
                    share_contact: 0,
                    share_app_card: 0,
                    share_live: 0,
                    share_post: 0,
                    showToast: 0,
                    snapshot: 0,
                    transfer: 0,
                    withdrawal: 0
                }
            };
            const verNum = +this.version.split('.').join('');
            const featList = featVersion[this.isReborn ? 'reborn' : 'mixin'];
            Object.keys(featList).forEach(feat => {
                res[feat] = verNum >= featList[feat];
            });
        }
        return res;
    }
    /**
     * judgement whether or not in mixin or reborn app
     */
    get isMixin() {
        var _a, _b, _c;
        const isIOS = env().isIOS;
        return !!(isIOS
            ? (_b = (_a = window === null || window === void 0 ? void 0 : window.webkit) === null || _a === void 0 ? void 0 : _a.messageHandlers) === null || _b === void 0 ? void 0 : _b.MixinContext : (window === null || window === void 0 ? void 0 : window.MixinContext) && typeof ((_c = window === null || window === void 0 ? void 0 : window.MixinContext) === null || _c === void 0 ? void 0 : _c.getContext) === 'function');
    }
    /**
     * judgement whether or not in reborn app
     */
    get isReborn() {
        return /XUEXI/.test(navigator.userAgent);
    }
    /**
   * get access token
   */
    get token() {
        var _a;
        return (_a = this._token) !== null && _a !== void 0 ? _a : store.get('$_mixin-token');
    }
    /**
     * get mixin app context
     */
    getContext() {
        if (!this.isMixin) {
            this.logger('getContext').log('Please call in reborn or mixin app!');
            return;
        }
        try {
            let ctx = messager('getContext')();
            if (typeof ctx === 'string') {
                try {
                    ctx = JSON.parse(ctx);
                }
                catch (err) {
                    this.logger('getContext').info(err);
                }
            }
            if (ctx)
                ctx.platform = (ctx === null || ctx === void 0 ? void 0 : ctx.platform) || (env().isIOS ? 'iOS' : 'Android');
            return ctx;
        }
        catch (err) {
            this.handlerError(err, 'getContext');
            return;
        }
    }
    /**
     * reload the theme according to theme-color
     */
    reloadTheme() {
        if (!this.isMixin) {
            this.logger('reloadTheme').log('Please call in reborn or mixin app!');
            return;
        }
        try {
            const reloadTheme = messager('reloadTheme');
            env().isIOS ? reloadTheme('') : reloadTheme();
        }
        catch (err) {
            this.handlerError(err, 'reloadTheme');
        }
    }
    /**
     * call native message window
     * Android Only
     */
    showToast(msg) {
        if (!this.isMixin) {
            this.logger('showToast').log('Please call in reborn or mixin app!');
            return;
        }
        try {
            messager('showToast')(msg);
        }
        catch (err) {
            this.handlerError(err, 'showToast');
        }
    }
    /**
     * play audio by mixin native player
     */
    playlist(src) {
        if (!this.isMixin) {
            this.logger('playlist').log('Please call in reborn or mixin app!');
            return;
        }
        try {
            messager('playlist')(src);
        }
        catch (err) {
            this.handlerError(err, 'playlist');
        }
    }
    /**
     * go login page
     * @type { phone?: boolean | number; profile?: boolean | number; contacts?: boolean | number; assets?: boolean | number; snapshots?: boolean | number; messages?: boolean | number; code_challenge?: boolean; } AUTH
     */
    login(auth, params) {
        const { client_id } = this.config || {};
        const cid = (params === null || params === void 0 ? void 0 : params.client_id) || client_id;
        if (!cid) {
            this.logger('login').warn('Please pass client_id first!');
            return;
        }
        getAccessCode(Object.assign(Object.assign({}, params), { client_id: cid, auth }));
    }
    /**
     * do logout
     * @param reload whether reload the page
     */
    logout(reload = true) {
        store.clear('$_mixin-token');
        store.clear('$_mixin-code-verifier');
        store.clear('$_mixin-user-info');
        if (reload)
            window.location.reload();
    }
    /**
     * request access-token by code
     * @param params request params
     * @param persistence whether persist the code
     * @returns
     */
    requestToken(params, persistence = true) {
        const { client_id: client_id_config } = this.config || {};
        const { code: code_params, code_verifier: code_verifier_params, client_id: client_id_params } = params || {};
        const client_id = client_id_params || client_id_config;
        const code = code_params || this.getCode();
        const code_verifier = code_verifier_params || store.get('$_mixin-code-verifier');
        if (!client_id || !code_verifier || !code) {
            this.logger('requestToken').warn('The request parameters which contain client_id, access_code and code_verifier is not correct!');
            return Promise.resolve(null);
        }
        return new Promise((resolve, reject) => {
            getAccessToken({
                code,
                code_verifier,
                client_id
            })
                .then(token => {
                this._token = token;
                if (persistence)
                    store.set('$_mixin-token', token);
                resolve(token);
            })
                .catch(err => {
                this.handlerError(err, 'requestToken', 'get token failed!');
                reject(err);
            });
        });
    }
    /**
     * get user infomations by request https://api.mixin.one/me API
     */
    getUserInfo(token) {
        var _a, _b;
        if (token === void 0) { token = (_a = this.token) !== null && _a !== void 0 ? _a : ''; }
        if (!token) {
            this.logger('getUserInfo').warn('The access_token is invalid!');
            return Promise.resolve(null);
        }
        try {
            const cache = store.get('$_mixin-user-info');
            const userInfo = ((_b = this._userInfo) !== null && _b !== void 0 ? _b : cache) ? JSON.parse(cache) : '';
            if (userInfo) {
                this.logger('getUserInfo').log('through cache!');
                return Promise.resolve(userInfo);
            }
        }
        catch (err) {
            this.logger('getUserInfo').info(err);
        }
        this.logger('getUserInfo').log('http request!');
        return request({
            url: 'https://api.mixin.one/me',
            method: 'GET',
            headers: {
                'Content-Type': 'application/json',
                Authorization: `Bearer ${token}`
            },
            withCredentials: false
        }).then(res => {
            const data = res.data;
            if (data) {
                this._userInfo = data;
                store.set('$_mixin-user-info', JSON.stringify(data));
            }
            return data;
        });
    }
    /**
     * evoke payment checkout by generate pay scheme-url
     * @type { recipient: string; asset: string; amount: string; trace?: string; memo?: string | Record<string, string>; } PARAMS_PAYMENT
     */
    payment(params) {
        return scheme.pay(params);
    }
    /**
     * evoke transfer checkout by generate pay scheme-url
     * @param recipient recipient id
     */
    transfer(recipient) {
        return scheme.transfer(recipient);
    }
    /**
     * evoke transfer detail by generate snapshots scheme-url
     * @type { trace_id?: string; snapshot_id?: string; } PARAMS_SNAPSHOTS
     */
    snapshot(params) {
        return scheme.snapshot(params);
    }
    /**
     * evoke withdrawal of an asset by generate withdrawal scheme-url
     * @type { address: string; asset: string; amount: string; trace?: string; memo?: string | Record<string, string>; } PARAMS_WITHDRAWAL
     */
    withdrawal(params) {
        return scheme.withdrawal(params);
    }
    address(type, params) {
        switch (type) {
            case 'add':
                return scheme.addWithdrawalAddress(params);
            case 'del':
                return scheme.delWithdrawalAddress(params);
        }
    }
    share(category, params) {
        let shareAction;
        switch (category) {
            case 'text':
                shareAction = scheme.shareText;
                break;
            case 'post':
                shareAction = scheme.sharePost;
                break;
            case 'live':
                shareAction = scheme.shareLive;
                break;
            case 'image':
                shareAction = scheme.shareImage;
                break;
            case 'app_card':
                shareAction = scheme.shareCard;
                break;
            case 'contact':
                shareAction = scheme.shareContact;
                break;
        }
        return shareAction === null || shareAction === void 0 ? void 0 : shareAction(params);
    }
    popup(type, params) {
        switch (type) {
            case 'user':
                return scheme.popupUser(params);
            case 'bot':
                return scheme.popupBot(params);
        }
    }
    /**
     * evoke conversation by generate conversations scheme-url
     * @param recipient conversation id
     */
    conversation(conversation_id) {
        return scheme.conversation(conversation_id);
    }
    getCode() {
        var _a, _b, _c;
        const parseData = parseUrl(window.location.href);
        if (typeof parseData !== 'string') {
            const { hash, search } = parseData;
            const regExp = /code=([^&#]*)/g;
            const code = (_b = (_a = regExp.exec(search)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : (_c = regExp.exec(hash)) === null || _c === void 0 ? void 0 : _c[1];
            return code;
        }
    }
    handlerError(err, prefix = '', msg = 'oops! some error has ocurred!') {
        let { 
        // eslint-disable-next-line prefer-const
        message = '', stack = '', name = '' } = parseError(err);
        if (name)
            name = `(${name}): `;
        if (stack)
            stack = ` at ${stack}`;
        this.logger(prefix).error(`👇 ${msg} ❌`, '\n', name, message, stack);
    }
}export default Bridge;export{Bridge};