bundle-polkadot-hw-ledger.js

(function (global, factory) {
	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@polkadot/util')) :
	typeof define === 'function' && define.amd ? define(['exports', '@polkadot/util'], factory) :
	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.polkadotHwLedger = {}, global.polkadotUtil));
})(this, (function (exports, util$1) { 'use strict';

	const global = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : window;

	var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
	var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};

	function getDefaultExportFromCjs (x) {
		return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
	}

	function getAugmentedNamespace(n) {
	  if (n.__esModule) return n;
	  var f = n.default;
		if (typeof f == "function") {
			var a = function a () {
				if (this instanceof a) {
	        return Reflect.construct(f, arguments, this.constructor);
				}
				return f.apply(this, arguments);
			};
			a.prototype = f.prototype;
	  } else a = {};
	  Object.defineProperty(a, '__esModule', {value: true});
		Object.keys(n).forEach(function (k) {
			var d = Object.getOwnPropertyDescriptor(n, k);
			Object.defineProperty(a, k, d.get ? d : {
				enumerable: true,
				get: function () {
					return n[k];
				}
			});
		});
		return a;
	}

	var dist = {};

	var legacy_apps = {};

	var supported_apps = {};

	var substrate_app = {};

	var common = {};

	(function (exports) {
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.getVersion = exports.processErrorResponse = exports.errorCodeToString = exports.ERROR_DESCRIPTION = exports.CHUNK_SIZE = void 0;
		exports.CHUNK_SIZE = 250;
		exports.ERROR_DESCRIPTION = {
		    1: "U2F: Unknown",
		    2: "U2F: Bad request",
		    3: "U2F: Configuration unsupported",
		    4: "U2F: Device Ineligible",
		    5: "U2F: Timeout",
		    14: "Timeout",
		    0x9000: "No errors",
		    0x9001: "Device is busy",
		    0x6802: "Error deriving keys",
		    0x6400: "Execution Error",
		    0x6700: "Wrong Length",
		    0x6982: "Empty Buffer",
		    0x6983: "Output buffer too small",
		    0x6984: "Data is invalid",
		    0x6985: "Conditions not satisfied",
		    0x6986: "Transaction rejected",
		    0x6a80: "Bad key handle",
		    0x6b00: "Invalid P1/P2",
		    0x6d00: "Instruction not supported",
		    0x6e01: "App does not seem to be open",
		    0x6f00: "Unknown error",
		    0x6f01: "Sign/verify error",
		};
		function errorCodeToString(statusCode) {
		    if (statusCode in exports.ERROR_DESCRIPTION)
		        return exports.ERROR_DESCRIPTION[statusCode];
		    return `Unknown Status Code: ${statusCode}`;
		}
		exports.errorCodeToString = errorCodeToString;
		function isDict(v) {
		    return typeof v === "object" && v !== null && !(v instanceof Array) && !(v instanceof Date);
		}
		function processErrorResponse(response) {
		    if (response != null) {
		        if (isDict(response)) {
		            if (Object.prototype.hasOwnProperty.call(response, "statusCode")) {
		                return {
		                    return_code: response.statusCode,
		                    error_message: errorCodeToString(response.statusCode),
		                };
		            }
		            if (Object.prototype.hasOwnProperty.call(response, "return_code") &&
		                Object.prototype.hasOwnProperty.call(response, "error_message")) {
		                return response;
		            }
		        }
		        return {
		            return_code: 0xffff,
		            error_message: response.toString(),
		        };
		    }
		    return {
		        return_code: 0xffff,
		        error_message: response.toString(),
		    };
		}
		exports.processErrorResponse = processErrorResponse;
		async function getVersion(transport, cla) {
		    return await transport.send(cla, 0 , 0, 0).then((response) => {
		        const errorCodeData = response.subarray(-2);
		        const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
		        if (response.length !== 14) {
		            return {
		                return_code: 0x6984,
		                error_message: errorCodeToString(0x6984),
		            };
		        }
		        const major = response[1] * 256 + response[2];
		        const minor = response[3] * 256 + response[4];
		        const patch = response[5] * 256 + response[6];
		        const deviceLocked = response[7] === 1;
		        const targetId = (response[8] << 24) + (response[9] << 16) + (response[10] << 8) + (response[11] << 0);
		        return {
		            return_code: returnCode,
		            error_message: errorCodeToString(returnCode),
		            test_mode: response[0] !== 0,
		            major,
		            minor,
		            patch,
		            deviceLocked,
		            target_id: targetId.toString(16),
		        };
		    }, processErrorResponse);
		}
		exports.getVersion = getVersion;
	} (common));
	getDefaultExportFromCjs(common);

	Object.defineProperty(substrate_app, "__esModule", { value: true });
	substrate_app.SubstrateApp = void 0;
	const common_1 = common;
	class SubstrateApp {
	    constructor(transport, cla, slip0044) {
	        if (transport == null) {
	            throw new Error("Transport has not been defined");
	        }
	        this.transport = transport;
	        this.cla = cla;
	        this.slip0044 = slip0044;
	    }
	    static serializePath(slip0044, account, change, addressIndex) {
	        if (!Number.isInteger(account))
	            throw new Error("Input must be an integer");
	        if (!Number.isInteger(change))
	            throw new Error("Input must be an integer");
	        if (!Number.isInteger(addressIndex))
	            throw new Error("Input must be an integer");
	        const buf = Buffer.alloc(20);
	        buf.writeUInt32LE(0x8000002c, 0);
	        buf.writeUInt32LE(slip0044, 4);
	        buf.writeUInt32LE(account, 8);
	        buf.writeUInt32LE(change, 12);
	        buf.writeUInt32LE(addressIndex, 16);
	        return buf;
	    }
	    static GetChunks(message) {
	        const chunks = [];
	        const buffer = Buffer.from(message);
	        for (let i = 0; i < buffer.length; i += common_1.CHUNK_SIZE) {
	            let end = i + common_1.CHUNK_SIZE;
	            if (i > buffer.length) {
	                end = buffer.length;
	            }
	            chunks.push(buffer.subarray(i, end));
	        }
	        return chunks;
	    }
	    static signGetChunks(slip0044, account, change, addressIndex, message) {
	        const chunks = [];
	        const bip44Path = SubstrateApp.serializePath(slip0044, account, change, addressIndex);
	        chunks.push(bip44Path);
	        chunks.push(...SubstrateApp.GetChunks(message));
	        return chunks;
	    }
	    async getVersion() {
	        try {
	            return await (0, common_1.getVersion)(this.transport, this.cla);
	        }
	        catch (e) {
	            return (0, common_1.processErrorResponse)(e);
	        }
	    }
	    async appInfo() {
	        return await this.transport.send(0xb0, 0x01, 0, 0).then((response) => {
	            const errorCodeData = response.subarray(-2);
	            const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
	            let appName = "";
	            let appVersion = "";
	            let flagLen = 0;
	            let flagsValue = 0;
	            if (response[0] !== 1) {
	                return {
	                    return_code: 0x9001,
	                    error_message: "response format ID not recognized",
	                };
	            }
	            else {
	                const appNameLen = response[1];
	                appName = response.subarray(2, 2 + appNameLen).toString("ascii");
	                let idx = 2 + appNameLen;
	                const appVersionLen = response[idx];
	                idx += 1;
	                appVersion = response.subarray(idx, idx + appVersionLen).toString("ascii");
	                idx += appVersionLen;
	                const appFlagsLen = response[idx];
	                idx += 1;
	                flagLen = appFlagsLen;
	                flagsValue = response[idx];
	            }
	            return {
	                return_code: returnCode,
	                error_message: (0, common_1.errorCodeToString)(returnCode),
	                appName: appName === "" || "err",
	                appVersion: appVersion === "" || "err",
	                flagLen,
	                flagsValue,
	                flag_recovery: (flagsValue & 1) !== 0,
	                flag_signed_mcu_code: (flagsValue & 2) !== 0,
	                flag_onboarded: (flagsValue & 4) !== 0,
	                flag_pin_validated: (flagsValue & 128) !== 0,
	            };
	        }, common_1.processErrorResponse);
	    }
	    async getAddress(account, change, addressIndex, requireConfirmation = false, scheme = 0 ) {
	        const bip44Path = SubstrateApp.serializePath(this.slip0044, account, change, addressIndex);
	        let p1 = 0;
	        if (requireConfirmation)
	            p1 = 1;
	        let p2 = 0;
	        if (!isNaN(scheme))
	            p2 = scheme;
	        return await this.transport.send(this.cla, 1 , p1, p2, bip44Path).then((response) => {
	            const errorCodeData = response.subarray(-2);
	            const errorCode = errorCodeData[0] * 256 + errorCodeData[1];
	            return {
	                pubKey: response.subarray(0, 32).toString("hex"),
	                address: response.subarray(32, response.length - 2).toString("ascii"),
	                return_code: errorCode,
	                error_message: (0, common_1.errorCodeToString)(errorCode),
	            };
	        }, common_1.processErrorResponse);
	    }
	    async signSendChunk(chunkIdx, chunkNum, chunk, scheme = 0 , ins = 2 ) {
	        let payloadType = 1 ;
	        if (chunkIdx === 1) {
	            payloadType = 0 ;
	        }
	        if (chunkIdx === chunkNum) {
	            payloadType = 2 ;
	        }
	        let p2 = 0;
	        if (!isNaN(scheme))
	            p2 = scheme;
	        return await this.transport
	            .send(this.cla, ins, payloadType, p2, chunk, [36864 , 0x6984, 0x6a80])
	            .then((response) => {
	            const errorCodeData = response.subarray(-2);
	            const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
	            let errorMessage = (0, common_1.errorCodeToString)(returnCode);
	            let signature = null;
	            if (returnCode === 0x6a80 || returnCode === 0x6984) {
	                errorMessage = response.subarray(0, response.length - 2).toString("ascii");
	            }
	            else if (response.length > 2) {
	                signature = response.subarray(0, response.length - 2);
	            }
	            return {
	                signature,
	                return_code: returnCode,
	                error_message: errorMessage,
	            };
	        }, common_1.processErrorResponse);
	    }
	    async signImpl(account, change, addressIndex, message, ins, scheme = 0 ) {
	        const chunks = SubstrateApp.signGetChunks(this.slip0044, account, change, addressIndex, message);
	        return await this.signSendChunk(1, chunks.length, chunks[0], scheme, ins).then(async () => {
	            let result;
	            for (let i = 1; i < chunks.length; i += 1) {
	                result = await this.signSendChunk(1 + i, chunks.length, chunks[i], scheme, ins);
	                if (result.return_code !== 36864 ) {
	                    break;
	                }
	            }
	            return {
	                return_code: result.return_code,
	                error_message: result.error_message,
	                signature: result.signature,
	            };
	        }, common_1.processErrorResponse);
	    }
	    async sign(account, change, addressIndex, message, scheme = 0 ) {
	        return await this.signImpl(account, change, addressIndex, message, 2 , scheme);
	    }
	    async signRaw(account, change, addressIndex, message, scheme = 0 ) {
	        return await this.signImpl(account, change, addressIndex, message, 3 , scheme);
	    }
	    async getAllowlistPubKey() {
	        return await this.transport.send(this.cla, 144 , 0, 0).then((response) => {
	            const errorCodeData = response.subarray(-2);
	            const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
	            console.log(response);
	            const pubkey = response.subarray(0, 32);
	            if (response.length !== 34) {
	                return {
	                    return_code: 0x6984,
	                    error_message: (0, common_1.errorCodeToString)(0x6984),
	                };
	            }
	            return {
	                return_code: returnCode,
	                error_message: (0, common_1.errorCodeToString)(returnCode),
	                pubkey,
	            };
	        }, common_1.processErrorResponse);
	    }
	    async setAllowlistPubKey(pk) {
	        return await this.transport.send(this.cla, 145 , 0, 0, pk).then((response) => {
	            const errorCodeData = response.subarray(-2);
	            const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
	            return {
	                return_code: returnCode,
	                error_message: (0, common_1.errorCodeToString)(returnCode),
	            };
	        }, common_1.processErrorResponse);
	    }
	    async getAllowlistHash() {
	        return await this.transport.send(this.cla, 146 , 0, 0).then((response) => {
	            const errorCodeData = response.subarray(-2);
	            const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
	            console.log(response);
	            const hash = response.subarray(0, 32);
	            if (response.length !== 34) {
	                return {
	                    return_code: 0x6984,
	                    error_message: (0, common_1.errorCodeToString)(0x6984),
	                };
	            }
	            return {
	                return_code: returnCode,
	                error_message: (0, common_1.errorCodeToString)(returnCode),
	                hash,
	            };
	        }, common_1.processErrorResponse);
	    }
	    async uploadSendChunk(chunkIdx, chunkNum, chunk) {
	        let payloadType = 1 ;
	        if (chunkIdx === 1) {
	            payloadType = 0 ;
	        }
	        if (chunkIdx === chunkNum) {
	            payloadType = 2 ;
	        }
	        return await this.transport
	            .send(this.cla, 147 , payloadType, 0, chunk, [36864 ])
	            .then((response) => {
	            const errorCodeData = response.subarray(-2);
	            const returnCode = errorCodeData[0] * 256 + errorCodeData[1];
	            const errorMessage = (0, common_1.errorCodeToString)(returnCode);
	            return {
	                return_code: returnCode,
	                error_message: errorMessage,
	            };
	        }, common_1.processErrorResponse);
	    }
	    async uploadAllowlist(message) {
	        const chunks = [];
	        chunks.push(Buffer.from([0]));
	        chunks.push(...SubstrateApp.GetChunks(message));
	        return await this.uploadSendChunk(1, chunks.length, chunks[0]).then(async (result) => {
	            if (result.return_code !== 36864 ) {
	                return {
	                    return_code: result.return_code,
	                    error_message: result.error_message,
	                };
	            }
	            for (let i = 1; i < chunks.length; i += 1) {
	                result = await this.uploadSendChunk(1 + i, chunks.length, chunks[i]);
	                if (result.return_code !== 36864 ) {
	                    break;
	                }
	            }
	            return {
	                return_code: result.return_code,
	                error_message: result.error_message,
	            };
	        }, common_1.processErrorResponse);
	    }
	}
	substrate_app.SubstrateApp = SubstrateApp;

	(function (exports) {
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.supportedApps = exports.getAppParams = exports.newSubstrateApp = void 0;
		const substrate_app_1 = substrate_app;
		function newSubstrateApp(transport, chainName) {
		    const requestedApp = exports.supportedApps.find((app) => {
		        return app.name.toLowerCase() === chainName.toLowerCase();
		    });
		    if (requestedApp != null) {
		        return new substrate_app_1.SubstrateApp(transport, requestedApp.cla, requestedApp.slip0044);
		    }
		    throw new Error(`Error: ${chainName} not supported`);
		}
		exports.newSubstrateApp = newSubstrateApp;
		function getAppParams(chainName) {
		    const params = exports.supportedApps.find((app) => {
		        return app.name.toLowerCase() === chainName.toLowerCase();
		    });
		    return params;
		}
		exports.getAppParams = getAppParams;
		exports.supportedApps = [
		    {
		        name: "Polkadot",
		        cla: 0x90,
		        slip0044: 0x80000162,
		        ss58_addr_type: 0,
		    },
		    {
		        name: "Polymesh",
		        cla: 0x91,
		        slip0044: 0x80000253,
		        ss58_addr_type: 12,
		    },
		    {
		        name: "Dock",
		        cla: 0x92,
		        slip0044: 0x80000252,
		        ss58_addr_type: 22,
		    },
		    {
		        name: "Centrifuge",
		        cla: 0x93,
		        slip0044: 0x800002eb,
		        ss58_addr_type: 36,
		    },
		    {
		        name: "Edgeware",
		        cla: 0x94,
		        slip0044: 0x8000020b,
		        ss58_addr_type: 7,
		    },
		    {
		        name: "Equilibrium",
		        cla: 0x95,
		        slip0044: 0x85f5e0fd,
		        ss58_addr_type: 67,
		    },
		    {
		        name: "Statemint",
		        cla: 0x96,
		        slip0044: 0x80000162,
		        ss58_addr_type: 0,
		    },
		    {
		        name: "Statemine",
		        cla: 0x97,
		        slip0044: 0x800001b2,
		        ss58_addr_type: 2,
		    },
		    {
		        name: "Nodle",
		        cla: 0x98,
		        slip0044: 0x800003eb,
		        ss58_addr_type: 37,
		    },
		    {
		        name: "Kusama",
		        cla: 0x99,
		        slip0044: 0x800001b2,
		        ss58_addr_type: 2,
		    },
		    {
		        name: "Karura",
		        cla: 0x9a,
		        slip0044: 0x800002ae,
		        ss58_addr_type: 8,
		    },
		    {
		        name: "Acala",
		        cla: 0x9b,
		        slip0044: 0x80000313,
		        ss58_addr_type: 10,
		    },
		    {
		        name: "VTB",
		        cla: 0x9c,
		        slip0044: 0x800002b6,
		        ss58_addr_type: 42,
		    },
		    {
		        name: "Peer",
		        cla: 0x9d,
		        slip0044: 0x800002ce,
		        ss58_addr_type: 42,
		    },
		    {
		        name: "Genshiro",
		        cla: 0x9e,
		        slip0044: 0x85f5e0fc,
		        ss58_addr_type: 67,
		    },
		    {
		        name: "Sora",
		        cla: 0x9f,
		        slip0044: 0x80000269,
		        ss58_addr_type: 69,
		    },
		    {
		        name: "Polkadex",
		        cla: 0xa0,
		        slip0044: 0x8000031f,
		        ss58_addr_type: 88,
		    },
		    {
		        name: "Bifrost",
		        cla: 0xa1,
		        slip0044: 0x80000314,
		        ss58_addr_type: 6,
		    },
		    {
		        name: "Reef",
		        cla: 0xa2,
		        slip0044: 0x80000333,
		        ss58_addr_type: 42,
		    },
		    {
		        name: "XXNetwork",
		        cla: 0xa3,
		        slip0044: 0x800007a3,
		        ss58_addr_type: 55,
		    },
		    {
		        name: "AlephZero",
		        cla: 0xa4,
		        slip0044: 0x80000283,
		        ss58_addr_type: 42,
		    },
		    {
		        name: "Interlay",
		        cla: 0xa5,
		        slip0044: 0x80000162,
		        ss58_addr_type: 2032,
		    },
		    {
		        name: "Parallel",
		        cla: 0xa6,
		        slip0044: 0x80000162,
		        ss58_addr_type: 172,
		    },
		    {
		        name: "Picasso",
		        cla: 0xa7,
		        slip0044: 0x800001b2,
		        ss58_addr_type: 49,
		    },
		    {
		        name: "Composable",
		        cla: 0xa8,
		        slip0044: 0x80000162,
		        ss58_addr_type: 49,
		    },
		    {
		        name: "Astar",
		        cla: 0xa9,
		        slip0044: 0x8000032a,
		        ss58_addr_type: 5,
		    },
		    {
		        name: "OriginTrail",
		        cla: 0xaa,
		        slip0044: 0x80000162,
		        ss58_addr_type: 101,
		    },
		    {
		        name: "HydraDX",
		        cla: 0xab,
		        slip0044: 0x80000162,
		        ss58_addr_type: 63,
		    },
		    {
		        name: "Stafi",
		        cla: 0xac,
		        slip0044: 0x8000038b,
		        ss58_addr_type: 20,
		    },
		    {
		        name: "Unique",
		        cla: 0xad,
		        slip0044: 0x80000295,
		        ss58_addr_type: 7391,
		    },
		    {
		        name: "BifrostKusama",
		        cla: 0xae,
		        slip0044: 0x80000314,
		        ss58_addr_type: 6,
		    },
		    {
		        name: "Phala",
		        cla: 0xaf,
		        slip0044: 0x80000162,
		        ss58_addr_type: 30,
		    },
		    {
		        name: "Khala",
		        cla: 0xb1,
		        slip0044: 0x800001b2,
		        ss58_addr_type: 30,
		    },
		    {
		        name: "Darwinia",
		        cla: 0xb2,
		        slip0044: 0x80000162,
		        ss58_addr_type: 18,
		    },
		    {
		        name: "Ajuna",
		        cla: 0xb3,
		        slip0044: 0x80000162,
		        ss58_addr_type: 1328,
		    },
		    {
		        name: "Bittensor",
		        cla: 0xb4,
		        slip0044: 0x800003ed,
		        ss58_addr_type: 42,
		    },
		    {
		        name: "Ternoa",
		        cla: 0xb5,
		        slip0044: 0x800003e3,
		        ss58_addr_type: 42,
		    },
		    {
		        name: "Pendulum",
		        cla: 0xb6,
		        slip0044: 0x80000162,
		        ss58_addr_type: 56,
		    },
		    {
		        name: "Zeitgeist",
		        cla: 0xb7,
		        slip0044: 0x80000162,
		        ss58_addr_type: 73,
		    },
		    {
		        name: "Joystream",
		        cla: 0xb8,
		        slip0044: 0x80000219,
		        ss58_addr_type: 126,
		    },
		    {
		        name: "Enjin",
		        cla: 0xb9,
		        slip0044: 0x80000483,
		        ss58_addr_type: 2135,
		    },
		    {
		        name: "Matrixchain",
		        cla: 0xba,
		        slip0044: 0x80000483,
		        ss58_addr_type: 1110,
		    },
		    {
		        name: "Quartz",
		        cla: 0xbb,
		        slip0044: 0x80000277,
		        ss58_addr_type: 255,
		    }
		];
	} (supported_apps));
	getDefaultExportFromCjs(supported_apps);

	Object.defineProperty(legacy_apps, "__esModule", { value: true });
	legacy_apps.newBifrostKusamaApp = legacy_apps.newUniqueApp = legacy_apps.newInterlayApp = legacy_apps.newAlephZeroApp = legacy_apps.newStafiApp = legacy_apps.newComposableApp = legacy_apps.newAstarApp = legacy_apps.newParallelApp = legacy_apps.newXXNetworkApp = legacy_apps.newAcalaApp = legacy_apps.newReefApp = legacy_apps.newKaruraApp = legacy_apps.newBifrostApp = legacy_apps.newPolkadexApp = legacy_apps.newSoraApp = legacy_apps.newNodleApp = legacy_apps.newStatemineApp = legacy_apps.newStatemintApp = legacy_apps.newGenshiroApp = legacy_apps.newEquilibriumApp = legacy_apps.newEdgewareApp = legacy_apps.newCentrifugeApp = legacy_apps.newDockApp = legacy_apps.newPolymeshApp = legacy_apps.newPolkadotApp = legacy_apps.newKusamaApp = void 0;
	const supported_apps_1 = supported_apps;
	function newKusamaApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Kusama");
	}
	legacy_apps.newKusamaApp = newKusamaApp;
	function newPolkadotApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Polkadot");
	}
	legacy_apps.newPolkadotApp = newPolkadotApp;
	function newPolymeshApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Polymesh");
	}
	legacy_apps.newPolymeshApp = newPolymeshApp;
	function newDockApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Dock");
	}
	legacy_apps.newDockApp = newDockApp;
	function newCentrifugeApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Centrifuge");
	}
	legacy_apps.newCentrifugeApp = newCentrifugeApp;
	function newEdgewareApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Edgeware");
	}
	legacy_apps.newEdgewareApp = newEdgewareApp;
	function newEquilibriumApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Equilibrium");
	}
	legacy_apps.newEquilibriumApp = newEquilibriumApp;
	function newGenshiroApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Genshiro");
	}
	legacy_apps.newGenshiroApp = newGenshiroApp;
	function newStatemintApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Statemint");
	}
	legacy_apps.newStatemintApp = newStatemintApp;
	function newStatemineApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Statemine");
	}
	legacy_apps.newStatemineApp = newStatemineApp;
	function newNodleApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Nodle");
	}
	legacy_apps.newNodleApp = newNodleApp;
	function newSoraApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Sora");
	}
	legacy_apps.newSoraApp = newSoraApp;
	function newPolkadexApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Polkadex");
	}
	legacy_apps.newPolkadexApp = newPolkadexApp;
	function newBifrostApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Bifrost");
	}
	legacy_apps.newBifrostApp = newBifrostApp;
	function newKaruraApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Karura");
	}
	legacy_apps.newKaruraApp = newKaruraApp;
	function newReefApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Reef");
	}
	legacy_apps.newReefApp = newReefApp;
	function newAcalaApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Acala");
	}
	legacy_apps.newAcalaApp = newAcalaApp;
	function newXXNetworkApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "XXNetwork");
	}
	legacy_apps.newXXNetworkApp = newXXNetworkApp;
	function newParallelApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Parallel");
	}
	legacy_apps.newParallelApp = newParallelApp;
	function newAstarApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Astar");
	}
	legacy_apps.newAstarApp = newAstarApp;
	function newComposableApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Composable");
	}
	legacy_apps.newComposableApp = newComposableApp;
	function newStafiApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Stafi");
	}
	legacy_apps.newStafiApp = newStafiApp;
	function newAlephZeroApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "AlephZero");
	}
	legacy_apps.newAlephZeroApp = newAlephZeroApp;
	function newInterlayApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Interlay");
	}
	legacy_apps.newInterlayApp = newInterlayApp;
	function newUniqueApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "Unique");
	}
	legacy_apps.newUniqueApp = newUniqueApp;
	function newBifrostKusamaApp(transport) {
	    return (0, supported_apps_1.newSubstrateApp)(transport, "BifrostKusama");
	}
	legacy_apps.newBifrostKusamaApp = newBifrostKusamaApp;

	(function (exports) {
		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
		    if (k2 === undefined) k2 = k;
		    var desc = Object.getOwnPropertyDescriptor(m, k);
		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
		      desc = { enumerable: true, get: function() { return m[k]; } };
		    }
		    Object.defineProperty(o, k2, desc);
		}) : (function(o, m, k, k2) {
		    if (k2 === undefined) k2 = k;
		    o[k2] = m[k];
		}));
		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.supportedApps = exports.newSubstrateApp = exports.SubstrateApp = void 0;
		__exportStar(legacy_apps, exports);
		var substrate_app_1 = substrate_app;
		Object.defineProperty(exports, "SubstrateApp", { enumerable: true, get: function () { return substrate_app_1.SubstrateApp; } });
		var supported_apps_1 = supported_apps;
		Object.defineProperty(exports, "newSubstrateApp", { enumerable: true, get: function () { return supported_apps_1.newSubstrateApp; } });
		Object.defineProperty(exports, "supportedApps", { enumerable: true, get: function () { return supported_apps_1.supportedApps; } });
	} (dist));
	getDefaultExportFromCjs(dist);

	var browser = {};

	var extendStatics = function(d, b) {
	  extendStatics = Object.setPrototypeOf ||
	      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
	      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
	  return extendStatics(d, b);
	};
	function __extends(d, b) {
	  if (typeof b !== "function" && b !== null)
	      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
	  extendStatics(d, b);
	  function __() { this.constructor = d; }
	  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
	}
	var __assign = function() {
	  __assign = Object.assign || function __assign(t) {
	      for (var s, i = 1, n = arguments.length; i < n; i++) {
	          s = arguments[i];
	          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
	      }
	      return t;
	  };
	  return __assign.apply(this, arguments);
	};
	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;
	}
	function __decorate(decorators, target, key, desc) {
	  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
	  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
	  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
	  return c > 3 && r && Object.defineProperty(target, key, r), r;
	}
	function __param(paramIndex, decorator) {
	  return function (target, key) { decorator(target, key, paramIndex); }
	}
	function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
	  function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
	  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
	  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
	  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
	  var _, done = false;
	  for (var i = decorators.length - 1; i >= 0; i--) {
	      var context = {};
	      for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
	      for (var p in contextIn.access) context.access[p] = contextIn.access[p];
	      context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
	      var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
	      if (kind === "accessor") {
	          if (result === void 0) continue;
	          if (result === null || typeof result !== "object") throw new TypeError("Object expected");
	          if (_ = accept(result.get)) descriptor.get = _;
	          if (_ = accept(result.set)) descriptor.set = _;
	          if (_ = accept(result.init)) initializers.unshift(_);
	      }
	      else if (_ = accept(result)) {
	          if (kind === "field") initializers.unshift(_);
	          else descriptor[key] = _;
	      }
	  }
	  if (target) Object.defineProperty(target, contextIn.name, descriptor);
	  done = true;
	}function __runInitializers(thisArg, initializers, value) {
	  var useValue = arguments.length > 2;
	  for (var i = 0; i < initializers.length; i++) {
	      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
	  }
	  return useValue ? value : void 0;
	}function __propKey(x) {
	  return typeof x === "symbol" ? x : "".concat(x);
	}function __setFunctionName(f, name, prefix) {
	  if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
	  return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
	}function __metadata(metadataKey, metadataValue) {
	  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
	}
	function __awaiter$4(thisArg, _arguments, P, generator) {
	  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	  return new (P || (P = Promise))(function (resolve, reject) {
	      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	      function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	      step((generator = generator.apply(thisArg, _arguments || [])).next());
	  });
	}
	function __generator(thisArg, body) {
	  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
	  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
	  function verb(n) { return function (v) { return step([n, v]); }; }
	  function step(op) {
	      if (f) throw new TypeError("Generator is already executing.");
	      while (g && (g = 0, op[0] && (_ = 0)), _) try {
	          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
	          if (y = 0, t) op = [op[0] & 2, t.value];
	          switch (op[0]) {
	              case 0: case 1: t = op; break;
	              case 4: _.label++; return { value: op[1], done: false };
	              case 5: _.label++; y = op[1]; op = [0]; continue;
	              case 7: op = _.ops.pop(); _.trys.pop(); continue;
	              default:
	                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
	                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
	                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
	                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
	                  if (t[2]) _.ops.pop();
	                  _.trys.pop(); continue;
	          }
	          op = body.call(thisArg, _);
	      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
	      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
	  }
	}
	var __createBinding = Object.create ? (function(o, m, k, k2) {
	  if (k2 === undefined) k2 = k;
	  var desc = Object.getOwnPropertyDescriptor(m, k);
	  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
	      desc = { enumerable: true, get: function() { return m[k]; } };
	  }
	  Object.defineProperty(o, k2, desc);
	}) : (function(o, m, k, k2) {
	  if (k2 === undefined) k2 = k;
	  o[k2] = m[k];
	});
	function __exportStar(m, o) {
	  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
	}
	function __values(o) {
	  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
	  if (m) return m.call(o);
	  if (o && typeof o.length === "number") return {
	      next: function () {
	          if (o && i >= o.length) o = void 0;
	          return { value: o && o[i++], done: !o };
	      }
	  };
	  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
	}
	function __read(o, n) {
	  var m = typeof Symbol === "function" && o[Symbol.iterator];
	  if (!m) return o;
	  var i = m.call(o), r, ar = [], e;
	  try {
	      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
	  }
	  catch (error) { e = { error: error }; }
	  finally {
	      try {
	          if (r && !r.done && (m = i["return"])) m.call(i);
	      }
	      finally { if (e) throw e.error; }
	  }
	  return ar;
	}
	function __spread() {
	  for (var ar = [], i = 0; i < arguments.length; i++)
	      ar = ar.concat(__read(arguments[i]));
	  return ar;
	}
	function __spreadArrays() {
	  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
	  for (var r = Array(s), k = 0, i = 0; i < il; i++)
	      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
	          r[k] = a[j];
	  return r;
	}
	function __spreadArray(to, from, pack) {
	  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
	      if (ar || !(i in from)) {
	          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
	          ar[i] = from[i];
	      }
	  }
	  return to.concat(ar || Array.prototype.slice.call(from));
	}
	function __await(v) {
	  return this instanceof __await ? (this.v = v, this) : new __await(v);
	}
	function __asyncGenerator(thisArg, _arguments, generator) {
	  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
	  var g = generator.apply(thisArg, _arguments || []), i, q = [];
	  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
	  function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
	  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
	  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
	  function fulfill(value) { resume("next", value); }
	  function reject(value) { resume("throw", value); }
	  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
	}
	function __asyncDelegator(o) {
	  var i, p;
	  return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
	  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
	}
	function __asyncValues(o) {
	  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
	  var m = o[Symbol.asyncIterator], i;
	  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
	  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
	  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
	}
	function __makeTemplateObject(cooked, raw) {
	  if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
	  return cooked;
	}var __setModuleDefault = Object.create ? (function(o, v) {
	  Object.defineProperty(o, "default", { enumerable: true, value: v });
	}) : function(o, v) {
	  o["default"] = v;
	};
	function __importStar(mod) {
	  if (mod && mod.__esModule) return mod;
	  var result = {};
	  if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
	  __setModuleDefault(result, mod);
	  return result;
	}
	function __importDefault(mod) {
	  return (mod && mod.__esModule) ? mod : { default: mod };
	}
	function __classPrivateFieldGet(receiver, state, kind, f) {
	  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
	  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
	  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
	}
	function __classPrivateFieldSet(receiver, state, value, kind, f) {
	  if (kind === "m") throw new TypeError("Private method is not writable");
	  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
	  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
	  return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
	}
	function __classPrivateFieldIn(state, receiver) {
	  if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
	  return typeof state === "function" ? receiver === state : state.has(receiver);
	}
	function __addDisposableResource(env, value, async) {
	  if (value !== null && value !== void 0) {
	    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
	    var dispose;
	    if (async) {
	        if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
	        dispose = value[Symbol.asyncDispose];
	    }
	    if (dispose === void 0) {
	        if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
	        dispose = value[Symbol.dispose];
	    }
	    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
	    env.stack.push({ value: value, dispose: dispose, async: async });
	  }
	  else if (async) {
	    env.stack.push({ async: true });
	  }
	  return value;
	}
	var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
	  var e = new Error(message);
	  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
	};
	function __disposeResources(env) {
	  function fail(e) {
	    env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
	    env.hasError = true;
	  }
	  function next() {
	    while (env.stack.length) {
	      var rec = env.stack.pop();
	      try {
	        var result = rec.dispose && rec.dispose.call(rec.value);
	        if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
	      }
	      catch (e) {
	          fail(e);
	      }
	    }
	    if (env.hasError) throw env.error;
	  }
	  return next();
	}
	const tslib_es6 = {
	  __extends,
	  __assign,
	  __rest,
	  __decorate,
	  __param,
	  __metadata,
	  __awaiter: __awaiter$4,
	  __generator,
	  __createBinding,
	  __exportStar,
	  __values,
	  __read,
	  __spread,
	  __spreadArrays,
	  __spreadArray,
	  __await,
	  __asyncGenerator,
	  __asyncDelegator,
	  __asyncValues,
	  __makeTemplateObject,
	  __importStar,
	  __importDefault,
	  __classPrivateFieldGet,
	  __classPrivateFieldSet,
	  __classPrivateFieldIn,
	  __addDisposableResource,
	  __disposeResources,
	};

	const tslib_es6$1 = /*#__PURE__*/Object.freeze({
		__proto__: null,
		__addDisposableResource: __addDisposableResource,
		get __assign () { return __assign; },
		__asyncDelegator: __asyncDelegator,
		__asyncGenerator: __asyncGenerator,
		__asyncValues: __asyncValues,
		__await: __await,
		__awaiter: __awaiter$4,
		__classPrivateFieldGet: __classPrivateFieldGet,
		__classPrivateFieldIn: __classPrivateFieldIn,
		__classPrivateFieldSet: __classPrivateFieldSet,
		__createBinding: __createBinding,
		__decorate: __decorate,
		__disposeResources: __disposeResources,
		__esDecorate: __esDecorate,
		__exportStar: __exportStar,
		__extends: __extends,
		__generator: __generator,
		__importDefault: __importDefault,
		__importStar: __importStar,
		__makeTemplateObject: __makeTemplateObject,
		__metadata: __metadata,
		__param: __param,
		__propKey: __propKey,
		__read: __read,
		__rest: __rest,
		__runInitializers: __runInitializers,
		__setFunctionName: __setFunctionName,
		__spread: __spread,
		__spreadArray: __spreadArray,
		__spreadArrays: __spreadArrays,
		__values: __values,
		default: tslib_es6
	});

	const require$$0 = /*@__PURE__*/getAugmentedNamespace(tslib_es6$1);

	const EventEmitter = {};

	const createCustomErrorClass = (name) => {
	    class CustomErrorClass extends Error {
	        constructor(message, fields, options) {
	            super(message || name, options);
	            Object.setPrototypeOf(this, CustomErrorClass.prototype);
	            this.name = name;
	            if (fields) {
	                for (const k in fields) {
	                    this[k] = fields[k];
	                }
	            }
	            if (options && isObject(options) && "cause" in options && !("cause" in this)) {
	                const cause = options.cause;
	                this.cause = cause;
	                if ("stack" in cause) {
	                    this.stack = this.stack + "\nCAUSE: " + cause.stack;
	                }
	            }
	        }
	    }
	    return CustomErrorClass;
	};
	function isObject(value) {
	    return typeof value === "object";
	}

	const DisconnectedDevice = createCustomErrorClass("DisconnectedDevice");
	const DisconnectedDeviceDuringOperation = createCustomErrorClass("DisconnectedDeviceDuringOperation");
	const TransportOpenUserCancelled = createCustomErrorClass("TransportOpenUserCancelled");
	const TransportInterfaceNotAvailable = createCustomErrorClass("TransportInterfaceNotAvailable");
	const TransportRaceCondition = createCustomErrorClass("TransportRaceCondition");
	const TransportWebUSBGestureRequired = createCustomErrorClass("TransportWebUSBGestureRequired");
	var HwTransportErrorType;
	(function (HwTransportErrorType) {
	    HwTransportErrorType["Unknown"] = "Unknown";
	    HwTransportErrorType["LocationServicesDisabled"] = "LocationServicesDisabled";
	    HwTransportErrorType["LocationServicesUnauthorized"] = "LocationServicesUnauthorized";
	    HwTransportErrorType["BluetoothScanStartFailed"] = "BluetoothScanStartFailed";
	})(HwTransportErrorType || (HwTransportErrorType = {}));
	class TransportError extends Error {
	    constructor(message, id) {
	        const name = "TransportError";
	        super(message || name);
	        this.name = name;
	        this.message = message;
	        this.stack = new Error(message).stack;
	        this.id = id;
	    }
	}
	const StatusCodes = {
	    ACCESS_CONDITION_NOT_FULFILLED: 0x9804,
	    ALGORITHM_NOT_SUPPORTED: 0x9484,
	    CLA_NOT_SUPPORTED: 0x6e00,
	    CODE_BLOCKED: 0x9840,
	    CODE_NOT_INITIALIZED: 0x9802,
	    COMMAND_INCOMPATIBLE_FILE_STRUCTURE: 0x6981,
	    CONDITIONS_OF_USE_NOT_SATISFIED: 0x6985,
	    CONTRADICTION_INVALIDATION: 0x9810,
	    CONTRADICTION_SECRET_CODE_STATUS: 0x9808,
	    CUSTOM_IMAGE_BOOTLOADER: 0x662f,
	    CUSTOM_IMAGE_EMPTY: 0x662e,
	    FILE_ALREADY_EXISTS: 0x6a89,
	    FILE_NOT_FOUND: 0x9404,
	    GP_AUTH_FAILED: 0x6300,
	    HALTED: 0x6faa,
	    INCONSISTENT_FILE: 0x9408,
	    INCORRECT_DATA: 0x6a80,
	    INCORRECT_LENGTH: 0x6700,
	    INCORRECT_P1_P2: 0x6b00,
	    INS_NOT_SUPPORTED: 0x6d00,
	    DEVICE_NOT_ONBOARDED: 0x6d07,
	    DEVICE_NOT_ONBOARDED_2: 0x6611,
	    INVALID_KCV: 0x9485,
	    INVALID_OFFSET: 0x9402,
	    LICENSING: 0x6f42,
	    LOCKED_DEVICE: 0x5515,
	    MAX_VALUE_REACHED: 0x9850,
	    MEMORY_PROBLEM: 0x9240,
	    MISSING_CRITICAL_PARAMETER: 0x6800,
	    NO_EF_SELECTED: 0x9400,
	    NOT_ENOUGH_MEMORY_SPACE: 0x6a84,
	    OK: 0x9000,
	    PIN_REMAINING_ATTEMPTS: 0x63c0,
	    REFERENCED_DATA_NOT_FOUND: 0x6a88,
	    SECURITY_STATUS_NOT_SATISFIED: 0x6982,
	    TECHNICAL_PROBLEM: 0x6f00,
	    UNKNOWN_APDU: 0x6d02,
	    USER_REFUSED_ON_DEVICE: 0x5501,
	    NOT_ENOUGH_SPACE: 0x5102,
	};
	function getAltStatusMessage(code) {
	    switch (code) {
	        case 0x6700:
	            return "Incorrect length";
	        case 0x6800:
	            return "Missing critical parameter";
	        case 0x6982:
	            return "Security not satisfied (dongle locked or have invalid access rights)";
	        case 0x6985:
	            return "Condition of use not satisfied (denied by the user?)";
	        case 0x6a80:
	            return "Invalid data received";
	        case 0x6b00:
	            return "Invalid parameter received";
	        case 0x5515:
	            return "Locked device";
	    }
	    if (0x6f00 <= code && code <= 0x6fff) {
	        return "Internal error, please report";
	    }
	}
	class TransportStatusError extends Error {
	    constructor(statusCode, { canBeMappedToChildError = true } = {}) {
	        const statusText = Object.keys(StatusCodes).find(k => StatusCodes[k] === statusCode) || "UNKNOWN_ERROR";
	        const smsg = getAltStatusMessage(statusCode) || statusText;
	        const statusCodeStr = statusCode.toString(16);
	        const message = `Ledger device: ${smsg} (0x${statusCodeStr})`;
	        super(message);
	        this.name = "TransportStatusError";
	        this.statusCode = statusCode;
	        this.statusText = statusText;
	        if (canBeMappedToChildError && statusCode === StatusCodes.LOCKED_DEVICE) {
	            return new LockedDeviceError(message);
	        }
	    }
	}
	class LockedDeviceError extends TransportStatusError {
	    constructor(message) {
	        super(StatusCodes.LOCKED_DEVICE, { canBeMappedToChildError: false });
	        if (message) {
	            this.message = message;
	        }
	        this.name = "LockedDeviceError";
	    }
	}

	let id = 0;
	const subscribers = [];
	const log = (type, message, data) => {
	    const obj = {
	        type,
	        id: String(++id),
	        date: new Date(),
	    };
	    if (message)
	        obj.message = message;
	    if (data)
	        obj.data = data;
	    dispatch(obj);
	};
	const trace = ({ type, message, data, context, }) => {
	    const obj = {
	        type,
	        id: String(++id),
	        date: new Date(),
	    };
	    if (message)
	        obj.message = message;
	    if (data)
	        obj.data = data;
	    if (context)
	        obj.context = context;
	    dispatch(obj);
	};
	class LocalTracer {
	    constructor(type, context) {
	        this.type = type;
	        this.context = context;
	    }
	    trace(message, data) {
	        trace({
	            type: this.type,
	            message,
	            data,
	            context: this.context,
	        });
	    }
	    getContext() {
	        return this.context;
	    }
	    setContext(context) {
	        this.context = context;
	    }
	    updateContext(contextToAdd) {
	        this.context = Object.assign(Object.assign({}, this.context), contextToAdd);
	    }
	    getType() {
	        return this.type;
	    }
	    setType(type) {
	        this.type = type;
	    }
	    withType(type) {
	        return new LocalTracer(type, this.context);
	    }
	    withContext(context) {
	        return new LocalTracer(this.type, context);
	    }
	    withUpdatedContext(contextToAdd) {
	        return new LocalTracer(this.type, Object.assign(Object.assign({}, this.context), contextToAdd));
	    }
	}
	const listen = (cb) => {
	    subscribers.push(cb);
	    return () => {
	        const i = subscribers.indexOf(cb);
	        if (i !== -1) {
	            subscribers[i] = subscribers[subscribers.length - 1];
	            subscribers.pop();
	        }
	    };
	};
	function dispatch(log) {
	    for (let i = 0; i < subscribers.length; i++) {
	        try {
	            subscribers[i](log);
	        }
	        catch (e) {
	            console.error(e);
	        }
	    }
	}
	if (typeof window !== "undefined") {
	    window.__ledgerLogsListen = listen;
	}

	var __awaiter$3 = (global && global.__awaiter) || function (thisArg, _arguments, P, generator) {
	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	    return new (P || (P = Promise))(function (resolve, reject) {
	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	        step((generator = generator.apply(thisArg, _arguments || [])).next());
	    });
	};
	const DEFAULT_LOG_TYPE = "transport";
	class Transport {
	    constructor({ context, logType } = {}) {
	        this.exchangeTimeout = 30000;
	        this.unresponsiveTimeout = 15000;
	        this.deviceModel = null;
	        this._events = new EventEmitter();
	        this.send = (cla, ins, p1, p2, data = Buffer.alloc(0), statusList = [StatusCodes.OK], { abortTimeoutMs } = {}) => __awaiter$3(this, void 0, void 0, function* () {
	            const tracer = this.tracer.withUpdatedContext({ function: "send" });
	            if (data.length >= 256) {
	                tracer.trace("data.length exceeded 256 bytes limit", { dataLength: data.length });
	                throw new TransportError("data.length exceed 256 bytes limit. Got: " + data.length, "DataLengthTooBig");
	            }
	            tracer.trace("Starting an exchange", { abortTimeoutMs });
	            const response = yield this.exchange(
	            Buffer.concat([Buffer.from([cla, ins, p1, p2]), Buffer.from([data.length]), data]), { abortTimeoutMs });
	            tracer.trace("Received response from exchange");
	            const sw = response.readUInt16BE(response.length - 2);
	            if (!statusList.some(s => s === sw)) {
	                throw new TransportStatusError(sw);
	            }
	            return response;
	        });
	        this._appAPIlock = null;
	        this.tracer = new LocalTracer(logType !== null && logType !== void 0 ? logType : DEFAULT_LOG_TYPE, context);
	    }
	    exchange(_apdu, { abortTimeoutMs: _abortTimeoutMs } = {}) {
	        throw new Error("exchange not implemented");
	    }
	    exchangeBulk(apdus, observer) {
	        let unsubscribed = false;
	        const unsubscribe = () => {
	            unsubscribed = true;
	        };
	        const main = () => __awaiter$3(this, void 0, void 0, function* () {
	            if (unsubscribed)
	                return;
	            for (const apdu of apdus) {
	                const r = yield this.exchange(apdu);
	                if (unsubscribed)
	                    return;
	                const status = r.readUInt16BE(r.length - 2);
	                if (status !== StatusCodes.OK) {
	                    throw new TransportStatusError(status);
	                }
	                observer.next(r);
	            }
	        });
	        main().then(() => !unsubscribed && observer.complete(), e => !unsubscribed && observer.error(e));
	        return { unsubscribe };
	    }
	    setScrambleKey(_key) { }
	    close() {
	        return Promise.resolve();
	    }
	    on(eventName, cb) {
	        this._events.on(eventName, cb);
	    }
	    off(eventName, cb) {
	        this._events.removeListener(eventName, cb);
	    }
	    emit(event, ...args) {
	        this._events.emit(event, ...args);
	    }
	    setDebugMode() {
	        console.warn("setDebugMode is deprecated. use @ledgerhq/logs instead. No logs are emitted in this anymore.");
	    }
	    setExchangeTimeout(exchangeTimeout) {
	        this.exchangeTimeout = exchangeTimeout;
	    }
	    setExchangeUnresponsiveTimeout(unresponsiveTimeout) {
	        this.unresponsiveTimeout = unresponsiveTimeout;
	    }
	    static create(openTimeout = 3000, listenTimeout) {
	        return new Promise((resolve, reject) => {
	            let found = false;
	            const sub = this.listen({
	                next: e => {
	                    found = true;
	                    if (sub)
	                        sub.unsubscribe();
	                    if (listenTimeoutId)
	                        clearTimeout(listenTimeoutId);
	                    this.open(e.descriptor, openTimeout).then(resolve, reject);
	                },
	                error: e => {
	                    if (listenTimeoutId)
	                        clearTimeout(listenTimeoutId);
	                    reject(e);
	                },
	                complete: () => {
	                    if (listenTimeoutId)
	                        clearTimeout(listenTimeoutId);
	                    if (!found) {
	                        reject(new TransportError(this.ErrorMessage_NoDeviceFound, "NoDeviceFound"));
	                    }
	                },
	            });
	            const listenTimeoutId = listenTimeout
	                ? setTimeout(() => {
	                    sub.unsubscribe();
	                    reject(new TransportError(this.ErrorMessage_ListenTimeout, "ListenTimeout"));
	                }, listenTimeout)
	                : null;
	        });
	    }
	    exchangeAtomicImpl(f) {
	        return __awaiter$3(this, void 0, void 0, function* () {
	            const tracer = this.tracer.withUpdatedContext({ function: "exchangeAtomicImpl" });
	            tracer.trace("Starting an atomic APDU exchange", {
	                unresponsiveTimeout: this.unresponsiveTimeout,
	            });
	            if (this.exchangeBusyPromise) {
	                tracer.trace("Atomic exchange is already busy");
	                throw new TransportRaceCondition("An action was already pending on the Ledger device. Please deny or reconnect.");
	            }
	            let resolveBusy;
	            const busyPromise = new Promise(r => {
	                resolveBusy = r;
	            });
	            this.exchangeBusyPromise = busyPromise;
	            let unresponsiveReached = false;
	            const timeout = setTimeout(() => {
	                tracer.trace(`Timeout reached, emitting Transport event "unresponsive"`, {
	                    unresponsiveTimeout: this.unresponsiveTimeout,
	                });
	                unresponsiveReached = true;
	                this.emit("unresponsive");
	            }, this.unresponsiveTimeout);
	            try {
	                const res = yield f();
	                if (unresponsiveReached) {
	                    tracer.trace("Device was unresponsive, emitting responsive");
	                    this.emit("responsive");
	                }
	                return res;
	            }
	            finally {
	                tracer.trace("Finalize, clearing busy guard");
	                clearTimeout(timeout);
	                if (resolveBusy)
	                    resolveBusy();
	                this.exchangeBusyPromise = null;
	            }
	        });
	    }
	    decorateAppAPIMethods(self, methods, scrambleKey) {
	        for (const methodName of methods) {
	            self[methodName] = this.decorateAppAPIMethod(methodName, self[methodName], self, scrambleKey);
	        }
	    }
	    decorateAppAPIMethod(methodName, f, ctx, scrambleKey) {
	        return (...args) => __awaiter$3(this, void 0, void 0, function* () {
	            const { _appAPIlock } = this;
	            if (_appAPIlock) {
	                return Promise.reject(new TransportError("Ledger Device is busy (lock " + _appAPIlock + ")", "TransportLocked"));
	            }
	            try {
	                this._appAPIlock = methodName;
	                this.setScrambleKey(scrambleKey);
	                return yield f.apply(ctx, args);
	            }
	            finally {
	                this._appAPIlock = null;
	            }
	        });
	    }
	    setTraceContext(context) {
	        this.tracer = this.tracer.withContext(context);
	    }
	    updateTraceContext(contextToAdd) {
	        this.tracer.updateContext(contextToAdd);
	    }
	    getTraceContext() {
	        return this.tracer.getContext();
	    }
	}
	Transport.ErrorMessage_ListenTimeout = "No Ledger device found (timeout)";
	Transport.ErrorMessage_NoDeviceFound = "No Ledger device found";

	const Tag = 0x05;
	function asUInt16BE(value) {
	    const b = Buffer.alloc(2);
	    b.writeUInt16BE(value, 0);
	    return b;
	}
	const initialAcc = {
	    data: Buffer.alloc(0),
	    dataLength: 0,
	    sequence: 0,
	};
	const createHIDframing = (channel, packetSize) => {
	    return {
	        makeBlocks(apdu) {
	            let data = Buffer.concat([asUInt16BE(apdu.length), apdu]);
	            const blockSize = packetSize - 5;
	            const nbBlocks = Math.ceil(data.length / blockSize);
	            data = Buffer.concat([data, Buffer.alloc(nbBlocks * blockSize - data.length + 1).fill(0)]);
	            const blocks = [];
	            for (let i = 0; i < nbBlocks; i++) {
	                const head = Buffer.alloc(5);
	                head.writeUInt16BE(channel, 0);
	                head.writeUInt8(Tag, 2);
	                head.writeUInt16BE(i, 3);
	                const chunk = data.slice(i * blockSize, (i + 1) * blockSize);
	                blocks.push(Buffer.concat([head, chunk]));
	            }
	            return blocks;
	        },
	        reduceResponse(acc, chunk) {
	            let { data, dataLength, sequence } = acc || initialAcc;
	            if (chunk.readUInt16BE(0) !== channel) {
	                throw new TransportError("Invalid channel", "InvalidChannel");
	            }
	            if (chunk.readUInt8(2) !== Tag) {
	                throw new TransportError("Invalid tag", "InvalidTag");
	            }
	            if (chunk.readUInt16BE(3) !== sequence) {
	                throw new TransportError("Invalid sequence", "InvalidSequence");
	            }
	            if (!acc) {
	                dataLength = chunk.readUInt16BE(5);
	            }
	            sequence++;
	            const chunkData = chunk.slice(acc ? 5 : 7);
	            data = Buffer.concat([data, chunkData]);
	            if (data.length > dataLength) {
	                data = data.slice(0, dataLength);
	            }
	            return {
	                data,
	                dataLength,
	                sequence,
	            };
	        },
	        getReducedResult(acc) {
	            if (acc && acc.dataLength === acc.data.length) {
	                return acc.data;
	            }
	        },
	    };
	};

	var re$2 = {exports: {}};

	const SEMVER_SPEC_VERSION = '2.0.0';
	const MAX_LENGTH$1 = 256;
	const MAX_SAFE_INTEGER$1 = Number.MAX_SAFE_INTEGER ||
	 9007199254740991;
	const MAX_SAFE_COMPONENT_LENGTH = 16;
	const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6;
	const RELEASE_TYPES = [
	  'major',
	  'premajor',
	  'minor',
	  'preminor',
	  'patch',
	  'prepatch',
	  'prerelease',
	];
	var constants$1 = {
	  MAX_LENGTH: MAX_LENGTH$1,
	  MAX_SAFE_COMPONENT_LENGTH,
	  MAX_SAFE_BUILD_LENGTH,
	  MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
	  RELEASE_TYPES,
	  SEMVER_SPEC_VERSION,
	  FLAG_INCLUDE_PRERELEASE: 0b001,
	  FLAG_LOOSE: 0b010,
	};
	getDefaultExportFromCjs(constants$1);

	const debug$1 = (
	  typeof process === 'object' &&
	  process.env &&
	  process.env.NODE_DEBUG &&
	  /\bsemver\b/i.test(process.env.NODE_DEBUG)
	) ? (...args) => console.error('SEMVER', ...args)
	  : () => {};
	var debug_1 = debug$1;
	getDefaultExportFromCjs(debug_1);

	(function (module, exports) {
		const {
		  MAX_SAFE_COMPONENT_LENGTH,
		  MAX_SAFE_BUILD_LENGTH,
		  MAX_LENGTH,
		} = constants$1;
		const debug = debug_1;
		exports = module.exports = {};
		const re = exports.re = [];
		const safeRe = exports.safeRe = [];
		const src = exports.src = [];
		const t = exports.t = {};
		let R = 0;
		const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
		const safeRegexReplacements = [
		  ['\\s', 1],
		  ['\\d', MAX_LENGTH],
		  [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH],
		];
		const makeSafeRegex = (value) => {
		  for (const [token, max] of safeRegexReplacements) {
		    value = value
		      .split(`${token}*`).join(`${token}{0,${max}}`)
		      .split(`${token}+`).join(`${token}{1,${max}}`);
		  }
		  return value
		};
		const createToken = (name, value, isGlobal) => {
		  const safe = makeSafeRegex(value);
		  const index = R++;
		  debug(name, index, value);
		  t[name] = index;
		  src[index] = value;
		  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
		  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined);
		};
		createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
		createToken('NUMERICIDENTIFIERLOOSE', '\\d+');
		createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
		createToken('MAINVERSION', `(${src[t.NUMERICIDENTIFIER]})\\.` +
		                   `(${src[t.NUMERICIDENTIFIER]})\\.` +
		                   `(${src[t.NUMERICIDENTIFIER]})`);
		createToken('MAINVERSIONLOOSE', `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
		                        `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.` +
		                        `(${src[t.NUMERICIDENTIFIERLOOSE]})`);
		createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NUMERICIDENTIFIER]
	}|${src[t.NONNUMERICIDENTIFIER]})`);
		createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NUMERICIDENTIFIERLOOSE]
	}|${src[t.NONNUMERICIDENTIFIER]})`);
		createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
	}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
		createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
	}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
		createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`);
		createToken('BUILD', `(?:\\+(${src[t.BUILDIDENTIFIER]
	}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
		createToken('FULLPLAIN', `v?${src[t.MAINVERSION]
	}${src[t.PRERELEASE]}?${
	  src[t.BUILD]}?`);
		createToken('FULL', `^${src[t.FULLPLAIN]}$`);
		createToken('LOOSEPLAIN', `[v=\\s]*${src[t.MAINVERSIONLOOSE]
	}${src[t.PRERELEASELOOSE]}?${
	  src[t.BUILD]}?`);
		createToken('LOOSE', `^${src[t.LOOSEPLAIN]}$`);
		createToken('GTLT', '((?:<|>)?=?)');
		createToken('XRANGEIDENTIFIERLOOSE', `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
		createToken('XRANGEIDENTIFIER', `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
		createToken('XRANGEPLAIN', `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})` +
		                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
		                   `(?:\\.(${src[t.XRANGEIDENTIFIER]})` +
		                   `(?:${src[t.PRERELEASE]})?${
	                     src[t.BUILD]}?` +
		                   `)?)?`);
		createToken('XRANGEPLAINLOOSE', `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})` +
		                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
		                        `(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})` +
		                        `(?:${src[t.PRERELEASELOOSE]})?${
	                          src[t.BUILD]}?` +
		                        `)?)?`);
		createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
		createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
		createToken('COERCE', `${'(^|[^\\d])' +
	              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
		              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
		              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
		              `(?:$|[^\\d])`);
		createToken('COERCERTL', src[t.COERCE], true);
		createToken('LONETILDE', '(?:~>?)');
		createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
		exports.tildeTrimReplace = '$1~';
		createToken('TILDE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAIN]}$`);
		createToken('TILDELOOSE', `^${src[t.LONETILDE]}${src[t.XRANGEPLAINLOOSE]}$`);
		createToken('LONECARET', '(?:\\^)');
		createToken('CARETTRIM', `(\\s*)${src[t.LONECARET]}\\s+`, true);
		exports.caretTrimReplace = '$1^';
		createToken('CARET', `^${src[t.LONECARET]}${src[t.XRANGEPLAIN]}$`);
		createToken('CARETLOOSE', `^${src[t.LONECARET]}${src[t.XRANGEPLAINLOOSE]}$`);
		createToken('COMPARATORLOOSE', `^${src[t.GTLT]}\\s*(${src[t.LOOSEPLAIN]})$|^$`);
		createToken('COMPARATOR', `^${src[t.GTLT]}\\s*(${src[t.FULLPLAIN]})$|^$`);
		createToken('COMPARATORTRIM', `(\\s*)${src[t.GTLT]
	}\\s*(${src[t.LOOSEPLAIN]}|${src[t.XRANGEPLAIN]})`, true);
		exports.comparatorTrimReplace = '$1$2$3';
		createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
		                   `\\s+-\\s+` +
		                   `(${src[t.XRANGEPLAIN]})` +
		                   `\\s*$`);
		createToken('HYPHENRANGELOOSE', `^\\s*(${src[t.XRANGEPLAINLOOSE]})` +
		                        `\\s+-\\s+` +
		                        `(${src[t.XRANGEPLAINLOOSE]})` +
		                        `\\s*$`);
		createToken('STAR', '(<|>)?=?\\s*\\*');
		createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
		createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$');
	} (re$2, re$2.exports));
	var reExports = re$2.exports;
	getDefaultExportFromCjs(reExports);

	const looseOption = Object.freeze({ loose: true });
	const emptyOpts = Object.freeze({ });
	const parseOptions$1 = options => {
	  if (!options) {
	    return emptyOpts
	  }
	  if (typeof options !== 'object') {
	    return looseOption
	  }
	  return options
	};
	var parseOptions_1 = parseOptions$1;
	getDefaultExportFromCjs(parseOptions_1);

	const numeric = /^[0-9]+$/;
	const compareIdentifiers$1 = (a, b) => {
	  const anum = numeric.test(a);
	  const bnum = numeric.test(b);
	  if (anum && bnum) {
	    a = +a;
	    b = +b;
	  }
	  return a === b ? 0
	    : (anum && !bnum) ? -1
	    : (bnum && !anum) ? 1
	    : a < b ? -1
	    : 1
	};
	const rcompareIdentifiers = (a, b) => compareIdentifiers$1(b, a);
	var identifiers$1 = {
	  compareIdentifiers: compareIdentifiers$1,
	  rcompareIdentifiers,
	};
	getDefaultExportFromCjs(identifiers$1);

	const debug = debug_1;
	const { MAX_LENGTH, MAX_SAFE_INTEGER } = constants$1;
	const { safeRe: re$1, t: t$1 } = reExports;
	const parseOptions = parseOptions_1;
	const { compareIdentifiers } = identifiers$1;
	let SemVer$d = class SemVer {
	  constructor (version, options) {
	    options = parseOptions(options);
	    if (version instanceof SemVer) {
	      if (version.loose === !!options.loose &&
	          version.includePrerelease === !!options.includePrerelease) {
	        return version
	      } else {
	        version = version.version;
	      }
	    } else if (typeof version !== 'string') {
	      throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`)
	    }
	    if (version.length > MAX_LENGTH) {
	      throw new TypeError(
	        `version is longer than ${MAX_LENGTH} characters`
	      )
	    }
	    debug('SemVer', version, options);
	    this.options = options;
	    this.loose = !!options.loose;
	    this.includePrerelease = !!options.includePrerelease;
	    const m = version.trim().match(options.loose ? re$1[t$1.LOOSE] : re$1[t$1.FULL]);
	    if (!m) {
	      throw new TypeError(`Invalid Version: ${version}`)
	    }
	    this.raw = version;
	    this.major = +m[1];
	    this.minor = +m[2];
	    this.patch = +m[3];
	    if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
	      throw new TypeError('Invalid major version')
	    }
	    if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
	      throw new TypeError('Invalid minor version')
	    }
	    if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
	      throw new TypeError('Invalid patch version')
	    }
	    if (!m[4]) {
	      this.prerelease = [];
	    } else {
	      this.prerelease = m[4].split('.').map((id) => {
	        if (/^[0-9]+$/.test(id)) {
	          const num = +id;
	          if (num >= 0 && num < MAX_SAFE_INTEGER) {
	            return num
	          }
	        }
	        return id
	      });
	    }
	    this.build = m[5] ? m[5].split('.') : [];
	    this.format();
	  }
	  format () {
	    this.version = `${this.major}.${this.minor}.${this.patch}`;
	    if (this.prerelease.length) {
	      this.version += `-${this.prerelease.join('.')}`;
	    }
	    return this.version
	  }
	  toString () {
	    return this.version
	  }
	  compare (other) {
	    debug('SemVer.compare', this.version, this.options, other);
	    if (!(other instanceof SemVer)) {
	      if (typeof other === 'string' && other === this.version) {
	        return 0
	      }
	      other = new SemVer(other, this.options);
	    }
	    if (other.version === this.version) {
	      return 0
	    }
	    return this.compareMain(other) || this.comparePre(other)
	  }
	  compareMain (other) {
	    if (!(other instanceof SemVer)) {
	      other = new SemVer(other, this.options);
	    }
	    return (
	      compareIdentifiers(this.major, other.major) ||
	      compareIdentifiers(this.minor, other.minor) ||
	      compareIdentifiers(this.patch, other.patch)
	    )
	  }
	  comparePre (other) {
	    if (!(other instanceof SemVer)) {
	      other = new SemVer(other, this.options);
	    }
	    if (this.prerelease.length && !other.prerelease.length) {
	      return -1
	    } else if (!this.prerelease.length && other.prerelease.length) {
	      return 1
	    } else if (!this.prerelease.length && !other.prerelease.length) {
	      return 0
	    }
	    let i = 0;
	    do {
	      const a = this.prerelease[i];
	      const b = other.prerelease[i];
	      debug('prerelease compare', i, a, b);
	      if (a === undefined && b === undefined) {
	        return 0
	      } else if (b === undefined) {
	        return 1
	      } else if (a === undefined) {
	        return -1
	      } else if (a === b) {
	        continue
	      } else {
	        return compareIdentifiers(a, b)
	      }
	    } while (++i)
	  }
	  compareBuild (other) {
	    if (!(other instanceof SemVer)) {
	      other = new SemVer(other, this.options);
	    }
	    let i = 0;
	    do {
	      const a = this.build[i];
	      const b = other.build[i];
	      debug('prerelease compare', i, a, b);
	      if (a === undefined && b === undefined) {
	        return 0
	      } else if (b === undefined) {
	        return 1
	      } else if (a === undefined) {
	        return -1
	      } else if (a === b) {
	        continue
	      } else {
	        return compareIdentifiers(a, b)
	      }
	    } while (++i)
	  }
	  inc (release, identifier, identifierBase) {
	    switch (release) {
	      case 'premajor':
	        this.prerelease.length = 0;
	        this.patch = 0;
	        this.minor = 0;
	        this.major++;
	        this.inc('pre', identifier, identifierBase);
	        break
	      case 'preminor':
	        this.prerelease.length = 0;
	        this.patch = 0;
	        this.minor++;
	        this.inc('pre', identifier, identifierBase);
	        break
	      case 'prepatch':
	        this.prerelease.length = 0;
	        this.inc('patch', identifier, identifierBase);
	        this.inc('pre', identifier, identifierBase);
	        break
	      case 'prerelease':
	        if (this.prerelease.length === 0) {
	          this.inc('patch', identifier, identifierBase);
	        }
	        this.inc('pre', identifier, identifierBase);
	        break
	      case 'major':
	        if (
	          this.minor !== 0 ||
	          this.patch !== 0 ||
	          this.prerelease.length === 0
	        ) {
	          this.major++;
	        }
	        this.minor = 0;
	        this.patch = 0;
	        this.prerelease = [];
	        break
	      case 'minor':
	        if (this.patch !== 0 || this.prerelease.length === 0) {
	          this.minor++;
	        }
	        this.patch = 0;
	        this.prerelease = [];
	        break
	      case 'patch':
	        if (this.prerelease.length === 0) {
	          this.patch++;
	        }
	        this.prerelease = [];
	        break
	      case 'pre': {
	        const base = Number(identifierBase) ? 1 : 0;
	        if (!identifier && identifierBase === false) {
	          throw new Error('invalid increment argument: identifier is empty')
	        }
	        if (this.prerelease.length === 0) {
	          this.prerelease = [base];
	        } else {
	          let i = this.prerelease.length;
	          while (--i >= 0) {
	            if (typeof this.prerelease[i] === 'number') {
	              this.prerelease[i]++;
	              i = -2;
	            }
	          }
	          if (i === -1) {
	            if (identifier === this.prerelease.join('.') && identifierBase === false) {
	              throw new Error('invalid increment argument: identifier already exists')
	            }
	            this.prerelease.push(base);
	          }
	        }
	        if (identifier) {
	          let prerelease = [identifier, base];
	          if (identifierBase === false) {
	            prerelease = [identifier];
	          }
	          if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
	            if (isNaN(this.prerelease[1])) {
	              this.prerelease = prerelease;
	            }
	          } else {
	            this.prerelease = prerelease;
	          }
	        }
	        break
	      }
	      default:
	        throw new Error(`invalid increment argument: ${release}`)
	    }
	    this.raw = this.format();
	    if (this.build.length) {
	      this.raw += `+${this.build.join('.')}`;
	    }
	    return this
	  }
	};
	var semver$2 = SemVer$d;
	getDefaultExportFromCjs(semver$2);

	const SemVer$c = semver$2;
	const parse$6 = (version, options, throwErrors = false) => {
	  if (version instanceof SemVer$c) {
	    return version
	  }
	  try {
	    return new SemVer$c(version, options)
	  } catch (er) {
	    if (!throwErrors) {
	      return null
	    }
	    throw er
	  }
	};
	var parse_1 = parse$6;
	getDefaultExportFromCjs(parse_1);

	const parse$5 = parse_1;
	const valid$2 = (version, options) => {
	  const v = parse$5(version, options);
	  return v ? v.version : null
	};
	var valid_1 = valid$2;
	getDefaultExportFromCjs(valid_1);

	const parse$4 = parse_1;
	const clean$1 = (version, options) => {
	  const s = parse$4(version.trim().replace(/^[=v]+/, ''), options);
	  return s ? s.version : null
	};
	var clean_1 = clean$1;
	getDefaultExportFromCjs(clean_1);

	const SemVer$b = semver$2;
	const inc$1 = (version, release, options, identifier, identifierBase) => {
	  if (typeof (options) === 'string') {
	    identifierBase = identifier;
	    identifier = options;
	    options = undefined;
	  }
	  try {
	    return new SemVer$b(
	      version instanceof SemVer$b ? version.version : version,
	      options
	    ).inc(release, identifier, identifierBase).version
	  } catch (er) {
	    return null
	  }
	};
	var inc_1 = inc$1;
	getDefaultExportFromCjs(inc_1);

	const parse$3 = parse_1;
	const diff$1 = (version1, version2) => {
	  const v1 = parse$3(version1, null, true);
	  const v2 = parse$3(version2, null, true);
	  const comparison = v1.compare(v2);
	  if (comparison === 0) {
	    return null
	  }
	  const v1Higher = comparison > 0;
	  const highVersion = v1Higher ? v1 : v2;
	  const lowVersion = v1Higher ? v2 : v1;
	  const highHasPre = !!highVersion.prerelease.length;
	  const lowHasPre = !!lowVersion.prerelease.length;
	  if (lowHasPre && !highHasPre) {
	    if (!lowVersion.patch && !lowVersion.minor) {
	      return 'major'
	    }
	    if (highVersion.patch) {
	      return 'patch'
	    }
	    if (highVersion.minor) {
	      return 'minor'
	    }
	    return 'major'
	  }
	  const prefix = highHasPre ? 'pre' : '';
	  if (v1.major !== v2.major) {
	    return prefix + 'major'
	  }
	  if (v1.minor !== v2.minor) {
	    return prefix + 'minor'
	  }
	  if (v1.patch !== v2.patch) {
	    return prefix + 'patch'
	  }
	  return 'prerelease'
	};
	var diff_1 = diff$1;
	getDefaultExportFromCjs(diff_1);

	const SemVer$a = semver$2;
	const major$1 = (a, loose) => new SemVer$a(a, loose).major;
	var major_1 = major$1;
	getDefaultExportFromCjs(major_1);

	const SemVer$9 = semver$2;
	const minor$1 = (a, loose) => new SemVer$9(a, loose).minor;
	var minor_1 = minor$1;
	getDefaultExportFromCjs(minor_1);

	const SemVer$8 = semver$2;
	const patch$1 = (a, loose) => new SemVer$8(a, loose).patch;
	var patch_1 = patch$1;
	getDefaultExportFromCjs(patch_1);

	const parse$2 = parse_1;
	const prerelease$1 = (version, options) => {
	  const parsed = parse$2(version, options);
	  return (parsed && parsed.prerelease.length) ? parsed.prerelease : null
	};
	var prerelease_1 = prerelease$1;
	getDefaultExportFromCjs(prerelease_1);

	const SemVer$7 = semver$2;
	const compare$b = (a, b, loose) =>
	  new SemVer$7(a, loose).compare(new SemVer$7(b, loose));
	var compare_1 = compare$b;
	getDefaultExportFromCjs(compare_1);

	const compare$a = compare_1;
	const rcompare$1 = (a, b, loose) => compare$a(b, a, loose);
	var rcompare_1 = rcompare$1;
	getDefaultExportFromCjs(rcompare_1);

	const compare$9 = compare_1;
	const compareLoose$1 = (a, b) => compare$9(a, b, true);
	var compareLoose_1 = compareLoose$1;
	getDefaultExportFromCjs(compareLoose_1);

	const SemVer$6 = semver$2;
	const compareBuild$3 = (a, b, loose) => {
	  const versionA = new SemVer$6(a, loose);
	  const versionB = new SemVer$6(b, loose);
	  return versionA.compare(versionB) || versionA.compareBuild(versionB)
	};
	var compareBuild_1 = compareBuild$3;
	getDefaultExportFromCjs(compareBuild_1);

	const compareBuild$2 = compareBuild_1;
	const sort$1 = (list, loose) => list.sort((a, b) => compareBuild$2(a, b, loose));
	var sort_1 = sort$1;
	getDefaultExportFromCjs(sort_1);

	const compareBuild$1 = compareBuild_1;
	const rsort$1 = (list, loose) => list.sort((a, b) => compareBuild$1(b, a, loose));
	var rsort_1 = rsort$1;
	getDefaultExportFromCjs(rsort_1);

	const compare$8 = compare_1;
	const gt$4 = (a, b, loose) => compare$8(a, b, loose) > 0;
	var gt_1 = gt$4;
	getDefaultExportFromCjs(gt_1);

	const compare$7 = compare_1;
	const lt$3 = (a, b, loose) => compare$7(a, b, loose) < 0;
	var lt_1 = lt$3;
	getDefaultExportFromCjs(lt_1);

	const compare$6 = compare_1;
	const eq$2 = (a, b, loose) => compare$6(a, b, loose) === 0;
	var eq_1 = eq$2;
	getDefaultExportFromCjs(eq_1);

	const compare$5 = compare_1;
	const neq$2 = (a, b, loose) => compare$5(a, b, loose) !== 0;
	var neq_1 = neq$2;
	getDefaultExportFromCjs(neq_1);

	const compare$4 = compare_1;
	const gte$3 = (a, b, loose) => compare$4(a, b, loose) >= 0;
	var gte_1 = gte$3;
	getDefaultExportFromCjs(gte_1);

	const compare$3 = compare_1;
	const lte$3 = (a, b, loose) => compare$3(a, b, loose) <= 0;
	var lte_1 = lte$3;
	getDefaultExportFromCjs(lte_1);

	const eq$1 = eq_1;
	const neq$1 = neq_1;
	const gt$3 = gt_1;
	const gte$2 = gte_1;
	const lt$2 = lt_1;
	const lte$2 = lte_1;
	const cmp$1 = (a, op, b, loose) => {
	  switch (op) {
	    case '===':
	      if (typeof a === 'object') {
	        a = a.version;
	      }
	      if (typeof b === 'object') {
	        b = b.version;
	      }
	      return a === b
	    case '!==':
	      if (typeof a === 'object') {
	        a = a.version;
	      }
	      if (typeof b === 'object') {
	        b = b.version;
	      }
	      return a !== b
	    case '':
	    case '=':
	    case '==':
	      return eq$1(a, b, loose)
	    case '!=':
	      return neq$1(a, b, loose)
	    case '>':
	      return gt$3(a, b, loose)
	    case '>=':
	      return gte$2(a, b, loose)
	    case '<':
	      return lt$2(a, b, loose)
	    case '<=':
	      return lte$2(a, b, loose)
	    default:
	      throw new TypeError(`Invalid operator: ${op}`)
	  }
	};
	var cmp_1 = cmp$1;
	getDefaultExportFromCjs(cmp_1);

	const SemVer$5 = semver$2;
	const parse$1 = parse_1;
	const { safeRe: re, t } = reExports;
	const coerce$1 = (version, options) => {
	  if (version instanceof SemVer$5) {
	    return version
	  }
	  if (typeof version === 'number') {
	    version = String(version);
	  }
	  if (typeof version !== 'string') {
	    return null
	  }
	  options = options || {};
	  let match = null;
	  if (!options.rtl) {
	    match = version.match(re[t.COERCE]);
	  } else {
	    let next;
	    while ((next = re[t.COERCERTL].exec(version)) &&
	        (!match || match.index + match[0].length !== version.length)
	    ) {
	      if (!match ||
	            next.index + next[0].length !== match.index + match[0].length) {
	        match = next;
	      }
	      re[t.COERCERTL].lastIndex = next.index + next[1].length + next[2].length;
	    }
	    re[t.COERCERTL].lastIndex = -1;
	  }
	  if (match === null) {
	    return null
	  }
	  return parse$1(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
	};
	var coerce_1 = coerce$1;
	getDefaultExportFromCjs(coerce_1);

	var iterator;
	var hasRequiredIterator;
	function requireIterator () {
		if (hasRequiredIterator) return iterator;
		hasRequiredIterator = 1;
		iterator = function (Yallist) {
		  Yallist.prototype[Symbol.iterator] = function* () {
		    for (let walker = this.head; walker; walker = walker.next) {
		      yield walker.value;
		    }
		  };
		};
		return iterator;
	}

	var yallist;
	var hasRequiredYallist;
	function requireYallist () {
		if (hasRequiredYallist) return yallist;
		hasRequiredYallist = 1;
		yallist = Yallist;
		Yallist.Node = Node;
		Yallist.create = Yallist;
		function Yallist (list) {
		  var self = this;
		  if (!(self instanceof Yallist)) {
		    self = new Yallist();
		  }
		  self.tail = null;
		  self.head = null;
		  self.length = 0;
		  if (list && typeof list.forEach === 'function') {
		    list.forEach(function (item) {
		      self.push(item);
		    });
		  } else if (arguments.length > 0) {
		    for (var i = 0, l = arguments.length; i < l; i++) {
		      self.push(arguments[i]);
		    }
		  }
		  return self
		}
		Yallist.prototype.removeNode = function (node) {
		  if (node.list !== this) {
		    throw new Error('removing node which does not belong to this list')
		  }
		  var next = node.next;
		  var prev = node.prev;
		  if (next) {
		    next.prev = prev;
		  }
		  if (prev) {
		    prev.next = next;
		  }
		  if (node === this.head) {
		    this.head = next;
		  }
		  if (node === this.tail) {
		    this.tail = prev;
		  }
		  node.list.length--;
		  node.next = null;
		  node.prev = null;
		  node.list = null;
		  return next
		};
		Yallist.prototype.unshiftNode = function (node) {
		  if (node === this.head) {
		    return
		  }
		  if (node.list) {
		    node.list.removeNode(node);
		  }
		  var head = this.head;
		  node.list = this;
		  node.next = head;
		  if (head) {
		    head.prev = node;
		  }
		  this.head = node;
		  if (!this.tail) {
		    this.tail = node;
		  }
		  this.length++;
		};
		Yallist.prototype.pushNode = function (node) {
		  if (node === this.tail) {
		    return
		  }
		  if (node.list) {
		    node.list.removeNode(node);
		  }
		  var tail = this.tail;
		  node.list = this;
		  node.prev = tail;
		  if (tail) {
		    tail.next = node;
		  }
		  this.tail = node;
		  if (!this.head) {
		    this.head = node;
		  }
		  this.length++;
		};
		Yallist.prototype.push = function () {
		  for (var i = 0, l = arguments.length; i < l; i++) {
		    push(this, arguments[i]);
		  }
		  return this.length
		};
		Yallist.prototype.unshift = function () {
		  for (var i = 0, l = arguments.length; i < l; i++) {
		    unshift(this, arguments[i]);
		  }
		  return this.length
		};
		Yallist.prototype.pop = function () {
		  if (!this.tail) {
		    return undefined
		  }
		  var res = this.tail.value;
		  this.tail = this.tail.prev;
		  if (this.tail) {
		    this.tail.next = null;
		  } else {
		    this.head = null;
		  }
		  this.length--;
		  return res
		};
		Yallist.prototype.shift = function () {
		  if (!this.head) {
		    return undefined
		  }
		  var res = this.head.value;
		  this.head = this.head.next;
		  if (this.head) {
		    this.head.prev = null;
		  } else {
		    this.tail = null;
		  }
		  this.length--;
		  return res
		};
		Yallist.prototype.forEach = function (fn, thisp) {
		  thisp = thisp || this;
		  for (var walker = this.head, i = 0; walker !== null; i++) {
		    fn.call(thisp, walker.value, i, this);
		    walker = walker.next;
		  }
		};
		Yallist.prototype.forEachReverse = function (fn, thisp) {
		  thisp = thisp || this;
		  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
		    fn.call(thisp, walker.value, i, this);
		    walker = walker.prev;
		  }
		};
		Yallist.prototype.get = function (n) {
		  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
		    walker = walker.next;
		  }
		  if (i === n && walker !== null) {
		    return walker.value
		  }
		};
		Yallist.prototype.getReverse = function (n) {
		  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
		    walker = walker.prev;
		  }
		  if (i === n && walker !== null) {
		    return walker.value
		  }
		};
		Yallist.prototype.map = function (fn, thisp) {
		  thisp = thisp || this;
		  var res = new Yallist();
		  for (var walker = this.head; walker !== null;) {
		    res.push(fn.call(thisp, walker.value, this));
		    walker = walker.next;
		  }
		  return res
		};
		Yallist.prototype.mapReverse = function (fn, thisp) {
		  thisp = thisp || this;
		  var res = new Yallist();
		  for (var walker = this.tail; walker !== null;) {
		    res.push(fn.call(thisp, walker.value, this));
		    walker = walker.prev;
		  }
		  return res
		};
		Yallist.prototype.reduce = function (fn, initial) {
		  var acc;
		  var walker = this.head;
		  if (arguments.length > 1) {
		    acc = initial;
		  } else if (this.head) {
		    walker = this.head.next;
		    acc = this.head.value;
		  } else {
		    throw new TypeError('Reduce of empty list with no initial value')
		  }
		  for (var i = 0; walker !== null; i++) {
		    acc = fn(acc, walker.value, i);
		    walker = walker.next;
		  }
		  return acc
		};
		Yallist.prototype.reduceReverse = function (fn, initial) {
		  var acc;
		  var walker = this.tail;
		  if (arguments.length > 1) {
		    acc = initial;
		  } else if (this.tail) {
		    walker = this.tail.prev;
		    acc = this.tail.value;
		  } else {
		    throw new TypeError('Reduce of empty list with no initial value')
		  }
		  for (var i = this.length - 1; walker !== null; i--) {
		    acc = fn(acc, walker.value, i);
		    walker = walker.prev;
		  }
		  return acc
		};
		Yallist.prototype.toArray = function () {
		  var arr = new Array(this.length);
		  for (var i = 0, walker = this.head; walker !== null; i++) {
		    arr[i] = walker.value;
		    walker = walker.next;
		  }
		  return arr
		};
		Yallist.prototype.toArrayReverse = function () {
		  var arr = new Array(this.length);
		  for (var i = 0, walker = this.tail; walker !== null; i++) {
		    arr[i] = walker.value;
		    walker = walker.prev;
		  }
		  return arr
		};
		Yallist.prototype.slice = function (from, to) {
		  to = to || this.length;
		  if (to < 0) {
		    to += this.length;
		  }
		  from = from || 0;
		  if (from < 0) {
		    from += this.length;
		  }
		  var ret = new Yallist();
		  if (to < from || to < 0) {
		    return ret
		  }
		  if (from < 0) {
		    from = 0;
		  }
		  if (to > this.length) {
		    to = this.length;
		  }
		  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
		    walker = walker.next;
		  }
		  for (; walker !== null && i < to; i++, walker = walker.next) {
		    ret.push(walker.value);
		  }
		  return ret
		};
		Yallist.prototype.sliceReverse = function (from, to) {
		  to = to || this.length;
		  if (to < 0) {
		    to += this.length;
		  }
		  from = from || 0;
		  if (from < 0) {
		    from += this.length;
		  }
		  var ret = new Yallist();
		  if (to < from || to < 0) {
		    return ret
		  }
		  if (from < 0) {
		    from = 0;
		  }
		  if (to > this.length) {
		    to = this.length;
		  }
		  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
		    walker = walker.prev;
		  }
		  for (; walker !== null && i > from; i--, walker = walker.prev) {
		    ret.push(walker.value);
		  }
		  return ret
		};
		Yallist.prototype.splice = function (start, deleteCount, ...nodes) {
		  if (start > this.length) {
		    start = this.length - 1;
		  }
		  if (start < 0) {
		    start = this.length + start;
		  }
		  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
		    walker = walker.next;
		  }
		  var ret = [];
		  for (var i = 0; walker && i < deleteCount; i++) {
		    ret.push(walker.value);
		    walker = this.removeNode(walker);
		  }
		  if (walker === null) {
		    walker = this.tail;
		  }
		  if (walker !== this.head && walker !== this.tail) {
		    walker = walker.prev;
		  }
		  for (var i = 0; i < nodes.length; i++) {
		    walker = insert(this, walker, nodes[i]);
		  }
		  return ret;
		};
		Yallist.prototype.reverse = function () {
		  var head = this.head;
		  var tail = this.tail;
		  for (var walker = head; walker !== null; walker = walker.prev) {
		    var p = walker.prev;
		    walker.prev = walker.next;
		    walker.next = p;
		  }
		  this.head = tail;
		  this.tail = head;
		  return this
		};
		function insert (self, node, value) {
		  var inserted = node === self.head ?
		    new Node(value, null, node, self) :
		    new Node(value, node, node.next, self);
		  if (inserted.next === null) {
		    self.tail = inserted;
		  }
		  if (inserted.prev === null) {
		    self.head = inserted;
		  }
		  self.length++;
		  return inserted
		}
		function push (self, item) {
		  self.tail = new Node(item, self.tail, null, self);
		  if (!self.head) {
		    self.head = self.tail;
		  }
		  self.length++;
		}
		function unshift (self, item) {
		  self.head = new Node(item, null, self.head, self);
		  if (!self.tail) {
		    self.tail = self.head;
		  }
		  self.length++;
		}
		function Node (value, prev, next, list) {
		  if (!(this instanceof Node)) {
		    return new Node(value, prev, next, list)
		  }
		  this.list = list;
		  this.value = value;
		  if (prev) {
		    prev.next = this;
		    this.prev = prev;
		  } else {
		    this.prev = null;
		  }
		  if (next) {
		    next.prev = this;
		    this.next = next;
		  } else {
		    this.next = null;
		  }
		}
		try {
		  requireIterator()(Yallist);
		} catch (er) {}
		return yallist;
	}

	var lruCache;
	var hasRequiredLruCache;
	function requireLruCache () {
		if (hasRequiredLruCache) return lruCache;
		hasRequiredLruCache = 1;
		const Yallist = requireYallist();
		const MAX = Symbol('max');
		const LENGTH = Symbol('length');
		const LENGTH_CALCULATOR = Symbol('lengthCalculator');
		const ALLOW_STALE = Symbol('allowStale');
		const MAX_AGE = Symbol('maxAge');
		const DISPOSE = Symbol('dispose');
		const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
		const LRU_LIST = Symbol('lruList');
		const CACHE = Symbol('cache');
		const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
		const naiveLength = () => 1;
		class LRUCache {
		  constructor (options) {
		    if (typeof options === 'number')
		      options = { max: options };
		    if (!options)
		      options = {};
		    if (options.max && (typeof options.max !== 'number' || options.max < 0))
		      throw new TypeError('max must be a non-negative number')
		    this[MAX] = options.max || Infinity;
		    const lc = options.length || naiveLength;
		    this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc;
		    this[ALLOW_STALE] = options.stale || false;
		    if (options.maxAge && typeof options.maxAge !== 'number')
		      throw new TypeError('maxAge must be a number')
		    this[MAX_AGE] = options.maxAge || 0;
		    this[DISPOSE] = options.dispose;
		    this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
		    this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
		    this.reset();
		  }
		  set max (mL) {
		    if (typeof mL !== 'number' || mL < 0)
		      throw new TypeError('max must be a non-negative number')
		    this[MAX] = mL || Infinity;
		    trim(this);
		  }
		  get max () {
		    return this[MAX]
		  }
		  set allowStale (allowStale) {
		    this[ALLOW_STALE] = !!allowStale;
		  }
		  get allowStale () {
		    return this[ALLOW_STALE]
		  }
		  set maxAge (mA) {
		    if (typeof mA !== 'number')
		      throw new TypeError('maxAge must be a non-negative number')
		    this[MAX_AGE] = mA;
		    trim(this);
		  }
		  get maxAge () {
		    return this[MAX_AGE]
		  }
		  set lengthCalculator (lC) {
		    if (typeof lC !== 'function')
		      lC = naiveLength;
		    if (lC !== this[LENGTH_CALCULATOR]) {
		      this[LENGTH_CALCULATOR] = lC;
		      this[LENGTH] = 0;
		      this[LRU_LIST].forEach(hit => {
		        hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
		        this[LENGTH] += hit.length;
		      });
		    }
		    trim(this);
		  }
		  get lengthCalculator () { return this[LENGTH_CALCULATOR] }
		  get length () { return this[LENGTH] }
		  get itemCount () { return this[LRU_LIST].length }
		  rforEach (fn, thisp) {
		    thisp = thisp || this;
		    for (let walker = this[LRU_LIST].tail; walker !== null;) {
		      const prev = walker.prev;
		      forEachStep(this, fn, walker, thisp);
		      walker = prev;
		    }
		  }
		  forEach (fn, thisp) {
		    thisp = thisp || this;
		    for (let walker = this[LRU_LIST].head; walker !== null;) {
		      const next = walker.next;
		      forEachStep(this, fn, walker, thisp);
		      walker = next;
		    }
		  }
		  keys () {
		    return this[LRU_LIST].toArray().map(k => k.key)
		  }
		  values () {
		    return this[LRU_LIST].toArray().map(k => k.value)
		  }
		  reset () {
		    if (this[DISPOSE] &&
		        this[LRU_LIST] &&
		        this[LRU_LIST].length) {
		      this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value));
		    }
		    this[CACHE] = new Map();
		    this[LRU_LIST] = new Yallist();
		    this[LENGTH] = 0;
		  }
		  dump () {
		    return this[LRU_LIST].map(hit =>
		      isStale(this, hit) ? false : {
		        k: hit.key,
		        v: hit.value,
		        e: hit.now + (hit.maxAge || 0)
		      }).toArray().filter(h => h)
		  }
		  dumpLru () {
		    return this[LRU_LIST]
		  }
		  set (key, value, maxAge) {
		    maxAge = maxAge || this[MAX_AGE];
		    if (maxAge && typeof maxAge !== 'number')
		      throw new TypeError('maxAge must be a number')
		    const now = maxAge ? Date.now() : 0;
		    const len = this[LENGTH_CALCULATOR](value, key);
		    if (this[CACHE].has(key)) {
		      if (len > this[MAX]) {
		        del(this, this[CACHE].get(key));
		        return false
		      }
		      const node = this[CACHE].get(key);
		      const item = node.value;
		      if (this[DISPOSE]) {
		        if (!this[NO_DISPOSE_ON_SET])
		          this[DISPOSE](key, item.value);
		      }
		      item.now = now;
		      item.maxAge = maxAge;
		      item.value = value;
		      this[LENGTH] += len - item.length;
		      item.length = len;
		      this.get(key);
		      trim(this);
		      return true
		    }
		    const hit = new Entry(key, value, len, now, maxAge);
		    if (hit.length > this[MAX]) {
		      if (this[DISPOSE])
		        this[DISPOSE](key, value);
		      return false
		    }
		    this[LENGTH] += hit.length;
		    this[LRU_LIST].unshift(hit);
		    this[CACHE].set(key, this[LRU_LIST].head);
		    trim(this);
		    return true
		  }
		  has (key) {
		    if (!this[CACHE].has(key)) return false
		    const hit = this[CACHE].get(key).value;
		    return !isStale(this, hit)
		  }
		  get (key) {
		    return get(this, key, true)
		  }
		  peek (key) {
		    return get(this, key, false)
		  }
		  pop () {
		    const node = this[LRU_LIST].tail;
		    if (!node)
		      return null
		    del(this, node);
		    return node.value
		  }
		  del (key) {
		    del(this, this[CACHE].get(key));
		  }
		  load (arr) {
		    this.reset();
		    const now = Date.now();
		    for (let l = arr.length - 1; l >= 0; l--) {
		      const hit = arr[l];
		      const expiresAt = hit.e || 0;
		      if (expiresAt === 0)
		        this.set(hit.k, hit.v);
		      else {
		        const maxAge = expiresAt - now;
		        if (maxAge > 0) {
		          this.set(hit.k, hit.v, maxAge);
		        }
		      }
		    }
		  }
		  prune () {
		    this[CACHE].forEach((value, key) => get(this, key, false));
		  }
		}
		const get = (self, key, doUse) => {
		  const node = self[CACHE].get(key);
		  if (node) {
		    const hit = node.value;
		    if (isStale(self, hit)) {
		      del(self, node);
		      if (!self[ALLOW_STALE])
		        return undefined
		    } else {
		      if (doUse) {
		        if (self[UPDATE_AGE_ON_GET])
		          node.value.now = Date.now();
		        self[LRU_LIST].unshiftNode(node);
		      }
		    }
		    return hit.value
		  }
		};
		const isStale = (self, hit) => {
		  if (!hit || (!hit.maxAge && !self[MAX_AGE]))
		    return false
		  const diff = Date.now() - hit.now;
		  return hit.maxAge ? diff > hit.maxAge
		    : self[MAX_AGE] && (diff > self[MAX_AGE])
		};
		const trim = self => {
		  if (self[LENGTH] > self[MAX]) {
		    for (let walker = self[LRU_LIST].tail;
		      self[LENGTH] > self[MAX] && walker !== null;) {
		      const prev = walker.prev;
		      del(self, walker);
		      walker = prev;
		    }
		  }
		};
		const del = (self, node) => {
		  if (node) {
		    const hit = node.value;
		    if (self[DISPOSE])
		      self[DISPOSE](hit.key, hit.value);
		    self[LENGTH] -= hit.length;
		    self[CACHE].delete(hit.key);
		    self[LRU_LIST].removeNode(node);
		  }
		};
		class Entry {
		  constructor (key, value, length, now, maxAge) {
		    this.key = key;
		    this.value = value;
		    this.length = length;
		    this.now = now;
		    this.maxAge = maxAge || 0;
		  }
		}
		const forEachStep = (self, fn, node, thisp) => {
		  let hit = node.value;
		  if (isStale(self, hit)) {
		    del(self, node);
		    if (!self[ALLOW_STALE])
		      hit = undefined;
		  }
		  if (hit)
		    fn.call(thisp, hit.value, hit.key, self);
		};
		lruCache = LRUCache;
		return lruCache;
	}

	var range;
	var hasRequiredRange;
	function requireRange () {
		if (hasRequiredRange) return range;
		hasRequiredRange = 1;
		class Range {
		  constructor (range, options) {
		    options = parseOptions(options);
		    if (range instanceof Range) {
		      if (
		        range.loose === !!options.loose &&
		        range.includePrerelease === !!options.includePrerelease
		      ) {
		        return range
		      } else {
		        return new Range(range.raw, options)
		      }
		    }
		    if (range instanceof Comparator) {
		      this.raw = range.value;
		      this.set = [[range]];
		      this.format();
		      return this
		    }
		    this.options = options;
		    this.loose = !!options.loose;
		    this.includePrerelease = !!options.includePrerelease;
		    this.raw = range
		      .trim()
		      .split(/\s+/)
		      .join(' ');
		    this.set = this.raw
		      .split('||')
		      .map(r => this.parseRange(r.trim()))
		      .filter(c => c.length);
		    if (!this.set.length) {
		      throw new TypeError(`Invalid SemVer Range: ${this.raw}`)
		    }
		    if (this.set.length > 1) {
		      const first = this.set[0];
		      this.set = this.set.filter(c => !isNullSet(c[0]));
		      if (this.set.length === 0) {
		        this.set = [first];
		      } else if (this.set.length > 1) {
		        for (const c of this.set) {
		          if (c.length === 1 && isAny(c[0])) {
		            this.set = [c];
		            break
		          }
		        }
		      }
		    }
		    this.format();
		  }
		  format () {
		    this.range = this.set
		      .map((comps) => comps.join(' ').trim())
		      .join('||')
		      .trim();
		    return this.range
		  }
		  toString () {
		    return this.range
		  }
		  parseRange (range) {
		    const memoOpts =
		      (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) |
		      (this.options.loose && FLAG_LOOSE);
		    const memoKey = memoOpts + ':' + range;
		    const cached = cache.get(memoKey);
		    if (cached) {
		      return cached
		    }
		    const loose = this.options.loose;
		    const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
		    range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
		    debug('hyphen replace', range);
		    range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
		    debug('comparator trim', range);
		    range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
		    debug('tilde trim', range);
		    range = range.replace(re[t.CARETTRIM], caretTrimReplace);
		    debug('caret trim', range);
		    let rangeList = range
		      .split(' ')
		      .map(comp => parseComparator(comp, this.options))
		      .join(' ')
		      .split(/\s+/)
		      .map(comp => replaceGTE0(comp, this.options));
		    if (loose) {
		      rangeList = rangeList.filter(comp => {
		        debug('loose invalid filter', comp, this.options);
		        return !!comp.match(re[t.COMPARATORLOOSE])
		      });
		    }
		    debug('range list', rangeList);
		    const rangeMap = new Map();
		    const comparators = rangeList.map(comp => new Comparator(comp, this.options));
		    for (const comp of comparators) {
		      if (isNullSet(comp)) {
		        return [comp]
		      }
		      rangeMap.set(comp.value, comp);
		    }
		    if (rangeMap.size > 1 && rangeMap.has('')) {
		      rangeMap.delete('');
		    }
		    const result = [...rangeMap.values()];
		    cache.set(memoKey, result);
		    return result
		  }
		  intersects (range, options) {
		    if (!(range instanceof Range)) {
		      throw new TypeError('a Range is required')
		    }
		    return this.set.some((thisComparators) => {
		      return (
		        isSatisfiable(thisComparators, options) &&
		        range.set.some((rangeComparators) => {
		          return (
		            isSatisfiable(rangeComparators, options) &&
		            thisComparators.every((thisComparator) => {
		              return rangeComparators.every((rangeComparator) => {
		                return thisComparator.intersects(rangeComparator, options)
		              })
		            })
		          )
		        })
		      )
		    })
		  }
		  test (version) {
		    if (!version) {
		      return false
		    }
		    if (typeof version === 'string') {
		      try {
		        version = new SemVer(version, this.options);
		      } catch (er) {
		        return false
		      }
		    }
		    for (let i = 0; i < this.set.length; i++) {
		      if (testSet(this.set[i], version, this.options)) {
		        return true
		      }
		    }
		    return false
		  }
		}
		range = Range;
		const LRU = requireLruCache();
		const cache = new LRU({ max: 1000 });
		const parseOptions = parseOptions_1;
		const Comparator = requireComparator();
		const debug = debug_1;
		const SemVer = semver$2;
		const {
		  safeRe: re,
		  t,
		  comparatorTrimReplace,
		  tildeTrimReplace,
		  caretTrimReplace,
		} = reExports;
		const { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = constants$1;
		const isNullSet = c => c.value === '<0.0.0-0';
		const isAny = c => c.value === '';
		const isSatisfiable = (comparators, options) => {
		  let result = true;
		  const remainingComparators = comparators.slice();
		  let testComparator = remainingComparators.pop();
		  while (result && remainingComparators.length) {
		    result = remainingComparators.every((otherComparator) => {
		      return testComparator.intersects(otherComparator, options)
		    });
		    testComparator = remainingComparators.pop();
		  }
		  return result
		};
		const parseComparator = (comp, options) => {
		  debug('comp', comp, options);
		  comp = replaceCarets(comp, options);
		  debug('caret', comp);
		  comp = replaceTildes(comp, options);
		  debug('tildes', comp);
		  comp = replaceXRanges(comp, options);
		  debug('xrange', comp);
		  comp = replaceStars(comp, options);
		  debug('stars', comp);
		  return comp
		};
		const isX = id => !id || id.toLowerCase() === 'x' || id === '*';
		const replaceTildes = (comp, options) => {
		  return comp
		    .trim()
		    .split(/\s+/)
		    .map((c) => replaceTilde(c, options))
		    .join(' ')
		};
		const replaceTilde = (comp, options) => {
		  const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
		  return comp.replace(r, (_, M, m, p, pr) => {
		    debug('tilde', comp, _, M, m, p, pr);
		    let ret;
		    if (isX(M)) {
		      ret = '';
		    } else if (isX(m)) {
		      ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
		    } else if (isX(p)) {
		      ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
		    } else if (pr) {
		      debug('replaceTilde pr', pr);
		      ret = `>=${M}.${m}.${p}-${pr
	      } <${M}.${+m + 1}.0-0`;
		    } else {
		      ret = `>=${M}.${m}.${p
	      } <${M}.${+m + 1}.0-0`;
		    }
		    debug('tilde return', ret);
		    return ret
		  })
		};
		const replaceCarets = (comp, options) => {
		  return comp
		    .trim()
		    .split(/\s+/)
		    .map((c) => replaceCaret(c, options))
		    .join(' ')
		};
		const replaceCaret = (comp, options) => {
		  debug('caret', comp, options);
		  const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
		  const z = options.includePrerelease ? '-0' : '';
		  return comp.replace(r, (_, M, m, p, pr) => {
		    debug('caret', comp, _, M, m, p, pr);
		    let ret;
		    if (isX(M)) {
		      ret = '';
		    } else if (isX(m)) {
		      ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
		    } else if (isX(p)) {
		      if (M === '0') {
		        ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
		      } else {
		        ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
		      }
		    } else if (pr) {
		      debug('replaceCaret pr', pr);
		      if (M === '0') {
		        if (m === '0') {
		          ret = `>=${M}.${m}.${p}-${pr
	          } <${M}.${m}.${+p + 1}-0`;
		        } else {
		          ret = `>=${M}.${m}.${p}-${pr
	          } <${M}.${+m + 1}.0-0`;
		        }
		      } else {
		        ret = `>=${M}.${m}.${p}-${pr
	        } <${+M + 1}.0.0-0`;
		      }
		    } else {
		      debug('no pr');
		      if (M === '0') {
		        if (m === '0') {
		          ret = `>=${M}.${m}.${p
	          }${z} <${M}.${m}.${+p + 1}-0`;
		        } else {
		          ret = `>=${M}.${m}.${p
	          }${z} <${M}.${+m + 1}.0-0`;
		        }
		      } else {
		        ret = `>=${M}.${m}.${p
	        } <${+M + 1}.0.0-0`;
		      }
		    }
		    debug('caret return', ret);
		    return ret
		  })
		};
		const replaceXRanges = (comp, options) => {
		  debug('replaceXRanges', comp, options);
		  return comp
		    .split(/\s+/)
		    .map((c) => replaceXRange(c, options))
		    .join(' ')
		};
		const replaceXRange = (comp, options) => {
		  comp = comp.trim();
		  const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
		  return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
		    debug('xRange', comp, ret, gtlt, M, m, p, pr);
		    const xM = isX(M);
		    const xm = xM || isX(m);
		    const xp = xm || isX(p);
		    const anyX = xp;
		    if (gtlt === '=' && anyX) {
		      gtlt = '';
		    }
		    pr = options.includePrerelease ? '-0' : '';
		    if (xM) {
		      if (gtlt === '>' || gtlt === '<') {
		        ret = '<0.0.0-0';
		      } else {
		        ret = '*';
		      }
		    } else if (gtlt && anyX) {
		      if (xm) {
		        m = 0;
		      }
		      p = 0;
		      if (gtlt === '>') {
		        gtlt = '>=';
		        if (xm) {
		          M = +M + 1;
		          m = 0;
		          p = 0;
		        } else {
		          m = +m + 1;
		          p = 0;
		        }
		      } else if (gtlt === '<=') {
		        gtlt = '<';
		        if (xm) {
		          M = +M + 1;
		        } else {
		          m = +m + 1;
		        }
		      }
		      if (gtlt === '<') {
		        pr = '-0';
		      }
		      ret = `${gtlt + M}.${m}.${p}${pr}`;
		    } else if (xm) {
		      ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
		    } else if (xp) {
		      ret = `>=${M}.${m}.0${pr
	      } <${M}.${+m + 1}.0-0`;
		    }
		    debug('xRange return', ret);
		    return ret
		  })
		};
		const replaceStars = (comp, options) => {
		  debug('replaceStars', comp, options);
		  return comp
		    .trim()
		    .replace(re[t.STAR], '')
		};
		const replaceGTE0 = (comp, options) => {
		  debug('replaceGTE0', comp, options);
		  return comp
		    .trim()
		    .replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], '')
		};
		const hyphenReplace = incPr => ($0,
		  from, fM, fm, fp, fpr, fb,
		  to, tM, tm, tp, tpr, tb) => {
		  if (isX(fM)) {
		    from = '';
		  } else if (isX(fm)) {
		    from = `>=${fM}.0.0${incPr ? '-0' : ''}`;
		  } else if (isX(fp)) {
		    from = `>=${fM}.${fm}.0${incPr ? '-0' : ''}`;
		  } else if (fpr) {
		    from = `>=${from}`;
		  } else {
		    from = `>=${from}${incPr ? '-0' : ''}`;
		  }
		  if (isX(tM)) {
		    to = '';
		  } else if (isX(tm)) {
		    to = `<${+tM + 1}.0.0-0`;
		  } else if (isX(tp)) {
		    to = `<${tM}.${+tm + 1}.0-0`;
		  } else if (tpr) {
		    to = `<=${tM}.${tm}.${tp}-${tpr}`;
		  } else if (incPr) {
		    to = `<${tM}.${tm}.${+tp + 1}-0`;
		  } else {
		    to = `<=${to}`;
		  }
		  return `${from} ${to}`.trim()
		};
		const testSet = (set, version, options) => {
		  for (let i = 0; i < set.length; i++) {
		    if (!set[i].test(version)) {
		      return false
		    }
		  }
		  if (version.prerelease.length && !options.includePrerelease) {
		    for (let i = 0; i < set.length; i++) {
		      debug(set[i].semver);
		      if (set[i].semver === Comparator.ANY) {
		        continue
		      }
		      if (set[i].semver.prerelease.length > 0) {
		        const allowed = set[i].semver;
		        if (allowed.major === version.major &&
		            allowed.minor === version.minor &&
		            allowed.patch === version.patch) {
		          return true
		        }
		      }
		    }
		    return false
		  }
		  return true
		};
		return range;
	}

	var comparator;
	var hasRequiredComparator;
	function requireComparator () {
		if (hasRequiredComparator) return comparator;
		hasRequiredComparator = 1;
		const ANY = Symbol('SemVer ANY');
		class Comparator {
		  static get ANY () {
		    return ANY
		  }
		  constructor (comp, options) {
		    options = parseOptions(options);
		    if (comp instanceof Comparator) {
		      if (comp.loose === !!options.loose) {
		        return comp
		      } else {
		        comp = comp.value;
		      }
		    }
		    comp = comp.trim().split(/\s+/).join(' ');
		    debug('comparator', comp, options);
		    this.options = options;
		    this.loose = !!options.loose;
		    this.parse(comp);
		    if (this.semver === ANY) {
		      this.value = '';
		    } else {
		      this.value = this.operator + this.semver.version;
		    }
		    debug('comp', this);
		  }
		  parse (comp) {
		    const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
		    const m = comp.match(r);
		    if (!m) {
		      throw new TypeError(`Invalid comparator: ${comp}`)
		    }
		    this.operator = m[1] !== undefined ? m[1] : '';
		    if (this.operator === '=') {
		      this.operator = '';
		    }
		    if (!m[2]) {
		      this.semver = ANY;
		    } else {
		      this.semver = new SemVer(m[2], this.options.loose);
		    }
		  }
		  toString () {
		    return this.value
		  }
		  test (version) {
		    debug('Comparator.test', version, this.options.loose);
		    if (this.semver === ANY || version === ANY) {
		      return true
		    }
		    if (typeof version === 'string') {
		      try {
		        version = new SemVer(version, this.options);
		      } catch (er) {
		        return false
		      }
		    }
		    return cmp(version, this.operator, this.semver, this.options)
		  }
		  intersects (comp, options) {
		    if (!(comp instanceof Comparator)) {
		      throw new TypeError('a Comparator is required')
		    }
		    if (this.operator === '') {
		      if (this.value === '') {
		        return true
		      }
		      return new Range(comp.value, options).test(this.value)
		    } else if (comp.operator === '') {
		      if (comp.value === '') {
		        return true
		      }
		      return new Range(this.value, options).test(comp.semver)
		    }
		    options = parseOptions(options);
		    if (options.includePrerelease &&
		      (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
		      return false
		    }
		    if (!options.includePrerelease &&
		      (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
		      return false
		    }
		    if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
		      return true
		    }
		    if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
		      return true
		    }
		    if (
		      (this.semver.version === comp.semver.version) &&
		      this.operator.includes('=') && comp.operator.includes('=')) {
		      return true
		    }
		    if (cmp(this.semver, '<', comp.semver, options) &&
		      this.operator.startsWith('>') && comp.operator.startsWith('<')) {
		      return true
		    }
		    if (cmp(this.semver, '>', comp.semver, options) &&
		      this.operator.startsWith('<') && comp.operator.startsWith('>')) {
		      return true
		    }
		    return false
		  }
		}
		comparator = Comparator;
		const parseOptions = parseOptions_1;
		const { safeRe: re, t } = reExports;
		const cmp = cmp_1;
		const debug = debug_1;
		const SemVer = semver$2;
		const Range = requireRange();
		return comparator;
	}

	const Range$9 = requireRange();
	const satisfies$4 = (version, range, options) => {
	  try {
	    range = new Range$9(range, options);
	  } catch (er) {
	    return false
	  }
	  return range.test(version)
	};
	var satisfies_1 = satisfies$4;
	getDefaultExportFromCjs(satisfies_1);

	const Range$8 = requireRange();
	const toComparators$1 = (range, options) =>
	  new Range$8(range, options).set
	    .map(comp => comp.map(c => c.value).join(' ').trim().split(' '));
	var toComparators_1 = toComparators$1;
	getDefaultExportFromCjs(toComparators_1);

	const SemVer$4 = semver$2;
	const Range$7 = requireRange();
	const maxSatisfying$1 = (versions, range, options) => {
	  let max = null;
	  let maxSV = null;
	  let rangeObj = null;
	  try {
	    rangeObj = new Range$7(range, options);
	  } catch (er) {
	    return null
	  }
	  versions.forEach((v) => {
	    if (rangeObj.test(v)) {
	      if (!max || maxSV.compare(v) === -1) {
	        max = v;
	        maxSV = new SemVer$4(max, options);
	      }
	    }
	  });
	  return max
	};
	var maxSatisfying_1 = maxSatisfying$1;
	getDefaultExportFromCjs(maxSatisfying_1);

	const SemVer$3 = semver$2;
	const Range$6 = requireRange();
	const minSatisfying$1 = (versions, range, options) => {
	  let min = null;
	  let minSV = null;
	  let rangeObj = null;
	  try {
	    rangeObj = new Range$6(range, options);
	  } catch (er) {
	    return null
	  }
	  versions.forEach((v) => {
	    if (rangeObj.test(v)) {
	      if (!min || minSV.compare(v) === 1) {
	        min = v;
	        minSV = new SemVer$3(min, options);
	      }
	    }
	  });
	  return min
	};
	var minSatisfying_1 = minSatisfying$1;
	getDefaultExportFromCjs(minSatisfying_1);

	const SemVer$2 = semver$2;
	const Range$5 = requireRange();
	const gt$2 = gt_1;
	const minVersion$1 = (range, loose) => {
	  range = new Range$5(range, loose);
	  let minver = new SemVer$2('0.0.0');
	  if (range.test(minver)) {
	    return minver
	  }
	  minver = new SemVer$2('0.0.0-0');
	  if (range.test(minver)) {
	    return minver
	  }
	  minver = null;
	  for (let i = 0; i < range.set.length; ++i) {
	    const comparators = range.set[i];
	    let setMin = null;
	    comparators.forEach((comparator) => {
	      const compver = new SemVer$2(comparator.semver.version);
	      switch (comparator.operator) {
	        case '>':
	          if (compver.prerelease.length === 0) {
	            compver.patch++;
	          } else {
	            compver.prerelease.push(0);
	          }
	          compver.raw = compver.format();
	        case '':
	        case '>=':
	          if (!setMin || gt$2(compver, setMin)) {
	            setMin = compver;
	          }
	          break
	        case '<':
	        case '<=':
	          break
	        default:
	          throw new Error(`Unexpected operation: ${comparator.operator}`)
	      }
	    });
	    if (setMin && (!minver || gt$2(minver, setMin))) {
	      minver = setMin;
	    }
	  }
	  if (minver && range.test(minver)) {
	    return minver
	  }
	  return null
	};
	var minVersion_1 = minVersion$1;
	getDefaultExportFromCjs(minVersion_1);

	const Range$4 = requireRange();
	const validRange$1 = (range, options) => {
	  try {
	    return new Range$4(range, options).range || '*'
	  } catch (er) {
	    return null
	  }
	};
	var valid$1 = validRange$1;
	getDefaultExportFromCjs(valid$1);

	const SemVer$1 = semver$2;
	const Comparator$2 = requireComparator();
	const { ANY: ANY$1 } = Comparator$2;
	const Range$3 = requireRange();
	const satisfies$3 = satisfies_1;
	const gt$1 = gt_1;
	const lt$1 = lt_1;
	const lte$1 = lte_1;
	const gte$1 = gte_1;
	const outside$3 = (version, range, hilo, options) => {
	  version = new SemVer$1(version, options);
	  range = new Range$3(range, options);
	  let gtfn, ltefn, ltfn, comp, ecomp;
	  switch (hilo) {
	    case '>':
	      gtfn = gt$1;
	      ltefn = lte$1;
	      ltfn = lt$1;
	      comp = '>';
	      ecomp = '>=';
	      break
	    case '<':
	      gtfn = lt$1;
	      ltefn = gte$1;
	      ltfn = gt$1;
	      comp = '<';
	      ecomp = '<=';
	      break
	    default:
	      throw new TypeError('Must provide a hilo val of "<" or ">"')
	  }
	  if (satisfies$3(version, range, options)) {
	    return false
	  }
	  for (let i = 0; i < range.set.length; ++i) {
	    const comparators = range.set[i];
	    let high = null;
	    let low = null;
	    comparators.forEach((comparator) => {
	      if (comparator.semver === ANY$1) {
	        comparator = new Comparator$2('>=0.0.0');
	      }
	      high = high || comparator;
	      low = low || comparator;
	      if (gtfn(comparator.semver, high.semver, options)) {
	        high = comparator;
	      } else if (ltfn(comparator.semver, low.semver, options)) {
	        low = comparator;
	      }
	    });
	    if (high.operator === comp || high.operator === ecomp) {
	      return false
	    }
	    if ((!low.operator || low.operator === comp) &&
	        ltefn(version, low.semver)) {
	      return false
	    } else if (low.operator === ecomp && ltfn(version, low.semver)) {
	      return false
	    }
	  }
	  return true
	};
	var outside_1 = outside$3;
	getDefaultExportFromCjs(outside_1);

	const outside$2 = outside_1;
	const gtr$1 = (version, range, options) => outside$2(version, range, '>', options);
	var gtr_1 = gtr$1;
	getDefaultExportFromCjs(gtr_1);

	const outside$1 = outside_1;
	const ltr$1 = (version, range, options) => outside$1(version, range, '<', options);
	var ltr_1 = ltr$1;
	getDefaultExportFromCjs(ltr_1);

	const Range$2 = requireRange();
	const intersects$1 = (r1, r2, options) => {
	  r1 = new Range$2(r1, options);
	  r2 = new Range$2(r2, options);
	  return r1.intersects(r2, options)
	};
	var intersects_1 = intersects$1;
	getDefaultExportFromCjs(intersects_1);

	const satisfies$2 = satisfies_1;
	const compare$2 = compare_1;
	var simplify = (versions, range, options) => {
	  const set = [];
	  let first = null;
	  let prev = null;
	  const v = versions.sort((a, b) => compare$2(a, b, options));
	  for (const version of v) {
	    const included = satisfies$2(version, range, options);
	    if (included) {
	      prev = version;
	      if (!first) {
	        first = version;
	      }
	    } else {
	      if (prev) {
	        set.push([first, prev]);
	      }
	      prev = null;
	      first = null;
	    }
	  }
	  if (first) {
	    set.push([first, null]);
	  }
	  const ranges = [];
	  for (const [min, max] of set) {
	    if (min === max) {
	      ranges.push(min);
	    } else if (!max && min === v[0]) {
	      ranges.push('*');
	    } else if (!max) {
	      ranges.push(`>=${min}`);
	    } else if (min === v[0]) {
	      ranges.push(`<=${max}`);
	    } else {
	      ranges.push(`${min} - ${max}`);
	    }
	  }
	  const simplified = ranges.join(' || ');
	  const original = typeof range.raw === 'string' ? range.raw : String(range);
	  return simplified.length < original.length ? simplified : range
	};
	getDefaultExportFromCjs(simplify);

	const Range$1 = requireRange();
	const Comparator$1 = requireComparator();
	const { ANY } = Comparator$1;
	const satisfies$1 = satisfies_1;
	const compare$1 = compare_1;
	const subset$1 = (sub, dom, options = {}) => {
	  if (sub === dom) {
	    return true
	  }
	  sub = new Range$1(sub, options);
	  dom = new Range$1(dom, options);
	  let sawNonNull = false;
	  OUTER: for (const simpleSub of sub.set) {
	    for (const simpleDom of dom.set) {
	      const isSub = simpleSubset(simpleSub, simpleDom, options);
	      sawNonNull = sawNonNull || isSub !== null;
	      if (isSub) {
	        continue OUTER
	      }
	    }
	    if (sawNonNull) {
	      return false
	    }
	  }
	  return true
	};
	const minimumVersionWithPreRelease = [new Comparator$1('>=0.0.0-0')];
	const minimumVersion = [new Comparator$1('>=0.0.0')];
	const simpleSubset = (sub, dom, options) => {
	  if (sub === dom) {
	    return true
	  }
	  if (sub.length === 1 && sub[0].semver === ANY) {
	    if (dom.length === 1 && dom[0].semver === ANY) {
	      return true
	    } else if (options.includePrerelease) {
	      sub = minimumVersionWithPreRelease;
	    } else {
	      sub = minimumVersion;
	    }
	  }
	  if (dom.length === 1 && dom[0].semver === ANY) {
	    if (options.includePrerelease) {
	      return true
	    } else {
	      dom = minimumVersion;
	    }
	  }
	  const eqSet = new Set();
	  let gt, lt;
	  for (const c of sub) {
	    if (c.operator === '>' || c.operator === '>=') {
	      gt = higherGT(gt, c, options);
	    } else if (c.operator === '<' || c.operator === '<=') {
	      lt = lowerLT(lt, c, options);
	    } else {
	      eqSet.add(c.semver);
	    }
	  }
	  if (eqSet.size > 1) {
	    return null
	  }
	  let gtltComp;
	  if (gt && lt) {
	    gtltComp = compare$1(gt.semver, lt.semver, options);
	    if (gtltComp > 0) {
	      return null
	    } else if (gtltComp === 0 && (gt.operator !== '>=' || lt.operator !== '<=')) {
	      return null
	    }
	  }
	  for (const eq of eqSet) {
	    if (gt && !satisfies$1(eq, String(gt), options)) {
	      return null
	    }
	    if (lt && !satisfies$1(eq, String(lt), options)) {
	      return null
	    }
	    for (const c of dom) {
	      if (!satisfies$1(eq, String(c), options)) {
	        return false
	      }
	    }
	    return true
	  }
	  let higher, lower;
	  let hasDomLT, hasDomGT;
	  let needDomLTPre = lt &&
	    !options.includePrerelease &&
	    lt.semver.prerelease.length ? lt.semver : false;
	  let needDomGTPre = gt &&
	    !options.includePrerelease &&
	    gt.semver.prerelease.length ? gt.semver : false;
	  if (needDomLTPre && needDomLTPre.prerelease.length === 1 &&
	      lt.operator === '<' && needDomLTPre.prerelease[0] === 0) {
	    needDomLTPre = false;
	  }
	  for (const c of dom) {
	    hasDomGT = hasDomGT || c.operator === '>' || c.operator === '>=';
	    hasDomLT = hasDomLT || c.operator === '<' || c.operator === '<=';
	    if (gt) {
	      if (needDomGTPre) {
	        if (c.semver.prerelease && c.semver.prerelease.length &&
	            c.semver.major === needDomGTPre.major &&
	            c.semver.minor === needDomGTPre.minor &&
	            c.semver.patch === needDomGTPre.patch) {
	          needDomGTPre = false;
	        }
	      }
	      if (c.operator === '>' || c.operator === '>=') {
	        higher = higherGT(gt, c, options);
	        if (higher === c && higher !== gt) {
	          return false
	        }
	      } else if (gt.operator === '>=' && !satisfies$1(gt.semver, String(c), options)) {
	        return false
	      }
	    }
	    if (lt) {
	      if (needDomLTPre) {
	        if (c.semver.prerelease && c.semver.prerelease.length &&
	            c.semver.major === needDomLTPre.major &&
	            c.semver.minor === needDomLTPre.minor &&
	            c.semver.patch === needDomLTPre.patch) {
	          needDomLTPre = false;
	        }
	      }
	      if (c.operator === '<' || c.operator === '<=') {
	        lower = lowerLT(lt, c, options);
	        if (lower === c && lower !== lt) {
	          return false
	        }
	      } else if (lt.operator === '<=' && !satisfies$1(lt.semver, String(c), options)) {
	        return false
	      }
	    }
	    if (!c.operator && (lt || gt) && gtltComp !== 0) {
	      return false
	    }
	  }
	  if (gt && hasDomLT && !lt && gtltComp !== 0) {
	    return false
	  }
	  if (lt && hasDomGT && !gt && gtltComp !== 0) {
	    return false
	  }
	  if (needDomGTPre || needDomLTPre) {
	    return false
	  }
	  return true
	};
	const higherGT = (a, b, options) => {
	  if (!a) {
	    return b
	  }
	  const comp = compare$1(a.semver, b.semver, options);
	  return comp > 0 ? a
	    : comp < 0 ? b
	    : b.operator === '>' && a.operator === '>=' ? b
	    : a
	};
	const lowerLT = (a, b, options) => {
	  if (!a) {
	    return b
	  }
	  const comp = compare$1(a.semver, b.semver, options);
	  return comp < 0 ? a
	    : comp > 0 ? b
	    : b.operator === '<' && a.operator === '<=' ? b
	    : a
	};
	var subset_1 = subset$1;
	getDefaultExportFromCjs(subset_1);

	const internalRe = reExports;
	const constants = constants$1;
	const SemVer = semver$2;
	const identifiers = identifiers$1;
	const parse = parse_1;
	const valid = valid_1;
	const clean = clean_1;
	const inc = inc_1;
	const diff = diff_1;
	const major = major_1;
	const minor = minor_1;
	const patch = patch_1;
	const prerelease = prerelease_1;
	const compare = compare_1;
	const rcompare = rcompare_1;
	const compareLoose = compareLoose_1;
	const compareBuild = compareBuild_1;
	const sort = sort_1;
	const rsort = rsort_1;
	const gt = gt_1;
	const lt = lt_1;
	const eq = eq_1;
	const neq = neq_1;
	const gte = gte_1;
	const lte = lte_1;
	const cmp = cmp_1;
	const coerce = coerce_1;
	const Comparator = requireComparator();
	const Range = requireRange();
	const satisfies = satisfies_1;
	const toComparators = toComparators_1;
	const maxSatisfying = maxSatisfying_1;
	const minSatisfying = minSatisfying_1;
	const minVersion = minVersion_1;
	const validRange = valid$1;
	const outside = outside_1;
	const gtr = gtr_1;
	const ltr = ltr_1;
	const intersects = intersects_1;
	const simplifyRange = simplify;
	const subset = subset_1;
	var semver = {
	  parse,
	  valid,
	  clean,
	  inc,
	  diff,
	  major,
	  minor,
	  patch,
	  prerelease,
	  compare,
	  rcompare,
	  compareLoose,
	  compareBuild,
	  sort,
	  rsort,
	  gt,
	  lt,
	  eq,
	  neq,
	  gte,
	  lte,
	  cmp,
	  coerce,
	  Comparator,
	  Range,
	  satisfies,
	  toComparators,
	  maxSatisfying,
	  minSatisfying,
	  minVersion,
	  validRange,
	  outside,
	  gtr,
	  ltr,
	  intersects,
	  simplifyRange,
	  subset,
	  SemVer,
	  re: internalRe.re,
	  src: internalRe.src,
	  tokens: internalRe.t,
	  SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
	  RELEASE_TYPES: constants.RELEASE_TYPES,
	  compareIdentifiers: identifiers.compareIdentifiers,
	  rcompareIdentifiers: identifiers.rcompareIdentifiers,
	};
	const semver$1 = getDefaultExportFromCjs(semver);

	var DeviceModelId;
	(function (DeviceModelId) {
	    DeviceModelId["blue"] = "blue";
	    DeviceModelId["nanoS"] = "nanoS";
	    DeviceModelId["nanoSP"] = "nanoSP";
	    DeviceModelId["nanoX"] = "nanoX";
	    DeviceModelId["stax"] = "stax";
	})(DeviceModelId || (DeviceModelId = {}));
	const devices = {
	    [DeviceModelId.blue]: {
	        id: DeviceModelId.blue,
	        productName: "Ledger Blue",
	        productIdMM: 0x00,
	        legacyUsbProductId: 0x0000,
	        usbOnly: true,
	        memorySize: 480 * 1024,
	        masks: [0x31000000, 0x31010000],
	        getBlockSize: (_firwareVersion) => 4 * 1024,
	    },
	    [DeviceModelId.nanoS]: {
	        id: DeviceModelId.nanoS,
	        productName: "Ledger Nano S",
	        productIdMM: 0x10,
	        legacyUsbProductId: 0x0001,
	        usbOnly: true,
	        memorySize: 320 * 1024,
	        masks: [0x31100000],
	        getBlockSize: (firmwareVersion) => { var _a; return semver$1.lt((_a = semver$1.coerce(firmwareVersion)) !== null && _a !== void 0 ? _a : "", "2.0.0") ? 4 * 1024 : 2 * 1024; },
	    },
	    [DeviceModelId.nanoSP]: {
	        id: DeviceModelId.nanoSP,
	        productName: "Ledger Nano S Plus",
	        productIdMM: 0x50,
	        legacyUsbProductId: 0x0005,
	        usbOnly: true,
	        memorySize: 1536 * 1024,
	        masks: [0x33100000],
	        getBlockSize: (_firmwareVersion) => 32,
	    },
	    [DeviceModelId.nanoX]: {
	        id: DeviceModelId.nanoX,
	        productName: "Ledger Nano X",
	        productIdMM: 0x40,
	        legacyUsbProductId: 0x0004,
	        usbOnly: false,
	        memorySize: 2 * 1024 * 1024,
	        masks: [0x33000000],
	        getBlockSize: (_firwareVersion) => 4 * 1024,
	        bluetoothSpec: [
	            {
	                serviceUuid: "13d63400-2c97-0004-0000-4c6564676572",
	                notifyUuid: "13d63400-2c97-0004-0001-4c6564676572",
	                writeUuid: "13d63400-2c97-0004-0002-4c6564676572",
	                writeCmdUuid: "13d63400-2c97-0004-0003-4c6564676572",
	            },
	        ],
	    },
	    [DeviceModelId.stax]: {
	        id: DeviceModelId.stax,
	        productName: "Ledger Stax",
	        productIdMM: 0x60,
	        legacyUsbProductId: 0x0006,
	        usbOnly: false,
	        memorySize: 1536 * 1024,
	        masks: [0x33200000],
	        getBlockSize: (_firmwareVersion) => 32,
	        bluetoothSpec: [
	            {
	                serviceUuid: "13d63400-2c97-6004-0000-4c6564676572",
	                notifyUuid: "13d63400-2c97-6004-0001-4c6564676572",
	                writeUuid: "13d63400-2c97-6004-0002-4c6564676572",
	                writeCmdUuid: "13d63400-2c97-6004-0003-4c6564676572",
	            },
	        ],
	    },
	};
	({
	    Blue: DeviceModelId.blue,
	    "Nano S": DeviceModelId.nanoS,
	    "Nano S Plus": DeviceModelId.nanoSP,
	    "Nano X": DeviceModelId.nanoX,
	    Stax: DeviceModelId.stax,
	});
	const devicesList = Object.values(devices);
	const ledgerUSBVendorId = 0x2c97;
	const identifyUSBProductId = (usbProductId) => {
	    const legacy = devicesList.find(d => d.legacyUsbProductId === usbProductId);
	    if (legacy)
	        return legacy;
	    const mm = usbProductId >> 8;
	    const deviceModel = devicesList.find(d => d.productIdMM === mm);
	    return deviceModel;
	};
	const bluetoothServices = [];
	const serviceUuidToInfos = {};
	for (const id in devices) {
	    const deviceModel = devices[id];
	    const { bluetoothSpec } = deviceModel;
	    if (bluetoothSpec) {
	        for (let i = 0; i < bluetoothSpec.length; i++) {
	            const spec = bluetoothSpec[i];
	            bluetoothServices.push(spec.serviceUuid);
	            serviceUuidToInfos[spec.serviceUuid] = serviceUuidToInfos[spec.serviceUuid.replace(/-/g, "")] = Object.assign({ deviceModel }, spec);
	        }
	    }
	}

	var __awaiter$2 = (global && global.__awaiter) || function (thisArg, _arguments, P, generator) {
	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	    return new (P || (P = Promise))(function (resolve, reject) {
	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	        step((generator = generator.apply(thisArg, _arguments || [])).next());
	    });
	};
	const ledgerDevices$1 = [
	    {
	        vendorId: ledgerUSBVendorId,
	    },
	];
	const isSupported$1 = () => Promise.resolve(!!(window.navigator && window.navigator.hid));
	const getHID = () => {
	    const { hid } = navigator;
	    if (!hid)
	        throw new TransportError("navigator.hid is not supported", "HIDNotSupported");
	    return hid;
	};
	function requestLedgerDevices() {
	    return __awaiter$2(this, void 0, void 0, function* () {
	        const device = yield getHID().requestDevice({
	            filters: ledgerDevices$1,
	        });
	        if (Array.isArray(device))
	            return device;
	        return [device];
	    });
	}
	function getLedgerDevices$1() {
	    return __awaiter$2(this, void 0, void 0, function* () {
	        const devices = yield getHID().getDevices();
	        return devices.filter(d => d.vendorId === ledgerUSBVendorId);
	    });
	}
	function getFirstLedgerDevice$1() {
	    return __awaiter$2(this, void 0, void 0, function* () {
	        const existingDevices = yield getLedgerDevices$1();
	        if (existingDevices.length > 0)
	            return existingDevices[0];
	        const devices = yield requestLedgerDevices();
	        return devices[0];
	    });
	}
	class TransportWebHID extends Transport {
	    constructor(device) {
	        super();
	        this.channel = Math.floor(Math.random() * 0xffff);
	        this.packetSize = 64;
	        this.inputs = [];
	        this.read = () => {
	            if (this.inputs.length) {
	                return Promise.resolve(this.inputs.shift());
	            }
	            return new Promise(success => {
	                this.inputCallback = success;
	            });
	        };
	        this.onInputReport = (e) => {
	            const buffer = Buffer.from(e.data.buffer);
	            if (this.inputCallback) {
	                this.inputCallback(buffer);
	                this.inputCallback = null;
	            }
	            else {
	                this.inputs.push(buffer);
	            }
	        };
	        this._disconnectEmitted = false;
	        this._emitDisconnect = (e) => {
	            if (this._disconnectEmitted)
	                return;
	            this._disconnectEmitted = true;
	            this.emit("disconnect", e);
	        };
	        this.exchange = (apdu) => __awaiter$2(this, void 0, void 0, function* () {
	            const b = yield this.exchangeAtomicImpl(() => __awaiter$2(this, void 0, void 0, function* () {
	                const { channel, packetSize } = this;
	                log("apdu", "=> " + apdu.toString("hex"));
	                const framing = createHIDframing(channel, packetSize);
	                const blocks = framing.makeBlocks(apdu);
	                for (let i = 0; i < blocks.length; i++) {
	                    yield this.device.sendReport(0, blocks[i]);
	                }
	                let result;
	                let acc;
	                while (!(result = framing.getReducedResult(acc))) {
	                    const buffer = yield this.read();
	                    acc = framing.reduceResponse(acc, buffer);
	                }
	                log("apdu", "<= " + result.toString("hex"));
	                return result;
	            })).catch(e => {
	                if (e && e.message && e.message.includes("write")) {
	                    this._emitDisconnect(e);
	                    throw new DisconnectedDeviceDuringOperation(e.message);
	                }
	                throw e;
	            });
	            return b;
	        });
	        this.device = device;
	        this.deviceModel =
	            typeof device.productId === "number" ? identifyUSBProductId(device.productId) : undefined;
	        device.addEventListener("inputreport", this.onInputReport);
	    }
	    static request() {
	        return __awaiter$2(this, void 0, void 0, function* () {
	            const [device] = yield requestLedgerDevices();
	            return TransportWebHID.open(device);
	        });
	    }
	    static openConnected() {
	        return __awaiter$2(this, void 0, void 0, function* () {
	            const devices = yield getLedgerDevices$1();
	            if (devices.length === 0)
	                return null;
	            return TransportWebHID.open(devices[0]);
	        });
	    }
	    static open(device) {
	        return __awaiter$2(this, void 0, void 0, function* () {
	            yield device.open();
	            const transport = new TransportWebHID(device);
	            const onDisconnect = e => {
	                if (device === e.device) {
	                    getHID().removeEventListener("disconnect", onDisconnect);
	                    transport._emitDisconnect(new DisconnectedDevice());
	                }
	            };
	            getHID().addEventListener("disconnect", onDisconnect);
	            return transport;
	        });
	    }
	    close() {
	        return __awaiter$2(this, void 0, void 0, function* () {
	            yield this.exchangeBusyPromise;
	            this.device.removeEventListener("inputreport", this.onInputReport);
	            yield this.device.close();
	        });
	    }
	    setScrambleKey() { }
	}
	TransportWebHID.isSupported = isSupported$1;
	TransportWebHID.list = getLedgerDevices$1;
	TransportWebHID.listen = (observer) => {
	    let unsubscribed = false;
	    getFirstLedgerDevice$1().then(device => {
	        if (!device) {
	            observer.error(new TransportOpenUserCancelled("Access denied to use Ledger device"));
	        }
	        else if (!unsubscribed) {
	            const deviceModel = typeof device.productId === "number"
	                ? identifyUSBProductId(device.productId)
	                : undefined;
	            observer.next({
	                type: "add",
	                descriptor: device,
	                deviceModel,
	            });
	            observer.complete();
	        }
	    }, error => {
	        observer.error(new TransportOpenUserCancelled(error.message));
	    });
	    function unsubscribe() {
	        unsubscribed = true;
	    }
	    return {
	        unsubscribe,
	    };
	};

	const TransportWebHID$1 = /*#__PURE__*/Object.freeze({
		__proto__: null,
		default: TransportWebHID
	});

	const require$$1 = /*@__PURE__*/getAugmentedNamespace(TransportWebHID$1);

	var __awaiter$1 = (global && global.__awaiter) || function (thisArg, _arguments, P, generator) {
	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	    return new (P || (P = Promise))(function (resolve, reject) {
	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	        step((generator = generator.apply(thisArg, _arguments || [])).next());
	    });
	};
	const ledgerDevices = [
	    {
	        vendorId: ledgerUSBVendorId,
	    },
	];
	function requestLedgerDevice() {
	    return __awaiter$1(this, void 0, void 0, function* () {
	        const device = yield navigator.usb.requestDevice({
	            filters: ledgerDevices,
	        });
	        return device;
	    });
	}
	function getLedgerDevices() {
	    return __awaiter$1(this, void 0, void 0, function* () {
	        const devices = yield navigator.usb.getDevices();
	        return devices.filter(d => d.vendorId === ledgerUSBVendorId);
	    });
	}
	function getFirstLedgerDevice() {
	    return __awaiter$1(this, void 0, void 0, function* () {
	        const existingDevices = yield getLedgerDevices();
	        if (existingDevices.length > 0)
	            return existingDevices[0];
	        return requestLedgerDevice();
	    });
	}
	const isSupported = () => Promise.resolve(!!navigator && !!navigator.usb && typeof navigator.usb.getDevices === "function");

	var __awaiter = (global && global.__awaiter) || function (thisArg, _arguments, P, generator) {
	    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
	    return new (P || (P = Promise))(function (resolve, reject) {
	        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
	        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
	        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
	        step((generator = generator.apply(thisArg, _arguments || [])).next());
	    });
	};
	const configurationValue = 1;
	const endpointNumber = 3;
	class TransportWebUSB extends Transport {
	    constructor(device, interfaceNumber) {
	        super();
	        this.channel = Math.floor(Math.random() * 0xffff);
	        this.packetSize = 64;
	        this._disconnectEmitted = false;
	        this._emitDisconnect = (e) => {
	            if (this._disconnectEmitted)
	                return;
	            this._disconnectEmitted = true;
	            this.emit("disconnect", e);
	        };
	        this.device = device;
	        this.interfaceNumber = interfaceNumber;
	        this.deviceModel = identifyUSBProductId(device.productId);
	    }
	    static request() {
	        return __awaiter(this, void 0, void 0, function* () {
	            const device = yield requestLedgerDevice();
	            return TransportWebUSB.open(device);
	        });
	    }
	    static openConnected() {
	        return __awaiter(this, void 0, void 0, function* () {
	            const devices = yield getLedgerDevices();
	            if (devices.length === 0)
	                return null;
	            return TransportWebUSB.open(devices[0]);
	        });
	    }
	    static open(device) {
	        return __awaiter(this, void 0, void 0, function* () {
	            yield device.open();
	            if (device.configuration === null) {
	                yield device.selectConfiguration(configurationValue);
	            }
	            yield gracefullyResetDevice(device);
	            const iface = device.configurations[0].interfaces.find(({ alternates }) => alternates.some(a => a.interfaceClass === 255));
	            if (!iface) {
	                throw new TransportInterfaceNotAvailable("No WebUSB interface found for your Ledger device. Please upgrade firmware or contact techsupport.");
	            }
	            const interfaceNumber = iface.interfaceNumber;
	            try {
	                yield device.claimInterface(interfaceNumber);
	            }
	            catch (e) {
	                yield device.close();
	                throw new TransportInterfaceNotAvailable(e.message);
	            }
	            const transport = new TransportWebUSB(device, interfaceNumber);
	            const onDisconnect = e => {
	                if (device === e.device) {
	                    navigator.usb.removeEventListener("disconnect", onDisconnect);
	                    transport._emitDisconnect(new DisconnectedDevice());
	                }
	            };
	            navigator.usb.addEventListener("disconnect", onDisconnect);
	            return transport;
	        });
	    }
	    close() {
	        return __awaiter(this, void 0, void 0, function* () {
	            yield this.exchangeBusyPromise;
	            yield this.device.releaseInterface(this.interfaceNumber);
	            yield gracefullyResetDevice(this.device);
	            yield this.device.close();
	        });
	    }
	    exchange(apdu) {
	        return __awaiter(this, void 0, void 0, function* () {
	            const b = yield this.exchangeAtomicImpl(() => __awaiter(this, void 0, void 0, function* () {
	                const { channel, packetSize } = this;
	                log("apdu", "=> " + apdu.toString("hex"));
	                const framing = createHIDframing(channel, packetSize);
	                const blocks = framing.makeBlocks(apdu);
	                for (let i = 0; i < blocks.length; i++) {
	                    yield this.device.transferOut(endpointNumber, blocks[i]);
	                }
	                let result;
	                let acc;
	                while (!(result = framing.getReducedResult(acc))) {
	                    const r = yield this.device.transferIn(endpointNumber, packetSize);
	                    const buffer = Buffer.from(r.data.buffer);
	                    acc = framing.reduceResponse(acc, buffer);
	                }
	                log("apdu", "<= " + result.toString("hex"));
	                return result;
	            })).catch(e => {
	                if (e && e.message && e.message.includes("disconnected")) {
	                    this._emitDisconnect(e);
	                    throw new DisconnectedDeviceDuringOperation(e.message);
	                }
	                throw e;
	            });
	            return b;
	        });
	    }
	    setScrambleKey() { }
	}
	TransportWebUSB.isSupported = isSupported;
	TransportWebUSB.list = getLedgerDevices;
	TransportWebUSB.listen = (observer) => {
	    let unsubscribed = false;
	    getFirstLedgerDevice().then(device => {
	        if (!unsubscribed) {
	            const deviceModel = identifyUSBProductId(device.productId);
	            observer.next({
	                type: "add",
	                descriptor: device,
	                deviceModel,
	            });
	            observer.complete();
	        }
	    }, error => {
	        if (window.DOMException && error instanceof window.DOMException && error.code === 18) {
	            observer.error(new TransportWebUSBGestureRequired(error.message));
	        }
	        else {
	            observer.error(new TransportOpenUserCancelled(error.message));
	        }
	    });
	    function unsubscribe() {
	        unsubscribed = true;
	    }
	    return {
	        unsubscribe,
	    };
	};
	function gracefullyResetDevice(device) {
	    return __awaiter(this, void 0, void 0, function* () {
	        try {
	            yield device.reset();
	        }
	        catch (err) {
	            console.warn(err);
	        }
	    });
	}

	const TransportWebUSB$1 = /*#__PURE__*/Object.freeze({
		__proto__: null,
		default: TransportWebUSB
	});

	const require$$2 = /*@__PURE__*/getAugmentedNamespace(TransportWebUSB$1);

	var util = {};

	var hasRequiredUtil;
	function requireUtil () {
		if (hasRequiredUtil) return util;
		hasRequiredUtil = 1;
		Object.defineProperty(util, "__esModule", { value: true });
		util.createDefs = void 0;
		function createDefs(...items) {
		    return items.map(([type, Clazz]) => ({
		        create: () => Clazz.create(),
		        type
		    }));
		}
		util.createDefs = createDefs;
		return util;
	}

	var packageInfo$1 = {};

	var hasRequiredPackageInfo;
	function requirePackageInfo () {
		if (hasRequiredPackageInfo) return packageInfo$1;
		hasRequiredPackageInfo = 1;
		Object.defineProperty(packageInfo$1, "__esModule", { value: true });
		packageInfo$1.packageInfo = void 0;
		packageInfo$1.packageInfo = { name: '@polkadot/hw-ledger-transports', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '12.6.2' };
		return packageInfo$1;
	}

	(function (exports) {
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.transports = exports.packageInfo = void 0;
		const tslib_1 = require$$0;
		const hw_transport_webhid_1 = tslib_1.__importDefault(require$$1);
		const hw_transport_webusb_1 = tslib_1.__importDefault(require$$2);
		const util_js_1 = requireUtil();
		var packageInfo_js_1 = requirePackageInfo();
		Object.defineProperty(exports, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
		exports.transports = (0, util_js_1.createDefs)(['webusb', hw_transport_webusb_1.default], ['hid', hw_transport_webhid_1.default]);
	} (browser));
	getDefaultExportFromCjs(browser);

	const LEDGER_DEFAULT_ACCOUNT = 0x80000000;
	const LEDGER_DEFAULT_CHANGE = 0x80000000;
	const LEDGER_DEFAULT_INDEX = 0x80000000;
	const LEDGER_SUCCESS_CODE = 0x9000;

	const ledgerApps = {
	    acala: 'Acala',
	    ajuna: 'Ajuna',
	    'aleph-node': 'AlephZero',
	    astar: 'Astar',
	    bifrost: 'Bifrost',
	    'bifrost-kusama': 'BifrostKusama',
	    centrifuge: 'Centrifuge',
	    composable: 'Composable',
	    darwinia: 'Darwinia',
	    'dock-mainnet': 'Dock',
	    edgeware: 'Edgeware',
	    enjin: 'Enjin',
	    equilibrium: 'Equilibrium',
	    genshiro: 'Genshiro',
	    hydradx: 'HydraDX',
	    'interlay-parachain': 'Interlay',
	    karura: 'Karura',
	    khala: 'Khala',
	    kusama: 'Kusama',
	    matrixchain: 'Matrixchain',
	    nodle: 'Nodle',
	    origintrail: 'OriginTrail',
	    parallel: 'Parallel',
	    pendulum: 'Pendulum',
	    phala: 'Phala',
	    picasso: 'Picasso',
	    polkadex: 'Polkadex',
	    polkadot: 'Polkadot',
	    polymesh: 'Polymesh',
	    quartz: 'Quartz',
	    sora: 'Sora',
	    stafi: 'Stafi',
	    statemine: 'Statemine',
	    statemint: 'Statemint',
	    ternoa: 'Ternoa',
	    unique: 'Unique',
	    vtb: 'VTB',
	    xxnetwork: 'XXNetwork',
	    zeitgeist: 'Zeitgeist'
	};

	const packageInfo = { name: '@polkadot/hw-ledger', path: (({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-hw-ledger.js', document.baseURI).href)) }) && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-hw-ledger.js', document.baseURI).href))) ? new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-hw-ledger.js', document.baseURI).href))).pathname.substring(0, new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.src || new URL('bundle-polkadot-hw-ledger.js', document.baseURI).href))).pathname.lastIndexOf('/') + 1) : 'auto', type: 'esm', version: '12.6.2' };

	async function wrapError(promise) {
	    const result = await promise;
	    if (result.return_code !== LEDGER_SUCCESS_CODE) {
	        throw new Error(result.error_message);
	    }
	    return result;
	}
	function sign(method, message, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE } = {}) {
	    return async (app) => {
	        const { signature } = await wrapError(app[method](account + accountOffset, change, addressIndex + addressOffset, util$1.u8aToBuffer(message)));
	        return {
	            signature: util$1.hexAddPrefix(signature.toString('hex'))
	        };
	    };
	}
	class Ledger {
	    __internal__ledgerName;
	    __internal__transportDef;
	    __internal__app = null;
	    constructor(transport, chain) {
	        const ledgerName = ledgerApps[chain];
	        const transportDef = browser.transports.find(({ type }) => type === transport);
	        if (!ledgerName) {
	            throw new Error(`Unsupported Ledger chain ${chain}`);
	        }
	        else if (!transportDef) {
	            throw new Error(`Unsupported Ledger transport ${transport}`);
	        }
	        this.__internal__ledgerName = ledgerName;
	        this.__internal__transportDef = transportDef;
	    }
	    async getAddress(confirm = false, accountOffset = 0, addressOffset = 0, { account = LEDGER_DEFAULT_ACCOUNT, addressIndex = LEDGER_DEFAULT_INDEX, change = LEDGER_DEFAULT_CHANGE } = {}) {
	        return this.withApp(async (app) => {
	            const { address, pubKey } = await wrapError(app.getAddress(account + accountOffset, change, addressIndex + addressOffset, confirm));
	            return {
	                address,
	                publicKey: util$1.hexAddPrefix(pubKey)
	            };
	        });
	    }
	    async getVersion() {
	        return this.withApp(async (app) => {
	            const { device_locked: isLocked, major, minor, patch, test_mode: isTestMode } = await wrapError(app.getVersion());
	            return {
	                isLocked,
	                isTestMode,
	                version: [major, minor, patch]
	            };
	        });
	    }
	    async sign(message, accountOffset, addressOffset, options) {
	        return this.withApp(sign('sign', message, accountOffset, addressOffset, options));
	    }
	    async signRaw(message, accountOffset, addressOffset, options) {
	        return this.withApp(sign('signRaw', util$1.u8aWrapBytes(message), accountOffset, addressOffset, options));
	    }
	    async withApp(fn) {
	        try {
	            if (!this.__internal__app) {
	                const transport = await this.__internal__transportDef.create();
	                this.__internal__app = dist.newSubstrateApp(transport, this.__internal__ledgerName);
	            }
	            return await fn(this.__internal__app);
	        }
	        catch (error) {
	            this.__internal__app = null;
	            throw error;
	        }
	    }
	}

	exports.Ledger = Ledger;
	exports.packageInfo = packageInfo;

}));