@pezkuwi/hw-ledger 14.0.7 → 14.0.11

package/bundle-pezkuwi-hw-ledger.js

@@ -47,17 +47,17 @@
 
 	var common$1 = {};
 
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.ERROR_DESCRIPTION = exports.ECDSA_PUBKEY_LEN = exports.ED25519_PUBKEY_LEN = exports.CHUNK_SIZE = void 0;
-		exports.errorCodeToString = errorCodeToString;
-		exports.processErrorResponse = processErrorResponse;
-		exports.getVersion = getVersion;
-		exports.serializePath = serializePath;
-		exports.CHUNK_SIZE = 250;
-		exports.ED25519_PUBKEY_LEN = 32;
-		exports.ECDSA_PUBKEY_LEN = 33;
-		exports.ERROR_DESCRIPTION = {
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.ERROR_DESCRIPTION = exports$1.ECDSA_PUBKEY_LEN = exports$1.ED25519_PUBKEY_LEN = exports$1.CHUNK_SIZE = void 0;
+		exports$1.errorCodeToString = errorCodeToString;
+		exports$1.processErrorResponse = processErrorResponse;
+		exports$1.getVersion = getVersion;
+		exports$1.serializePath = serializePath;
+		exports$1.CHUNK_SIZE = 250;
+		exports$1.ED25519_PUBKEY_LEN = 32;
+		exports$1.ECDSA_PUBKEY_LEN = 33;
+		exports$1.ERROR_DESCRIPTION = {
 		    1: 'U2F: Unknown',
 		    2: 'U2F: Bad request',
 		    3: 'U2F: Configuration unsupported',
@@ -82,8 +82,8 @@
 		    0x6f01: 'Sign/verify error',
 		};
 		function errorCodeToString(statusCode) {
-		    if (statusCode in exports.ERROR_DESCRIPTION)
-		        return exports.ERROR_DESCRIPTION[statusCode];
+		    if (statusCode in exports$1.ERROR_DESCRIPTION)
+		        return exports$1.ERROR_DESCRIPTION[statusCode];
 		    return `Unknown Status Code: ${statusCode}`;
 		}
 		function isDict(v) {
@@ -440,14 +440,14 @@
 	}
 	substrate_app.SubstrateApp = SubstrateApp;
 
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.supportedApps = void 0;
-		exports.newSubstrateApp = newSubstrateApp;
-		exports.getAppParams = getAppParams;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.supportedApps = void 0;
+		exports$1.newSubstrateApp = newSubstrateApp;
+		exports$1.getAppParams = getAppParams;
 		const substrate_app_1 = substrate_app;
 		function newSubstrateApp(transport, chainName) {
-		    const requestedApp = exports.supportedApps.find((app) => {
+		    const requestedApp = exports$1.supportedApps.find((app) => {
 		        return app.name.toLowerCase() === chainName.toLowerCase();
 		    });
 		    if (requestedApp != null) {
@@ -456,12 +456,12 @@
 		    throw new Error(`Error: ${chainName} not supported`);
 		}
 		function getAppParams(chainName) {
-		    const params = exports.supportedApps.find((app) => {
+		    const params = exports$1.supportedApps.find((app) => {
 		        return app.name.toLowerCase() === chainName.toLowerCase();
 		    });
 		    return params;
 		}
-		exports.supportedApps = [
+		exports$1.supportedApps = [
 		    {
 		        name: 'Polkadot',
 		        cla: 0x90,
@@ -857,8 +857,15 @@
 
 	var generic_app = {};
 
-	/*! Axios v1.9.0 Copyright (c) 2025 Matt Zabriskie and contributors */
+	/*! Axios v1.13.2 Copyright (c) 2025 Matt Zabriskie and contributors */
 
+	/**
+	 * Create a bound version of a function with a specified `this` context
+	 *
+	 * @param {Function} fn - The function to bind
+	 * @param {*} thisArg - The value to be passed as the `this` parameter
+	 * @returns {Function} A new function that will call the original function with the specified `this` context
+	 */
 	function bind(fn, thisArg) {
 	  return function wrap() {
 	    return fn.apply(thisArg, arguments);
@@ -869,7 +876,7 @@
 
 	const {toString} = Object.prototype;
 	const {getPrototypeOf} = Object;
-	const {iterator: iterator$1, toStringTag} = Symbol;
+	const {iterator, toStringTag} = Symbol;
 
 	const kindOf = (cache => thing => {
 	    const str = toString.call(thing);
@@ -910,7 +917,7 @@
 	 */
 	function isBuffer(val) {
 	  return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor)
-	    && isFunction(val.constructor.isBuffer) && val.constructor.isBuffer(val);
+	    && isFunction$1(val.constructor.isBuffer) && val.constructor.isBuffer(val);
 	}
 
 	/**
@@ -955,7 +962,7 @@
 	 * @param {*} val The value to test
 	 * @returns {boolean} True if value is a Function, otherwise false
 	 */
-	const isFunction = typeOfTest('function');
+	const isFunction$1 = typeOfTest('function');
 
 	/**
 	 * Determine if a value is a Number
@@ -996,7 +1003,28 @@
 	  }
 
 	  const prototype = getPrototypeOf(val);
-	  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag in val) && !(iterator$1 in val);
+	  return (prototype === null || prototype === Object.prototype || Object.getPrototypeOf(prototype) === null) && !(toStringTag in val) && !(iterator in val);
+	};
+
+	/**
+	 * Determine if a value is an empty object (safely handles Buffers)
+	 *
+	 * @param {*} val The value to test
+	 *
+	 * @returns {boolean} True if value is an empty object, otherwise false
+	 */
+	const isEmptyObject = (val) => {
+	  // Early return for non-objects or Buffers to prevent RangeError
+	  if (!isObject$1(val) || isBuffer(val)) {
+	    return false;
+	  }
+
+	  try {
+	    return Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
+	  } catch (e) {
+	    // Fallback for any other objects that might cause RangeError with Object.keys()
+	    return false;
+	  }
 	};
 
 	/**
@@ -1042,7 +1070,7 @@
 	 *
 	 * @returns {boolean} True if value is a Stream, otherwise false
 	 */
-	const isStream = (val) => isObject$1(val) && isFunction(val.pipe);
+	const isStream = (val) => isObject$1(val) && isFunction$1(val.pipe);
 
 	/**
 	 * Determine if a value is a FormData
@@ -1055,10 +1083,10 @@
 	  let kind;
 	  return thing && (
 	    (typeof FormData === 'function' && thing instanceof FormData) || (
-	      isFunction(thing.append) && (
+	      isFunction$1(thing.append) && (
 	        (kind = kindOf(thing)) === 'formdata' ||
 	        // detect form-data instance
-	        (kind === 'object' && isFunction(thing.toString) && thing.toString() === '[object FormData]')
+	        (kind === 'object' && isFunction$1(thing.toString) && thing.toString() === '[object FormData]')
 	      )
 	    )
 	  )
@@ -1121,6 +1149,11 @@
 	      fn.call(null, obj[i], i, obj);
 	    }
 	  } else {
+	    // Buffer check
+	    if (isBuffer(obj)) {
+	      return;
+	    }
+
 	    // Iterate over object keys
 	    const keys = allOwnKeys ? Object.getOwnPropertyNames(obj) : Object.keys(obj);
 	    const len = keys.length;
@@ -1134,6 +1167,10 @@
 	}
 
 	function findKey(obj, key) {
+	  if (isBuffer(obj)){
+	    return null;
+	  }
+
 	  key = key.toLowerCase();
 	  const keys = Object.keys(obj);
 	  let i = keys.length;
@@ -1174,7 +1211,7 @@
 	 * @returns {Object} Result of all merge properties
 	 */
 	function merge(/* obj1, obj2, obj3, ... */) {
-	  const {caseless} = isContextDefined(this) && this || {};
+	  const {caseless, skipUndefined} = isContextDefined(this) && this || {};
 	  const result = {};
 	  const assignValue = (val, key) => {
 	    const targetKey = caseless && findKey(result, key) || key;
@@ -1184,7 +1221,7 @@
 	      result[targetKey] = merge({}, val);
 	    } else if (isArray(val)) {
 	      result[targetKey] = val.slice();
-	    } else {
+	    } else if (!skipUndefined || !isUndefined(val)) {
 	      result[targetKey] = val;
 	    }
 	  };
@@ -1207,7 +1244,7 @@
 	 */
 	const extend = (a, b, thisArg, {allOwnKeys}= {}) => {
 	  forEach(b, (val, key) => {
-	    if (thisArg && isFunction(val)) {
+	    if (thisArg && isFunction$1(val)) {
 	      a[key] = bind(val, thisArg);
 	    } else {
 	      a[key] = val;
@@ -1347,7 +1384,7 @@
 	 * @returns {void}
 	 */
 	const forEachEntry = (obj, fn) => {
-	  const generator = obj && obj[iterator$1];
+	  const generator = obj && obj[iterator];
 
 	  const _iterator = generator.call(obj);
 
@@ -1423,13 +1460,13 @@
 	const freezeMethods = (obj) => {
 	  reduceDescriptors(obj, (descriptor, name) => {
 	    // skip restricted props in strict mode
-	    if (isFunction(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
+	    if (isFunction$1(obj) && ['arguments', 'caller', 'callee'].indexOf(name) !== -1) {
 	      return false;
 	    }
 
 	    const value = obj[name];
 
-	    if (!isFunction(value)) return;
+	    if (!isFunction$1(value)) return;
 
 	    descriptor.enumerable = false;
 
@@ -1466,6 +1503,8 @@
 	  return value != null && Number.isFinite(value = +value) ? value : defaultValue;
 	};
 
+
+
 	/**
 	 * If the thing is a FormData object, return true, otherwise return false.
 	 *
@@ -1474,7 +1513,7 @@
 	 * @returns {boolean}
 	 */
 	function isSpecCompliantForm(thing) {
-	  return !!(thing && isFunction(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator$1]);
+	  return !!(thing && isFunction$1(thing.append) && thing[toStringTag] === 'FormData' && thing[iterator]);
 	}
 
 	const toJSONObject = (obj) => {
@@ -1487,6 +1526,11 @@
 	        return;
 	      }
 
+	      //Buffer check
+	      if (isBuffer(source)) {
+	        return source;
+	      }
+
 	      if(!('toJSON' in source)) {
 	        stack[i] = source;
 	        const target = isArray(source) ? [] : {};
@@ -1511,7 +1555,7 @@
 	const isAsyncFn = kindOfTest('AsyncFunction');
 
 	const isThenable = (thing) =>
-	  thing && (isObject$1(thing) || isFunction(thing)) && isFunction(thing.then) && isFunction(thing.catch);
+	  thing && (isObject$1(thing) || isFunction$1(thing)) && isFunction$1(thing.then) && isFunction$1(thing.catch);
 
 	// original code
 	// https://github.com/DigitalBrainJS/AxiosPromise/blob/16deab13710ec09779922131f3fa5954320f83ab/lib/utils.js#L11-L34
@@ -1535,7 +1579,7 @@
 	  })(`axios@${Math.random()}`, []) : (cb) => setTimeout(cb);
 	})(
 	  typeof setImmediate === 'function',
-	  isFunction(_global.postMessage)
+	  isFunction$1(_global.postMessage)
 	);
 
 	const asap = typeof queueMicrotask !== 'undefined' ?
@@ -1544,7 +1588,7 @@
 	// *********************
 
 
-	const isIterable = (thing) => thing != null && isFunction(thing[iterator$1]);
+	const isIterable = (thing) => thing != null && isFunction$1(thing[iterator]);
 
 
 	var utils$1 = {
@@ -1558,6 +1602,7 @@
 	  isBoolean,
 	  isObject: isObject$1,
 	  isPlainObject,
+	  isEmptyObject,
 	  isReadableStream,
 	  isRequest,
 	  isResponse,
@@ -1567,7 +1612,7 @@
 	  isFile,
 	  isBlob,
 	  isRegExp,
-	  isFunction,
+	  isFunction: isFunction$1,
 	  isStream,
 	  isURLSearchParams,
 	  isTypedArray,
@@ -1693,11 +1738,18 @@
 	    return prop !== 'isAxiosError';
 	  });
 
-	  AxiosError.call(axiosError, error.message, code, config, request, response);
+	  const msg = error && error.message ? error.message : 'Error';
+
+	  // Prefer explicit code; otherwise copy the low-level error's code (e.g. ECONNREFUSED)
+	  const errCode = code == null && error ? error.code : code;
+	  AxiosError.call(axiosError, msg, errCode, config, request, response);
 
-	  axiosError.cause = error;
+	  // Chain the original error on the standard field; non-enumerable to avoid JSON noise
+	  if (error && axiosError.cause == null) {
+	    Object.defineProperty(axiosError, 'cause', { value: error, configurable: true });
+	  }
 
-	  axiosError.name = error.name;
+	  axiosError.name = (error && error.name) || 'Error';
 
 	  customProps && Object.assign(axiosError, customProps);
 
@@ -1822,6 +1874,10 @@
 	      return value.toISOString();
 	    }
 
+	    if (utils$1.isBoolean(value)) {
+	      return value.toString();
+	    }
+
 	    if (!useBlob && utils$1.isBlob(value)) {
 	      throw new AxiosError('Blob is not supported. Use a Buffer instead.');
 	    }
@@ -1984,9 +2040,7 @@
 	    replace(/%3A/gi, ':').
 	    replace(/%24/g, '$').
 	    replace(/%2C/gi, ',').
-	    replace(/%20/g, '+').
-	    replace(/%5B/gi, '[').
-	    replace(/%5D/gi, ']');
+	    replace(/%20/g, '+');
 	}
 
 	/**
@@ -2064,7 +2118,7 @@
 	   *
 	   * @param {Number} id The ID that was returned by `use`
 	   *
-	   * @returns {Boolean} `true` if the interceptor was removed, `false` otherwise
+	   * @returns {void}
 	   */
 	  eject(id) {
 	    if (this.handlers[id]) {
@@ -2185,7 +2239,7 @@
 	};
 
 	function toURLEncodedForm(data, options) {
-	  return toFormData(data, new platform.classes.URLSearchParams(), Object.assign({
+	  return toFormData(data, new platform.classes.URLSearchParams(), {
 	    visitor: function(value, key, path, helpers) {
 	      if (platform.isNode && utils$1.isBuffer(value)) {
 	        this.append(key, value.toString('base64'));
@@ -2193,8 +2247,9 @@
 	      }
 
 	      return helpers.defaultVisitor.apply(this, arguments);
-	    }
-	  }, options));
+	    },
+	    ...options
+	  });
 	}
 
 	/**
@@ -2390,7 +2445,7 @@
 	      const strictJSONParsing = !silentJSONParsing && JSONRequested;
 
 	      try {
-	        return JSON.parse(data);
+	        return JSON.parse(data, this.parseReviver);
 	      } catch (e) {
 	        if (strictJSONParsing) {
 	          if (e.name === 'SyntaxError') {
@@ -2947,7 +3002,7 @@
 	      clearTimeout(timer);
 	      timer = null;
 	    }
-	    fn.apply(null, args);
+	    fn(...args);
 	  };
 
 	  const throttled = (...args) => {
@@ -3029,27 +3084,38 @@
 
 	  // Standard browser envs support document.cookie
 	  {
-	    write(name, value, expires, path, domain, secure) {
-	      const cookie = [name + '=' + encodeURIComponent(value)];
-
-	      utils$1.isNumber(expires) && cookie.push('expires=' + new Date(expires).toGMTString());
+	    write(name, value, expires, path, domain, secure, sameSite) {
+	      if (typeof document === 'undefined') return;
 
-	      utils$1.isString(path) && cookie.push('path=' + path);
+	      const cookie = [`${name}=${encodeURIComponent(value)}`];
 
-	      utils$1.isString(domain) && cookie.push('domain=' + domain);
-
-	      secure === true && cookie.push('secure');
+	      if (utils$1.isNumber(expires)) {
+	        cookie.push(`expires=${new Date(expires).toUTCString()}`);
+	      }
+	      if (utils$1.isString(path)) {
+	        cookie.push(`path=${path}`);
+	      }
+	      if (utils$1.isString(domain)) {
+	        cookie.push(`domain=${domain}`);
+	      }
+	      if (secure === true) {
+	        cookie.push('secure');
+	      }
+	      if (utils$1.isString(sameSite)) {
+	        cookie.push(`SameSite=${sameSite}`);
+	      }
 
 	      document.cookie = cookie.join('; ');
 	    },
 
 	    read(name) {
-	      const match = document.cookie.match(new RegExp('(^|;\\s*)(' + name + ')=([^;]*)'));
-	      return (match ? decodeURIComponent(match[3]) : null);
+	      if (typeof document === 'undefined') return null;
+	      const match = document.cookie.match(new RegExp('(?:^|; )' + name + '=([^;]*)'));
+	      return match ? decodeURIComponent(match[1]) : null;
 	    },
 
 	    remove(name) {
-	      this.write(name, '', Date.now() - 86400000);
+	      this.write(name, '', Date.now() - 86400000, '/');
 	    }
 	  }
 
@@ -3138,11 +3204,11 @@
 	  }
 
 	  // eslint-disable-next-line consistent-return
-	  function mergeDeepProperties(a, b, prop , caseless) {
+	  function mergeDeepProperties(a, b, prop, caseless) {
 	    if (!utils$1.isUndefined(b)) {
-	      return getMergedValue(a, b, prop , caseless);
+	      return getMergedValue(a, b, prop, caseless);
 	    } else if (!utils$1.isUndefined(a)) {
-	      return getMergedValue(undefined, a, prop , caseless);
+	      return getMergedValue(undefined, a, prop, caseless);
 	    }
 	  }
 
@@ -3200,10 +3266,10 @@
 	    socketPath: defaultToConfig2,
 	    responseEncoding: defaultToConfig2,
 	    validateStatus: mergeDirectKeys,
-	    headers: (a, b , prop) => mergeDeepProperties(headersToObject(a), headersToObject(b),prop, true)
+	    headers: (a, b, prop) => mergeDeepProperties(headersToObject(a), headersToObject(b), prop, true)
 	  };
 
-	  utils$1.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
+	  utils$1.forEach(Object.keys({...config1, ...config2}), function computeConfigValue(prop) {
 	    const merge = mergeMap[prop] || mergeDeepProperties;
 	    const configValue = merge(config1[prop], config2[prop], prop);
 	    (utils$1.isUndefined(configValue) && merge !== mergeDirectKeys) || (config[prop] = configValue);
@@ -3215,7 +3281,7 @@
 	var resolveConfig = (config) => {
 	  const newConfig = mergeConfig({}, config);
 
-	  let {data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth} = newConfig;
+	  let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
 
 	  newConfig.headers = headers = AxiosHeaders$1.from(headers);
 
@@ -3228,17 +3294,21 @@
 	    );
 	  }
 
-	  let contentType;
-
 	  if (utils$1.isFormData(data)) {
 	    if (platform.hasStandardBrowserEnv || platform.hasStandardBrowserWebWorkerEnv) {
-	      headers.setContentType(undefined); // Let the browser set it
-	    } else if ((contentType = headers.getContentType()) !== false) {
-	      // fix semicolon duplication issue for ReactNative FormData implementation
-	      const [type, ...tokens] = contentType ? contentType.split(';').map(token => token.trim()).filter(Boolean) : [];
-	      headers.setContentType([type || 'multipart/form-data', ...tokens].join('; '));
+	      headers.setContentType(undefined); // browser handles it
+	    } else if (utils$1.isFunction(data.getHeaders)) {
+	      // Node.js FormData (like form-data package)
+	      const formHeaders = data.getHeaders();
+	      // Only set safe headers to avoid overwriting security headers
+	      const allowedHeaders = ['content-type', 'content-length'];
+	      Object.entries(formHeaders).forEach(([key, val]) => {
+	        if (allowedHeaders.includes(key.toLowerCase())) {
+	          headers.set(key, val);
+	        }
+	      });
 	    }
-	  }
+	  }  
 
 	  // Add xsrf header
 	  // This is only done if running in a standard browser environment.
@@ -3355,15 +3425,18 @@
 	    };
 
 	    // Handle low level network errors
-	    request.onerror = function handleError() {
-	      // Real errors are hidden from us by the browser
-	      // onerror should only fire if it's a network error
-	      reject(new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request));
-
-	      // Clean up request
-	      request = null;
+	  request.onerror = function handleError(event) {
+	       // Browsers deliver a ProgressEvent in XHR onerror
+	       // (message may be empty; when present, surface it)
+	       // See https://developer.mozilla.org/docs/Web/API/XMLHttpRequest/error_event
+	       const msg = event && event.message ? event.message : 'Network Error';
+	       const err = new AxiosError(msg, AxiosError.ERR_NETWORK, config, request);
+	       // attach the underlying event for consumers who want details
+	       err.event = event || null;
+	       reject(err);
+	       request = null;
 	    };
-
+	    
 	    // Handle timeout
 	    request.ontimeout = function handleTimeout() {
 	      let timeoutErrorMessage = _config.timeout ? 'timeout of ' + _config.timeout + 'ms exceeded' : 'timeout exceeded';
@@ -3495,7 +3568,7 @@
 	const streamChunk = function* (chunk, chunkSize) {
 	  let len = chunk.byteLength;
 
-	  if (!chunkSize || len < chunkSize) {
+	  if (len < chunkSize) {
 	    yield chunk;
 	    return;
 	  }
@@ -3579,14 +3652,18 @@
 	  })
 	};
 
-	const isFetchSupported = typeof fetch === 'function' && typeof Request === 'function' && typeof Response === 'function';
-	const isReadableStreamSupported = isFetchSupported && typeof ReadableStream === 'function';
+	const DEFAULT_CHUNK_SIZE = 64 * 1024;
+
+	const {isFunction} = utils$1;
+
+	const globalFetchAPI = (({Request, Response}) => ({
+	  Request, Response
+	}))(utils$1.global);
+
+	const {
+	  ReadableStream: ReadableStream$1, TextEncoder
+	} = utils$1.global;
 
-	// used only inside the fetch adapter
-	const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
-	    ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
-	    async (str) => new Uint8Array(await new Response(str).arrayBuffer())
-	);
 
 	const test = (fn, ...args) => {
 	  try {
@@ -3596,278 +3673,380 @@
 	  }
 	};
 
-	const supportsRequestStream = isReadableStreamSupported && test(() => {
-	  let duplexAccessed = false;
+	const factory = (env) => {
+	  env = utils$1.merge.call({
+	    skipUndefined: true
+	  }, globalFetchAPI, env);
 
-	  const hasContentType = new Request(platform.origin, {
-	    body: new ReadableStream(),
-	    method: 'POST',
-	    get duplex() {
-	      duplexAccessed = true;
-	      return 'half';
-	    },
-	  }).headers.has('Content-Type');
+	  const {fetch: envFetch, Request, Response} = env;
+	  const isFetchSupported = envFetch ? isFunction(envFetch) : typeof fetch === 'function';
+	  const isRequestSupported = isFunction(Request);
+	  const isResponseSupported = isFunction(Response);
 
-	  return duplexAccessed && !hasContentType;
-	});
+	  if (!isFetchSupported) {
+	    return false;
+	  }
 
-	const DEFAULT_CHUNK_SIZE = 64 * 1024;
+	  const isReadableStreamSupported = isFetchSupported && isFunction(ReadableStream$1);
 
-	const supportsResponseStream = isReadableStreamSupported &&
-	  test(() => utils$1.isReadableStream(new Response('').body));
+	  const encodeText = isFetchSupported && (typeof TextEncoder === 'function' ?
+	      ((encoder) => (str) => encoder.encode(str))(new TextEncoder()) :
+	      async (str) => new Uint8Array(await new Request(str).arrayBuffer())
+	  );
 
+	  const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
+	    let duplexAccessed = false;
 
-	const resolvers = {
-	  stream: supportsResponseStream && ((res) => res.body)
-	};
+	    const hasContentType = new Request(platform.origin, {
+	      body: new ReadableStream$1(),
+	      method: 'POST',
+	      get duplex() {
+	        duplexAccessed = true;
+	        return 'half';
+	      },
+	    }).headers.has('Content-Type');
 
-	isFetchSupported && (((res) => {
-	  ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {
-	    !resolvers[type] && (resolvers[type] = utils$1.isFunction(res[type]) ? (res) => res[type]() :
-	      (_, config) => {
-	        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
-	      });
+	    return duplexAccessed && !hasContentType;
 	  });
-	})(new Response));
 
-	const getBodyLength = async (body) => {
-	  if (body == null) {
-	    return 0;
-	  }
+	  const supportsResponseStream = isResponseSupported && isReadableStreamSupported &&
+	    test(() => utils$1.isReadableStream(new Response('').body));
 
-	  if(utils$1.isBlob(body)) {
-	    return body.size;
-	  }
+	  const resolvers = {
+	    stream: supportsResponseStream && ((res) => res.body)
+	  };
 
-	  if(utils$1.isSpecCompliantForm(body)) {
-	    const _request = new Request(platform.origin, {
-	      method: 'POST',
-	      body,
+	  isFetchSupported && ((() => {
+	    ['text', 'arrayBuffer', 'blob', 'formData', 'stream'].forEach(type => {
+	      !resolvers[type] && (resolvers[type] = (res, config) => {
+	        let method = res && res[type];
+
+	        if (method) {
+	          return method.call(res);
+	        }
+
+	        throw new AxiosError(`Response type '${type}' is not supported`, AxiosError.ERR_NOT_SUPPORT, config);
+	      });
 	    });
-	    return (await _request.arrayBuffer()).byteLength;
-	  }
+	  })());
 
-	  if(utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
-	    return body.byteLength;
-	  }
+	  const getBodyLength = async (body) => {
+	    if (body == null) {
+	      return 0;
+	    }
 
-	  if(utils$1.isURLSearchParams(body)) {
-	    body = body + '';
-	  }
+	    if (utils$1.isBlob(body)) {
+	      return body.size;
+	    }
 
-	  if(utils$1.isString(body)) {
-	    return (await encodeText(body)).byteLength;
-	  }
-	};
+	    if (utils$1.isSpecCompliantForm(body)) {
+	      const _request = new Request(platform.origin, {
+	        method: 'POST',
+	        body,
+	      });
+	      return (await _request.arrayBuffer()).byteLength;
+	    }
 
-	const resolveBodyLength = async (headers, body) => {
-	  const length = utils$1.toFiniteNumber(headers.getContentLength());
+	    if (utils$1.isArrayBufferView(body) || utils$1.isArrayBuffer(body)) {
+	      return body.byteLength;
+	    }
 
-	  return length == null ? getBodyLength(body) : length;
-	};
+	    if (utils$1.isURLSearchParams(body)) {
+	      body = body + '';
+	    }
+
+	    if (utils$1.isString(body)) {
+	      return (await encodeText(body)).byteLength;
+	    }
+	  };
+
+	  const resolveBodyLength = async (headers, body) => {
+	    const length = utils$1.toFiniteNumber(headers.getContentLength());
+
+	    return length == null ? getBodyLength(body) : length;
+	  };
+
+	  return async (config) => {
+	    let {
+	      url,
+	      method,
+	      data,
+	      signal,
+	      cancelToken,
+	      timeout,
+	      onDownloadProgress,
+	      onUploadProgress,
+	      responseType,
+	      headers,
+	      withCredentials = 'same-origin',
+	      fetchOptions
+	    } = resolveConfig(config);
+
+	    let _fetch = envFetch || fetch;
+
+	    responseType = responseType ? (responseType + '').toLowerCase() : 'text';
+
+	    let composedSignal = composeSignals$1([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
 
-	var fetchAdapter = isFetchSupported && (async (config) => {
-	  let {
-	    url,
-	    method,
-	    data,
-	    signal,
-	    cancelToken,
-	    timeout,
-	    onDownloadProgress,
-	    onUploadProgress,
-	    responseType,
-	    headers,
-	    withCredentials = 'same-origin',
-	    fetchOptions
-	  } = resolveConfig(config);
-
-	  responseType = responseType ? (responseType + '').toLowerCase() : 'text';
-
-	  let composedSignal = composeSignals$1([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
-
-	  let request;
-
-	  const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
+	    let request = null;
+
+	    const unsubscribe = composedSignal && composedSignal.unsubscribe && (() => {
 	      composedSignal.unsubscribe();
-	  });
+	    });
 
-	  let requestContentLength;
+	    let requestContentLength;
 
-	  try {
-	    if (
-	      onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&
-	      (requestContentLength = await resolveBodyLength(headers, data)) !== 0
-	    ) {
-	      let _request = new Request(url, {
-	        method: 'POST',
-	        body: data,
-	        duplex: "half"
-	      });
+	    try {
+	      if (
+	        onUploadProgress && supportsRequestStream && method !== 'get' && method !== 'head' &&
+	        (requestContentLength = await resolveBodyLength(headers, data)) !== 0
+	      ) {
+	        let _request = new Request(url, {
+	          method: 'POST',
+	          body: data,
+	          duplex: "half"
+	        });
 
-	      let contentTypeHeader;
+	        let contentTypeHeader;
 
-	      if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
-	        headers.setContentType(contentTypeHeader);
-	      }
+	        if (utils$1.isFormData(data) && (contentTypeHeader = _request.headers.get('content-type'))) {
+	          headers.setContentType(contentTypeHeader);
+	        }
 
-	      if (_request.body) {
-	        const [onProgress, flush] = progressEventDecorator(
-	          requestContentLength,
-	          progressEventReducer(asyncDecorator(onUploadProgress))
-	        );
+	        if (_request.body) {
+	          const [onProgress, flush] = progressEventDecorator(
+	            requestContentLength,
+	            progressEventReducer(asyncDecorator(onUploadProgress))
+	          );
 
-	        data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+	          data = trackStream(_request.body, DEFAULT_CHUNK_SIZE, onProgress, flush);
+	        }
 	      }
-	    }
 
-	    if (!utils$1.isString(withCredentials)) {
-	      withCredentials = withCredentials ? 'include' : 'omit';
-	    }
+	      if (!utils$1.isString(withCredentials)) {
+	        withCredentials = withCredentials ? 'include' : 'omit';
+	      }
 
-	    // Cloudflare Workers throws when credentials are defined
-	    // see https://github.com/cloudflare/workerd/issues/902
-	    const isCredentialsSupported = "credentials" in Request.prototype;
-	    request = new Request(url, {
-	      ...fetchOptions,
-	      signal: composedSignal,
-	      method: method.toUpperCase(),
-	      headers: headers.normalize().toJSON(),
-	      body: data,
-	      duplex: "half",
-	      credentials: isCredentialsSupported ? withCredentials : undefined
-	    });
+	      // Cloudflare Workers throws when credentials are defined
+	      // see https://github.com/cloudflare/workerd/issues/902
+	      const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
 
-	    let response = await fetch(request);
+	      const resolvedOptions = {
+	        ...fetchOptions,
+	        signal: composedSignal,
+	        method: method.toUpperCase(),
+	        headers: headers.normalize().toJSON(),
+	        body: data,
+	        duplex: "half",
+	        credentials: isCredentialsSupported ? withCredentials : undefined
+	      };
 
-	    const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
+	      request = isRequestSupported && new Request(url, resolvedOptions);
 
-	    if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
-	      const options = {};
+	      let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url, resolvedOptions));
 
-	      ['status', 'statusText', 'headers'].forEach(prop => {
-	        options[prop] = response[prop];
-	      });
+	      const isStreamResponse = supportsResponseStream && (responseType === 'stream' || responseType === 'response');
 
-	      const responseContentLength = utils$1.toFiniteNumber(response.headers.get('content-length'));
+	      if (supportsResponseStream && (onDownloadProgress || (isStreamResponse && unsubscribe))) {
+	        const options = {};
 
-	      const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
-	        responseContentLength,
-	        progressEventReducer(asyncDecorator(onDownloadProgress), true)
-	      ) || [];
+	        ['status', 'statusText', 'headers'].forEach(prop => {
+	          options[prop] = response[prop];
+	        });
 
-	      response = new Response(
-	        trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
-	          flush && flush();
-	          unsubscribe && unsubscribe();
-	        }),
-	        options
-	      );
-	    }
+	        const responseContentLength = utils$1.toFiniteNumber(response.headers.get('content-length'));
 
-	    responseType = responseType || 'text';
+	        const [onProgress, flush] = onDownloadProgress && progressEventDecorator(
+	          responseContentLength,
+	          progressEventReducer(asyncDecorator(onDownloadProgress), true)
+	        ) || [];
 
-	    let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || 'text'](response, config);
+	        response = new Response(
+	          trackStream(response.body, DEFAULT_CHUNK_SIZE, onProgress, () => {
+	            flush && flush();
+	            unsubscribe && unsubscribe();
+	          }),
+	          options
+	        );
+	      }
 
-	    !isStreamResponse && unsubscribe && unsubscribe();
+	      responseType = responseType || 'text';
 
-	    return await new Promise((resolve, reject) => {
-	      settle(resolve, reject, {
-	        data: responseData,
-	        headers: AxiosHeaders$1.from(response.headers),
-	        status: response.status,
-	        statusText: response.statusText,
-	        config,
-	        request
-	      });
-	    })
-	  } catch (err) {
-	    unsubscribe && unsubscribe();
+	      let responseData = await resolvers[utils$1.findKey(resolvers, responseType) || 'text'](response, config);
 
-	    if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
-	      throw Object.assign(
-	        new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request),
-	        {
-	          cause: err.cause || err
-	        }
-	      )
+	      !isStreamResponse && unsubscribe && unsubscribe();
+
+	      return await new Promise((resolve, reject) => {
+	        settle(resolve, reject, {
+	          data: responseData,
+	          headers: AxiosHeaders$1.from(response.headers),
+	          status: response.status,
+	          statusText: response.statusText,
+	          config,
+	          request
+	        });
+	      })
+	    } catch (err) {
+	      unsubscribe && unsubscribe();
+
+	      if (err && err.name === 'TypeError' && /Load failed|fetch/i.test(err.message)) {
+	        throw Object.assign(
+	          new AxiosError('Network Error', AxiosError.ERR_NETWORK, config, request),
+	          {
+	            cause: err.cause || err
+	          }
+	        )
+	      }
+
+	      throw AxiosError.from(err, err && err.code, config, request);
 	    }
+	  }
+	};
 
-	    throw AxiosError.from(err, err && err.code, config, request);
+	const seedCache = new Map();
+
+	const getFetch = (config) => {
+	  let env = (config && config.env) || {};
+	  const {fetch, Request, Response} = env;
+	  const seeds = [
+	    Request, Response, fetch
+	  ];
+
+	  let len = seeds.length, i = len,
+	    seed, target, map = seedCache;
+
+	  while (i--) {
+	    seed = seeds[i];
+	    target = map.get(seed);
+
+	    target === undefined && map.set(seed, target = (i ? new Map() : factory(env)));
+
+	    map = target;
 	  }
-	});
 
+	  return target;
+	};
+
+	getFetch();
+
+	/**
+	 * Known adapters mapping.
+	 * Provides environment-specific adapters for Axios:
+	 * - `http` for Node.js
+	 * - `xhr` for browsers
+	 * - `fetch` for fetch API-based requests
+	 * 
+	 * @type {Object<string, Function|Object>}
+	 */
 	const knownAdapters = {
 	  http: httpAdapter,
 	  xhr: xhrAdapter,
-	  fetch: fetchAdapter
+	  fetch: {
+	    get: getFetch,
+	  }
 	};
 
+	// Assign adapter names for easier debugging and identification
 	utils$1.forEach(knownAdapters, (fn, value) => {
 	  if (fn) {
 	    try {
-	      Object.defineProperty(fn, 'name', {value});
+	      Object.defineProperty(fn, 'name', { value });
 	    } catch (e) {
 	      // eslint-disable-next-line no-empty
 	    }
-	    Object.defineProperty(fn, 'adapterName', {value});
+	    Object.defineProperty(fn, 'adapterName', { value });
 	  }
 	});
 
+	/**
+	 * Render a rejection reason string for unknown or unsupported adapters
+	 * 
+	 * @param {string} reason
+	 * @returns {string}
+	 */
 	const renderReason = (reason) => `- ${reason}`;
 
+	/**
+	 * Check if the adapter is resolved (function, null, or false)
+	 * 
+	 * @param {Function|null|false} adapter
+	 * @returns {boolean}
+	 */
 	const isResolvedHandle = (adapter) => utils$1.isFunction(adapter) || adapter === null || adapter === false;
 
-	var adapters = {
-	  getAdapter: (adapters) => {
-	    adapters = utils$1.isArray(adapters) ? adapters : [adapters];
-
-	    const {length} = adapters;
-	    let nameOrAdapter;
-	    let adapter;
+	/**
+	 * Get the first suitable adapter from the provided list.
+	 * Tries each adapter in order until a supported one is found.
+	 * Throws an AxiosError if no adapter is suitable.
+	 * 
+	 * @param {Array<string|Function>|string|Function} adapters - Adapter(s) by name or function.
+	 * @param {Object} config - Axios request configuration
+	 * @throws {AxiosError} If no suitable adapter is available
+	 * @returns {Function} The resolved adapter function
+	 */
+	function getAdapter(adapters, config) {
+	  adapters = utils$1.isArray(adapters) ? adapters : [adapters];
 
-	    const rejectedReasons = {};
+	  const { length } = adapters;
+	  let nameOrAdapter;
+	  let adapter;
 
-	    for (let i = 0; i < length; i++) {
-	      nameOrAdapter = adapters[i];
-	      let id;
+	  const rejectedReasons = {};
 
-	      adapter = nameOrAdapter;
+	  for (let i = 0; i < length; i++) {
+	    nameOrAdapter = adapters[i];
+	    let id;
 
-	      if (!isResolvedHandle(nameOrAdapter)) {
-	        adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
+	    adapter = nameOrAdapter;
 
-	        if (adapter === undefined) {
-	          throw new AxiosError(`Unknown adapter '${id}'`);
-	        }
-	      }
+	    if (!isResolvedHandle(nameOrAdapter)) {
+	      adapter = knownAdapters[(id = String(nameOrAdapter)).toLowerCase()];
 
-	      if (adapter) {
-	        break;
+	      if (adapter === undefined) {
+	        throw new AxiosError(`Unknown adapter '${id}'`);
 	      }
+	    }
 
-	      rejectedReasons[id || '#' + i] = adapter;
+	    if (adapter && (utils$1.isFunction(adapter) || (adapter = adapter.get(config)))) {
+	      break;
 	    }
 
-	    if (!adapter) {
+	    rejectedReasons[id || '#' + i] = adapter;
+	  }
 
-	      const reasons = Object.entries(rejectedReasons)
-	        .map(([id, state]) => `adapter ${id} ` +
-	          (state === false ? 'is not supported by the environment' : 'is not available in the build')
-	        );
+	  if (!adapter) {
+	    const reasons = Object.entries(rejectedReasons)
+	      .map(([id, state]) => `adapter ${id} ` +
+	        (state === false ? 'is not supported by the environment' : 'is not available in the build')
+	      );
 
-	      let s = length ?
-	        (reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0])) :
-	        'as no adapter specified';
+	    let s = length ?
+	      (reasons.length > 1 ? 'since :\n' + reasons.map(renderReason).join('\n') : ' ' + renderReason(reasons[0])) :
+	      'as no adapter specified';
 
-	      throw new AxiosError(
-	        `There is no suitable adapter to dispatch the request ` + s,
-	        'ERR_NOT_SUPPORT'
-	      );
-	    }
+	    throw new AxiosError(
+	      `There is no suitable adapter to dispatch the request ` + s,
+	      'ERR_NOT_SUPPORT'
+	    );
+	  }
 
-	    return adapter;
-	  },
+	  return adapter;
+	}
+
+	/**
+	 * Exports Axios adapters and utility to resolve an adapter
+	 */
+	var adapters = {
+	  /**
+	   * Resolve an adapter from a list of adapter names or functions.
+	   * @type {Function}
+	   */
+	  getAdapter,
+
+	  /**
+	   * Exposes all known adapters
+	   * @type {Object<string, Function|Object>}
+	   */
 	  adapters: knownAdapters
 	};
 
@@ -3910,7 +4089,7 @@
 	    config.headers.setContentType('application/x-www-form-urlencoded', false);
 	  }
 
-	  const adapter = adapters.getAdapter(config.adapter || defaults$1.adapter);
+	  const adapter = adapters.getAdapter(config.adapter || defaults$1.adapter, config);
 
 	  return adapter(config).then(function onAdapterResolution(response) {
 	    throwIfCancellationRequested(config);
@@ -3944,7 +4123,7 @@
 	  });
 	}
 
-	const VERSION = "1.9.0";
+	const VERSION = "1.13.2";
 
 	const validators$1 = {};
 
@@ -4183,8 +4362,8 @@
 
 	    if (!synchronousRequestInterceptors) {
 	      const chain = [dispatchRequest.bind(this), undefined];
-	      chain.unshift.apply(chain, requestInterceptorChain);
-	      chain.push.apply(chain, responseInterceptorChain);
+	      chain.unshift(...requestInterceptorChain);
+	      chain.push(...responseInterceptorChain);
 	      len = chain.length;
 
 	      promise = Promise.resolve(config);
@@ -4200,8 +4379,6 @@
 
 	    let newConfig = config;
 
-	    i = 0;
-
 	    while (i < len) {
 	      const onFulfilled = requestInterceptorChain[i++];
 	      const onRejected = requestInterceptorChain[i++];
@@ -4505,6 +4682,12 @@
 	  LoopDetected: 508,
 	  NotExtended: 510,
 	  NetworkAuthenticationRequired: 511,
+	  WebServerIsDown: 521,
+	  ConnectionTimedOut: 522,
+	  OriginIsUnreachable: 523,
+	  TimeoutOccurred: 524,
+	  SslHandshakeFailed: 525,
+	  InvalidSslCertificate: 526,
 	};
 
 	Object.entries(HttpStatusCode).forEach(([key, value]) => {
@@ -4726,7 +4909,7 @@
 	var errors = {};
 
 	Object.defineProperty(errors, "__esModule", { value: true });
-	errors.errorCodeToString = void 0;
+	errors.errorCodeToString = errorCodeToString;
 	const consts_1$4 = consts;
 	function errorCodeToString(returnCode, customErrorList) {
 	    const returnCodeStr = returnCode.toString(16).toUpperCase();
@@ -4739,7 +4922,6 @@
 	    }
 	    return errDescription;
 	}
-	errors.errorCodeToString = errorCodeToString;
 
 	Object.defineProperty(responseError, "__esModule", { value: true });
 	responseError.ResponseError = void 0;
@@ -4757,7 +4939,9 @@
 	responseError.ResponseError = ResponseError;
 
 	Object.defineProperty(bip32, "__esModule", { value: true });
-	bip32.bufferToBip32Path = bip32.numbersToBip32Path = bip32.serializePath = void 0;
+	bip32.serializePath = serializePath;
+	bip32.numbersToBip32Path = numbersToBip32Path;
+	bip32.bufferToBip32Path = bufferToBip32Path;
 	const consts_1$3 = consts;
 	const responseError_1$3 = responseError;
 	function serializePath(path, requiredPathLengths) {
@@ -4791,7 +4975,6 @@
 	    });
 	    return buf;
 	}
-	bip32.serializePath = serializePath;
 	function numbersToBip32Path(items) {
 	    if (items.length === 0) {
 	        throw new responseError_1$3.ResponseError(consts_1$3.LedgerError.GenericError, 'The items array cannot be empty.');
@@ -4812,7 +4995,6 @@
 	    }
 	    return 'm/' + pathArray.join('/');
 	}
-	bip32.numbersToBip32Path = numbersToBip32Path;
 	function bufferToBip32Path(buffer) {
 	    if (buffer.length % 4 !== 0) {
 	        throw new responseError_1$3.ResponseError(consts_1$3.LedgerError.GenericError, 'The buffer length must be a multiple of 4.');
@@ -4823,7 +5005,6 @@
 	    }
 	    return numbersToBip32Path(items);
 	}
-	bip32.bufferToBip32Path = bufferToBip32Path;
 
 	var common = {};
 
@@ -4964,7 +5145,8 @@
 	payload.ResponsePayload = ResponsePayload;
 
 	Object.defineProperty(common, "__esModule", { value: true });
-	common.processErrorResponse = common.processResponse = void 0;
+	common.processResponse = processResponse;
+	common.processErrorResponse = processErrorResponse;
 	const consts_1$1 = consts;
 	const errors_1 = errors;
 	const payload_1 = payload;
@@ -4983,11 +5165,16 @@
 	        return new payload_1.ResponsePayload(payload);
 	    }
 	    if (payload.length > 0) {
-	        errorMessage += ` : ${payload.toString('ascii')}`;
+	        const payloadString = payload.toString('utf8');
+	        if (!payloadString.includes(errorMessage)) {
+	            errorMessage += ` : ${payloadString}`;
+	        }
+	        else {
+	            errorMessage = payloadString;
+	        }
 	    }
 	    throw new responseError_1$1.ResponseError(returnCode, errorMessage);
 	}
-	common.processResponse = processResponse;
 	function processErrorResponse(response, customErrorList) {
 	    if (isDict(response)) {
 	        if (Object.prototype.hasOwnProperty.call(response, 'statusCode')) {
@@ -4999,7 +5186,6 @@
 	    }
 	    return responseError_1$1.ResponseError.fromReturnCode(consts_1$1.LedgerError.UnknownTransportError);
 	}
-	common.processErrorResponse = processErrorResponse;
 
 	Object.defineProperty(app, "__esModule", { value: true });
 	const bip32_1 = bip32;
@@ -5046,9 +5232,25 @@
 	            payloadType = consts_1.PAYLOAD_TYPE.LAST;
 	        }
 	        const statusList = [consts_1.LedgerError.NoErrors, consts_1.LedgerError.DataIsInvalid, consts_1.LedgerError.BadKeyHandle];
-	        const responseBuffer = await this.transport.send(this.CLA, ins, payloadType, p2, chunk, statusList);
-	        const response = (0, common_1$1.processResponse)(responseBuffer, this.CUSTOM_APP_ERROR_DESCRIPTION);
-	        return response;
+	        try {
+	            const responseBuffer = await this.transport.send(this.CLA, ins, payloadType, p2, chunk, statusList);
+	            return (0, common_1$1.processResponse)(responseBuffer, this.CUSTOM_APP_ERROR_DESCRIPTION);
+	        }
+	        catch (e) {
+	            const statusCode = e.statusCode || e.returnCode || consts_1.LedgerError.UnknownTransportError;
+	            const message = e.message;
+	            let buffer;
+	            if (message?.length > 0) {
+	                const messageBytes = Buffer.from(message, 'utf8');
+	                buffer = Buffer.concat([messageBytes, Buffer.allocUnsafe(2)]);
+	                buffer.writeUInt16BE(statusCode, buffer.length - 2);
+	            }
+	            else {
+	                buffer = Buffer.allocUnsafe(2);
+	                buffer.writeUInt16BE(statusCode, 0);
+	            }
+	            return (0, common_1$1.processResponse)(buffer, this.CUSTOM_APP_ERROR_DESCRIPTION);
+	        }
 	    }
 	    async signSendChunk(ins, chunkIdx, chunkNum, chunk) {
 	        return this.sendGenericChunk(ins, 0, chunkIdx, chunkNum, chunk);
@@ -5161,7 +5363,7 @@
 
 	Object.defineProperty(types, "__esModule", { value: true });
 
-	(function (exports) {
+	(function (exports$1) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
 		    if (k2 === undefined) k2 = k;
 		    var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -5173,21 +5375,21 @@
 		    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);
+		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports$1) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
 		};
 		var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
 		    return (mod && mod.__esModule) ? mod : { "default": mod };
 		};
-		Object.defineProperty(exports, "__esModule", { value: true });
+		Object.defineProperty(exports$1, "__esModule", { value: true });
 		const app_1 = __importDefault(app);
-		exports.default = app_1.default;
-		__exportStar(common, exports);
-		__exportStar(consts, exports);
-		__exportStar(types, exports);
-		__exportStar(bip32, exports);
-		__exportStar(responseError, exports);
-		__exportStar(payload, exports);
+		exports$1.default = app_1.default;
+		__exportStar(common, exports$1);
+		__exportStar(consts, exports$1);
+		__exportStar(types, exports$1);
+		__exportStar(bip32, exports$1);
+		__exportStar(responseError, exports$1);
+		__exportStar(payload, exports$1);
 	} (dist));
 	getDefaultExportFromCjs(dist);
 
@@ -5574,7 +5776,7 @@
 	}
 	generic_legacy.PolkadotGenericAppLegacy = PolkadotGenericAppLegacy;
 
-	(function (exports) {
+	(function (exports$1) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
 		    if (k2 === undefined) k2 = k;
 		    var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -5586,19 +5788,19 @@
 		    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);
+		var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports$1) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports$1, p)) __createBinding(exports$1, m, p);
 		};
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.supportedApps = exports.newSubstrateApp = exports.SubstrateApp = void 0;
-		__exportStar(legacy_apps, exports);
-		__exportStar(generic_app, exports);
-		__exportStar(generic_legacy, exports);
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.supportedApps = exports$1.newSubstrateApp = exports$1.SubstrateApp = void 0;
+		__exportStar(legacy_apps, exports$1);
+		__exportStar(generic_app, exports$1);
+		__exportStar(generic_legacy, exports$1);
 		var substrate_app_1 = substrate_app;
-		Object.defineProperty(exports, "SubstrateApp", { enumerable: true, get: function () { return substrate_app_1.SubstrateApp; } });
+		Object.defineProperty(exports$1, "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; } });
+		Object.defineProperty(exports$1, "newSubstrateApp", { enumerable: true, get: function () { return supported_apps_1.newSubstrateApp; } });
+		Object.defineProperty(exports$1, "supportedApps", { enumerable: true, get: function () { return supported_apps_1.supportedApps; } });
 	} (dist$1));
 	getDefaultExportFromCjs(dist$1);
 
@@ -5687,7 +5889,7 @@
 	}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 __awaiter(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); } }
@@ -5820,10 +6022,18 @@
 	}) : function(o, v) {
 	  o["default"] = v;
 	};
+	var ownKeys = function(o) {
+	  ownKeys = Object.getOwnPropertyNames || function (o) {
+	    var ar = [];
+	    for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+	    return ar;
+	  };
+	  return ownKeys(o);
+	};
 	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);
+	  if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
 	  __setModuleDefault(result, mod);
 	  return result;
 	}
@@ -5915,7 +6125,7 @@
 	  __propKey,
 	  __setFunctionName,
 	  __metadata,
-	  __awaiter: __awaiter$4,
+	  __awaiter,
 	  __generator,
 	  __createBinding,
 	  __exportStar,
@@ -5947,7 +6157,7 @@
 		__asyncGenerator: __asyncGenerator,
 		__asyncValues: __asyncValues,
 		__await: __await,
-		__awaiter: __awaiter$4,
+		__awaiter: __awaiter,
 		__classPrivateFieldGet: __classPrivateFieldGet,
 		__classPrivateFieldIn: __classPrivateFieldIn,
 		__classPrivateFieldSet: __classPrivateFieldSet,
@@ -5980,8 +6190,14 @@
 
 	const EventEmitter = {};
 
+	const errorClasses = {};
+	const deserializers = {};
+	const addCustomErrorDeserializer = (name, deserializer) => {
+	    deserializers[name] = deserializer;
+	};
 	const createCustomErrorClass = (name) => {
 	    class CustomErrorClass extends Error {
+	        cause;
 	        constructor(message, fields, options) {
 	            super(message || name, options);
 	            Object.setPrototypeOf(this, CustomErrorClass.prototype);
@@ -5991,7 +6207,7 @@
 	                    this[k] = fields[k];
 	                }
 	            }
-	            if (options && isObject(options) && "cause" in options && !("cause" in this)) {
+	            if (options && isObject(options) && "cause" in options && !this.cause) {
 	                const cause = options.cause;
 	                this.cause = cause;
 	                if ("stack" in cause) {
@@ -6000,18 +6216,150 @@
 	            }
 	        }
 	    }
+	    errorClasses[name] = CustomErrorClass;
 	    return CustomErrorClass;
 	};
 	function isObject(value) {
 	    return typeof value === "object";
 	}
 
+	createCustomErrorClass("AccountNameRequired");
+	createCustomErrorClass("AccountNotSupported");
+	createCustomErrorClass("AccountAwaitingSendPendingOperations");
+	createCustomErrorClass("AmountRequired");
+	createCustomErrorClass("BluetoothRequired");
+	createCustomErrorClass("BtcUnmatchedApp");
+	createCustomErrorClass("CantOpenDevice");
+	createCustomErrorClass("CashAddrNotSupported");
+	createCustomErrorClass("ClaimRewardsFeesWarning");
+	createCustomErrorClass("CurrencyNotSupported");
+	createCustomErrorClass("DeviceAppVerifyNotSupported");
+	createCustomErrorClass("DeviceGenuineSocketEarlyClose");
+	createCustomErrorClass("DeviceNotGenuine");
+	createCustomErrorClass("DeviceOnDashboardExpected");
+	createCustomErrorClass("DeviceOnDashboardUnexpected");
+	createCustomErrorClass("DeviceInOSUExpected");
+	createCustomErrorClass("DeviceHalted");
+	createCustomErrorClass("DeviceNameInvalid");
+	createCustomErrorClass("DeviceSocketFail");
+	createCustomErrorClass("DeviceSocketNoBulkStatus");
+	createCustomErrorClass("DeviceSocketNoBulkStatus");
+	createCustomErrorClass("UnresponsiveDeviceError");
 	const DisconnectedDevice = createCustomErrorClass("DisconnectedDevice");
 	const DisconnectedDeviceDuringOperation = createCustomErrorClass("DisconnectedDeviceDuringOperation");
+	createCustomErrorClass("DeviceExtractOnboardingStateError");
+	createCustomErrorClass("DeviceOnboardingStatePollingError");
+	createCustomErrorClass("EnpointConfig");
+	createCustomErrorClass("EthAppPleaseEnableContractData");
+	createCustomErrorClass("SolAppPleaseEnableContractData");
+	createCustomErrorClass("CeloAppPleaseEnableContractData");
+	createCustomErrorClass("FeeEstimationFailed");
+	createCustomErrorClass("FirmwareNotRecognized");
+	createCustomErrorClass("HardResetFail");
+	createCustomErrorClass("InvalidXRPTag");
+	createCustomErrorClass("InvalidAddress");
+	createCustomErrorClass("InvalidNonce");
+	createCustomErrorClass("InvalidAddressBecauseDestinationIsAlsoSource");
+	createCustomErrorClass("LatestMCUInstalledError");
+	createCustomErrorClass("LatestFirmwareVersionRequired");
+	createCustomErrorClass("UnsupportedFeatureError");
+	createCustomErrorClass("NanoSNotSupported");
+	createCustomErrorClass("UnknownMCU");
+	createCustomErrorClass("LedgerAPIError");
+	createCustomErrorClass("LedgerAPIErrorWithMessage");
+	createCustomErrorClass("LedgerAPINotAvailable");
+	createCustomErrorClass("ManagerAppAlreadyInstalled");
+	createCustomErrorClass("ManagerAppRelyOnBTC");
+	createCustomErrorClass("ManagerAppDepInstallRequired");
+	createCustomErrorClass("ManagerAppDepUninstallRequired");
+	createCustomErrorClass("ManagerDeviceLocked");
+	createCustomErrorClass("ManagerFirmwareNotEnoughSpace");
+	createCustomErrorClass("ManagerNotEnoughSpace");
+	createCustomErrorClass("ManagerUninstallBTCDep");
+	createCustomErrorClass("NetworkDown");
+	createCustomErrorClass("NetworkError");
+	createCustomErrorClass("NoAddressesFound");
+	createCustomErrorClass("NotEnoughBalance");
+	createCustomErrorClass("NotEnoughBalanceFees");
+	createCustomErrorClass("NotEnoughBalanceSwap");
+	createCustomErrorClass("NotEnoughBalanceToDelegate");
+	createCustomErrorClass("UnstakeNotEnoughStakedBalanceLeft");
+	createCustomErrorClass("RestakeNotEnoughStakedBalanceLeft");
+	createCustomErrorClass("NotEnoughToRestake");
+	createCustomErrorClass("NotEnoughToUnstake");
+	createCustomErrorClass("NotEnoughBalanceInParentAccount");
+	createCustomErrorClass("NotEnoughSpendableBalance");
+	createCustomErrorClass("NotEnoughBalanceBecauseDestinationNotCreated");
+	createCustomErrorClass("NotEnoughToStake");
+	createCustomErrorClass("NoAccessToCamera");
+	createCustomErrorClass("NotEnoughGas");
+	createCustomErrorClass("NotEnoughGasSwap");
+	createCustomErrorClass("TronEmptyAccount");
+	createCustomErrorClass("MaybeKeepTronAccountAlive");
+	createCustomErrorClass("NotSupportedLegacyAddress");
+	createCustomErrorClass("GasLessThanEstimate");
+	createCustomErrorClass("PriorityFeeTooLow");
+	createCustomErrorClass("PriorityFeeTooHigh");
+	createCustomErrorClass("PriorityFeeHigherThanMaxFee");
+	createCustomErrorClass("MaxFeeTooLow");
+	createCustomErrorClass("PasswordsDontMatch");
+	createCustomErrorClass("PasswordIncorrect");
+	createCustomErrorClass("RecommendSubAccountsToEmpty");
+	createCustomErrorClass("RecommendUndelegation");
+	createCustomErrorClass("TimeoutTagged");
+	createCustomErrorClass("UnexpectedBootloader");
+	createCustomErrorClass("MCUNotGenuineToDashboard");
+	createCustomErrorClass("RecipientRequired");
+	createCustomErrorClass("UnavailableTezosOriginatedAccountReceive");
+	createCustomErrorClass("UnavailableTezosOriginatedAccountSend");
+	createCustomErrorClass("UpdateFetchFileFail");
+	createCustomErrorClass("UpdateIncorrectHash");
+	createCustomErrorClass("UpdateIncorrectSig");
+	createCustomErrorClass("UpdateYourApp");
+	createCustomErrorClass("UserRefusedDeviceNameChange");
+	createCustomErrorClass("UserRefusedAddress");
+	createCustomErrorClass("UserRefusedFirmwareUpdate");
+	createCustomErrorClass("UserRefusedAllowManager");
+	createCustomErrorClass("UserRefusedOnDevice");
+	createCustomErrorClass("PinNotSet");
+	createCustomErrorClass("ExpertModeRequired");
 	const TransportOpenUserCancelled = createCustomErrorClass("TransportOpenUserCancelled");
 	const TransportInterfaceNotAvailable = createCustomErrorClass("TransportInterfaceNotAvailable");
 	const TransportRaceCondition = createCustomErrorClass("TransportRaceCondition");
 	const TransportWebUSBGestureRequired = createCustomErrorClass("TransportWebUSBGestureRequired");
+	createCustomErrorClass("TransactionHasBeenValidatedError");
+	createCustomErrorClass("TransportExchangeTimeoutError");
+	createCustomErrorClass("DeviceShouldStayInApp");
+	createCustomErrorClass("WebsocketConnectionError");
+	createCustomErrorClass("WebsocketConnectionFailed");
+	createCustomErrorClass("WrongDeviceForAccount");
+	createCustomErrorClass("WrongDeviceForAccountPayout");
+	createCustomErrorClass("MissingSwapPayloadParamaters");
+	createCustomErrorClass("WrongDeviceForAccountRefund");
+	createCustomErrorClass("WrongAppForCurrency");
+	createCustomErrorClass("ETHAddressNonEIP");
+	createCustomErrorClass("CantScanQRCode");
+	createCustomErrorClass("FeeNotLoaded");
+	createCustomErrorClass("FeeNotLoadedSwap");
+	createCustomErrorClass("FeeRequired");
+	createCustomErrorClass("FeeTooHigh");
+	createCustomErrorClass("PendingOperation");
+	createCustomErrorClass("SyncError");
+	createCustomErrorClass("PairingFailed");
+	createCustomErrorClass("PeerRemovedPairing");
+	createCustomErrorClass("GenuineCheckFailed");
+	createCustomErrorClass("LedgerAPI4xx");
+	createCustomErrorClass("LedgerAPI5xx");
+	createCustomErrorClass("FirmwareOrAppUpdateRequired");
+	createCustomErrorClass("ReplacementTransactionUnderpriced");
+	createCustomErrorClass("OpReturnSizeLimit");
+	createCustomErrorClass("DustLimit");
+	createCustomErrorClass("LanguageNotFound");
+	createCustomErrorClass("NoDBPathGiven");
+	createCustomErrorClass("DBWrongPassword");
+	createCustomErrorClass("DBNotReset");
+	createCustomErrorClass("SequenceNumberError");
+	createCustomErrorClass("DisabledTransactionBroadcastError");
 	var HwTransportErrorType;
 	(function (HwTransportErrorType) {
 	    HwTransportErrorType["Unknown"] = "Unknown";
@@ -6020,6 +6368,7 @@
 	    HwTransportErrorType["BluetoothScanStartFailed"] = "BluetoothScanStartFailed";
 	})(HwTransportErrorType || (HwTransportErrorType = {}));
 	class TransportError extends Error {
+	    id;
 	    constructor(message, id) {
 	        const name = "TransportError";
 	        super(message || name);
@@ -6029,6 +6378,7 @@
 	        this.id = id;
 	    }
 	}
+	addCustomErrorDeserializer("TransportError", e => new TransportError(e.message, e.id));
 	const StatusCodes = {
 	    ACCESS_CONDITION_NOT_FULFILLED: 0x9804,
 	    ALGORITHM_NOT_SUPPORTED: 0x9484,
@@ -6105,6 +6455,8 @@
 	    }
 	}
 	class TransportStatusError extends Error {
+	    statusCode;
+	    statusText;
 	    constructor(statusCode, { canBeMappedToChildError = true } = {}) {
 	        const statusText = Object.keys(StatusCodes).find(k => StatusCodes[k] === statusCode) || "UNKNOWN_ERROR";
 	        const smsg = getAltStatusMessage(statusCode) || statusText;
@@ -6130,6 +6482,7 @@
 	        Object.setPrototypeOf(this, LockedDeviceError.prototype);
 	    }
 	}
+	addCustomErrorDeserializer("TransportStatusError", e => new TransportStatusError(e.statusCode));
 
 	let id = 0;
 	const subscribers = [];
@@ -6141,8 +6494,6 @@
 	    };
 	    if (message)
 	        obj.message = message;
-	    if (data)
-	        obj.data = data;
 	    dispatch(obj);
 	};
 	const trace = ({ type, message, data, context, }) => {
@@ -6160,6 +6511,8 @@
 	    dispatch(obj);
 	};
 	class LocalTracer {
+	    type;
+	    context;
 	    constructor(type, context) {
 	        this.type = type;
 	        this.context = context;
@@ -6179,7 +6532,7 @@
 	        this.context = context;
 	    }
 	    updateContext(contextToAdd) {
-	        this.context = Object.assign(Object.assign({}, this.context), contextToAdd);
+	        this.context = { ...this.context, ...contextToAdd };
 	    }
 	    getType() {
 	        return this.type;
@@ -6194,7 +6547,7 @@
 	        return new LocalTracer(this.type, context);
 	    }
 	    withUpdatedContext(contextToAdd) {
-	        return new LocalTracer(this.type, Object.assign(Object.assign({}, this.context), contextToAdd));
+	        return new LocalTracer(this.type, { ...this.context, ...contextToAdd });
 	    }
 	}
 	const listen = (cb) => {
@@ -6221,41 +6574,19 @@
 	    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 {
+	    exchangeTimeout = 30000;
+	    unresponsiveTimeout = 15000;
+	    deviceModel = null;
+	    tracer;
 	    constructor({ context, logType } = {}) {
-	        this.exchangeTimeout = 30000;
-	        this.unresponsiveTimeout = 15000;
-	        this.deviceModel = null;
-	        this._events = new EventEmitter();
-	        this.send = (cla_1, ins_1, p1_1, p2_1, ...args_1) => __awaiter$3(this, [cla_1, ins_1, p1_1, p2_1, ...args_1], void 0, function* (cla, ins, p1, p2, data = Buffer.alloc(0), statusList = [StatusCodes.OK], { abortTimeoutMs } = {}) {
-	            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);
+	        this.tracer = new LocalTracer(logType ?? DEFAULT_LOG_TYPE, context);
 	    }
+	    static isSupported;
+	    static list;
+	    static listen;
+	    static open;
 	    exchange(_apdu, { abortTimeoutMs: _abortTimeoutMs } = {}) {
 	        throw new Error("exchange not implemented");
 	    }
@@ -6264,11 +6595,11 @@
 	        const unsubscribe = () => {
 	            unsubscribed = true;
 	        };
-	        const main = () => __awaiter$3(this, void 0, void 0, function* () {
+	        const main = async () => {
 	            if (unsubscribed)
 	                return;
 	            for (const apdu of apdus) {
-	                const r = yield this.exchange(apdu);
+	                const r = await this.exchange(apdu);
 	                if (unsubscribed)
 	                    return;
 	                const status = r.readUInt16BE(r.length - 2);
@@ -6277,7 +6608,7 @@
 	                }
 	                observer.next(r);
 	            }
-	        });
+	        };
 	        main().then(() => !unsubscribed && observer.complete(), e => !unsubscribed && observer.error(e));
 	        return { unsubscribe };
 	    }
@@ -6285,6 +6616,7 @@
 	    close() {
 	        return Promise.resolve();
 	    }
+	    _events = new EventEmitter();
 	    on(eventName, cb) {
 	        this._events.on(eventName, cb);
 	    }
@@ -6303,6 +6635,20 @@
 	    setExchangeUnresponsiveTimeout(unresponsiveTimeout) {
 	        this.unresponsiveTimeout = unresponsiveTimeout;
 	    }
+	    send = async (cla, ins, p1, p2, data = Buffer.alloc(0), statusList = [StatusCodes.OK], { abortTimeoutMs } = {}) => {
+	        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");
+	        }
+	        const response = await this.exchange(
+	        Buffer.concat([Buffer.from([cla, ins, p1, p2]), Buffer.from([data.length]), data]), { abortTimeoutMs });
+	        const sw = response.readUInt16BE(response.length - 2);
+	        if (!statusList.some(s => s === sw)) {
+	            throw new TransportStatusError(sw);
+	        }
+	        return response;
+	    };
 	    static create(openTimeout = 3000, listenTimeout) {
 	        return new Promise((resolve, reject) => {
 	            let found = false;
@@ -6336,53 +6682,53 @@
 	                : null;
 	        });
 	    }
-	    exchangeAtomicImpl(f) {
-	        return __awaiter$3(this, void 0, void 0, function* () {
-	            const tracer = this.tracer.withUpdatedContext({
-	                function: "exchangeAtomicImpl",
+	    exchangeBusyPromise;
+	    async exchangeAtomicImpl(f) {
+	        const tracer = this.tracer.withUpdatedContext({
+	            function: "exchangeAtomicImpl",
+	            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,
 	            });
-	            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;
+	            unresponsiveReached = true;
+	            this.emit("unresponsive");
+	        }, this.unresponsiveTimeout);
+	        try {
+	            const res = await 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);
 	        }
 	    }
+	    _appAPIlock = null;
 	    decorateAppAPIMethod(methodName, f, ctx, scrambleKey) {
-	        return (...args) => __awaiter$3(this, void 0, void 0, function* () {
+	        return async (...args) => {
 	            const { _appAPIlock } = this;
 	            if (_appAPIlock) {
 	                return Promise.reject(new TransportError("Ledger Device is busy (lock " + _appAPIlock + ")", "TransportLocked"));
@@ -6390,12 +6736,12 @@
 	            try {
 	                this._appAPIlock = methodName;
 	                this.setScrambleKey(scrambleKey);
-	                return yield f.apply(ctx, args);
+	                return await f.apply(ctx, args);
 	            }
 	            finally {
 	                this._appAPIlock = null;
 	            }
-	        });
+	        };
 	    }
 	    setTraceContext(context) {
 	        this.tracer = this.tracer.withContext(context);
@@ -6406,9 +6752,9 @@
 	    getTraceContext() {
 	        return this.tracer.getContext();
 	    }
+	    static ErrorMessage_ListenTimeout = "No Ledger device found (timeout)";
+	    static ErrorMessage_NoDeviceFound = "No Ledger device found";
 	}
-	Transport.ErrorMessage_ListenTimeout = "No Ledger device found (timeout)";
-	Transport.ErrorMessage_NoDeviceFound = "No Ledger device found";
 
 	const Tag = 0x05;
 	function asUInt16BE(value) {
@@ -6512,18 +6858,19 @@
 	var debug_1 = debug$1;
 	getDefaultExportFromCjs(debug_1);
 
-	(function (module, exports) {
+	(function (module, exports$1) {
 		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 = {};
+		exports$1 = module.exports = {};
+		const re = exports$1.re = [];
+		const safeRe = exports$1.safeRe = [];
+		const src = exports$1.src = [];
+		const safeSrc = exports$1.safeSrc = [];
+		const t = exports$1.t = {};
 		let R = 0;
 		const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
 		const safeRegexReplacements = [
@@ -6545,6 +6892,7 @@
 		  debug(name, index, value);
 		  t[name] = index;
 		  src[index] = value;
+		  safeSrc[index] = safe;
 		  re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
 		  safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined);
 		};
@@ -6557,10 +6905,10 @@
 		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('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]
+	}|${src[t.NUMERICIDENTIFIER]})`);
+		createToken('PRERELEASEIDENTIFIERLOOSE', `(?:${src[t.NONNUMERICIDENTIFIER]
+	}|${src[t.NUMERICIDENTIFIERLOOSE]})`);
 		createToken('PRERELEASE', `(?:-(${src[t.PRERELEASEIDENTIFIER]
 	}(?:\\.${src[t.PRERELEASEIDENTIFIER]})*))`);
 		createToken('PRERELEASELOOSE', `(?:-?(${src[t.PRERELEASEIDENTIFIERLOOSE]
@@ -6593,27 +6941,32 @@
 		                        `)?)?`);
 		createToken('XRANGE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
 		createToken('XRANGELOOSE', `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
-		createToken('COERCE', `${'(^|[^\\d])' +
+		createToken('COERCEPLAIN', `${'(^|[^\\d])' +
 	              '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` +
 		              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
-		              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` +
+		              `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+		createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+		createToken('COERCEFULL', src[t.COERCEPLAIN] +
+		              `(?:${src[t.PRERELEASE]})?` +
+		              `(?:${src[t.BUILD]})?` +
 		              `(?:$|[^\\d])`);
 		createToken('COERCERTL', src[t.COERCE], true);
+		createToken('COERCERTLFULL', src[t.COERCEFULL], true);
 		createToken('LONETILDE', '(?:~>?)');
 		createToken('TILDETRIM', `(\\s*)${src[t.LONETILDE]}\\s+`, true);
-		exports.tildeTrimReplace = '$1~';
+		exports$1.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^';
+		exports$1.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';
+		exports$1.comparatorTrimReplace = '$1$2$3';
 		createToken('HYPHENRANGE', `^\\s*(${src[t.XRANGEPLAIN]})` +
 		                   `\\s+-\\s+` +
 		                   `(${src[t.XRANGEPLAIN]})` +
@@ -6645,6 +6998,9 @@
 
 	const numeric = /^[0-9]+$/;
 	const compareIdentifiers$1 = (a, b) => {
+	  if (typeof a === 'number' && typeof b === 'number') {
+	    return a === b ? 0 : a < b ? -1 : 1
+	  }
 	  const anum = numeric.test(a);
 	  const bnum = numeric.test(b);
 	  if (anum && bnum) {
@@ -6674,7 +7030,7 @@
 	    options = parseOptions(options);
 	    if (version instanceof SemVer) {
 	      if (version.loose === !!options.loose &&
-	          version.includePrerelease === !!options.includePrerelease) {
+	        version.includePrerelease === !!options.includePrerelease) {
 	        return version
 	      } else {
 	        version = version.version;
@@ -6751,19 +7107,33 @@
 	    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) {
+	    if (this.major < other.major) {
 	      return -1
-	    } else if (!this.prerelease.length && other.prerelease.length) {
+	    }
+	    if (this.major > other.major) {
+	      return 1
+	    }
+	    if (this.minor < other.minor) {
+	      return -1
+	    }
+	    if (this.minor > other.minor) {
+	      return 1
+	    }
+	    if (this.patch < other.patch) {
+	      return -1
+	    }
+	    if (this.patch > other.patch) {
+	      return 1
+	    }
+	    return 0
+	  }
+	  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
@@ -6794,7 +7164,7 @@
 	    do {
 	      const a = this.build[i];
 	      const b = other.build[i];
-	      debug('prerelease compare', i, a, b);
+	      debug('build compare', i, a, b);
 	      if (a === undefined && b === undefined) {
 	        return 0
 	      } else if (b === undefined) {
@@ -6809,6 +7179,17 @@
 	    } while (++i)
 	  }
 	  inc (release, identifier, identifierBase) {
+	    if (release.startsWith('pre')) {
+	      if (!identifier && identifierBase === false) {
+	        throw new Error('invalid increment argument: identifier is empty')
+	      }
+	      if (identifier) {
+	        const match = `-${identifier}`.match(this.options.loose ? re$1[t$1.PRERELEASELOOSE] : re$1[t$1.PRERELEASE]);
+	        if (!match || match[1] !== identifier) {
+	          throw new Error(`invalid identifier: ${identifier}`)
+	        }
+	      }
+	    }
 	    switch (release) {
 	      case 'premajor':
 	        this.prerelease.length = 0;
@@ -6834,6 +7215,12 @@
 	        }
 	        this.inc('pre', identifier, identifierBase);
 	        break
+	      case 'release':
+	        if (this.prerelease.length === 0) {
+	          throw new Error(`version ${this.raw} is not a prerelease`)
+	        }
+	        this.prerelease.length = 0;
+	        break
 	      case 'major':
 	        if (
 	          this.minor !== 0 ||
@@ -6861,9 +7248,6 @@
 	        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 {
@@ -6978,13 +7362,12 @@
 	    if (!lowVersion.patch && !lowVersion.minor) {
 	      return 'major'
 	    }
-	    if (highVersion.patch) {
+	    if (lowVersion.compareMain(highVersion) === 0) {
+	      if (lowVersion.minor && !lowVersion.patch) {
+	        return 'minor'
+	      }
 	      return 'patch'
 	    }
-	    if (highVersion.minor) {
-	      return 'minor'
-	    }
-	    return 'major'
 	  }
 	  const prefix = highHasPre ? 'pre' : '';
 	  if (v1.major !== v2.major) {
@@ -7150,679 +7533,71 @@
 	  options = options || {};
 	  let match = null;
 	  if (!options.rtl) {
-	    match = version.match(re[t.COERCE]);
+	    match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
 	  } else {
+	    const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
 	    let next;
-	    while ((next = re[t.COERCERTL].exec(version)) &&
+	    while ((next = coerceRtlRegex.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;
+	      coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
 	    }
-	    re[t.COERCERTL].lastIndex = -1;
+	    coerceRtlRegex.lastIndex = -1;
 	  }
 	  if (match === null) {
 	    return null
 	  }
-	  return parse$1(`${match[2]}.${match[3] || '0'}.${match[4] || '0'}`, options)
+	  const major = match[2];
+	  const minor = match[3] || '0';
+	  const patch = match[4] || '0';
+	  const prerelease = options.includePrerelease && match[5] ? `-${match[5]}` : '';
+	  const build = options.includePrerelease && match[6] ? `+${match[6]}` : '';
+	  return parse$1(`${major}.${minor}.${patch}${prerelease}${build}`, 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;
+	var lrucache;
+	var hasRequiredLrucache;
+	function requireLrucache () {
+		if (hasRequiredLrucache) return lrucache;
+		hasRequiredLrucache = 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)
+		  constructor () {
+		    this.max = 1000;
+		    this.map = new Map();
 		  }
 		  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);
-		        }
-		      }
+		    const value = this.map.get(key);
+		    if (value === undefined) {
+		      return undefined
+		    } else {
+		      this.map.delete(key);
+		      this.map.set(key, value);
+		      return value
 		    }
 		  }
-		  prune () {
-		    this[CACHE].forEach((value, key) => get(this, key, false));
+		  delete (key) {
+		    return this.map.delete(key)
 		  }
-		}
-		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);
+		  set (key, value) {
+		    const deleted = this.delete(key);
+		    if (!deleted && value !== undefined) {
+		      if (this.map.size >= this.max) {
+		        const firstKey = this.map.keys().next().value;
+		        this.delete(firstKey);
 		      }
+		      this.map.set(key, value);
 		    }
-		    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;
+		    return this
 		  }
 		}
-		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;
+		lrucache = LRUCache;
+		return lrucache;
 	}
 
 	var range;
@@ -7830,6 +7605,7 @@
 	function requireRange () {
 		if (hasRequiredRange) return range;
 		hasRequiredRange = 1;
+		const SPACE_CHARACTERS = /\s+/g;
 		class Range {
 		  constructor (range, options) {
 		    options = parseOptions(options);
@@ -7846,16 +7622,13 @@
 		    if (range instanceof Comparator) {
 		      this.raw = range.value;
 		      this.set = [[range]];
-		      this.format();
+		      this.formatted = undefined;
 		      return this
 		    }
 		    this.options = options;
 		    this.loose = !!options.loose;
 		    this.includePrerelease = !!options.includePrerelease;
-		    this.raw = range
-		      .trim()
-		      .split(/\s+/)
-		      .join(' ');
+		    this.raw = range.trim().replace(SPACE_CHARACTERS, ' ');
 		    this.set = this.raw
 		      .split('||')
 		      .map(r => this.parseRange(r.trim()))
@@ -7877,13 +7650,27 @@
 		        }
 		      }
 		    }
-		    this.format();
+		    this.formatted = undefined;
+		  }
+		  get range () {
+		    if (this.formatted === undefined) {
+		      this.formatted = '';
+		      for (let i = 0; i < this.set.length; i++) {
+		        if (i > 0) {
+		          this.formatted += '||';
+		        }
+		        const comps = this.set[i];
+		        for (let k = 0; k < comps.length; k++) {
+		          if (k > 0) {
+		            this.formatted += ' ';
+		          }
+		          this.formatted += comps[k].toString().trim();
+		        }
+		      }
+		    }
+		    return this.formatted
 		  }
 		  format () {
-		    this.range = this.set
-		      .map((comps) => comps.join(' ').trim())
-		      .join('||')
-		      .trim();
 		    return this.range
 		  }
 		  toString () {
@@ -7976,8 +7763,8 @@
 		  }
 		}
 		range = Range;
-		const LRU = requireLruCache();
-		const cache = new LRU({ max: 1000 });
+		const LRU = requireLrucache();
+		const cache = new LRU();
 		const parseOptions = parseOptions_1;
 		const Comparator = requireComparator();
 		const debug = debug_1;
@@ -8005,6 +7792,7 @@
 		  return result
 		};
 		const parseComparator = (comp, options) => {
+		  comp = comp.replace(re[t.BUILD], '');
 		  debug('comp', comp, options);
 		  comp = replaceCarets(comp, options);
 		  debug('caret', comp);
@@ -8181,7 +7969,7 @@
 		};
 		const hyphenReplace = incPr => ($0,
 		  from, fM, fm, fp, fpr, fb,
-		  to, tM, tm, tp, tpr, tb) => {
+		  to, tM, tm, tp, tpr) => {
 		  if (isX(fM)) {
 		    from = '';
 		  } else if (isX(fm)) {
@@ -8887,6 +8675,7 @@
 	    DeviceModelId["nanoX"] = "nanoX";
 	    DeviceModelId["stax"] = "stax";
 	    DeviceModelId["europa"] = "europa";
+	    DeviceModelId["apex"] = "apex";
 	})(DeviceModelId || (DeviceModelId = {}));
 	const devices = {
 	    [DeviceModelId.blue]: {
@@ -8907,7 +8696,7 @@
 	        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; },
+	        getBlockSize: (firmwareVersion) => semver$1.lt(semver$1.coerce(firmwareVersion) ?? "", "2.0.0") ? 4 * 1024 : 2 * 1024,
 	    },
 	    [DeviceModelId.nanoX]: {
 	        id: DeviceModelId.nanoX,
@@ -8937,6 +8726,24 @@
 	        masks: [0x33100000],
 	        getBlockSize: (_firmwareVersion) => 32,
 	    },
+	    [DeviceModelId.apex]: {
+	        id: DeviceModelId.apex,
+	        productName: "Ledger Nano Gen5",
+	        productIdMM: 0x80,
+	        legacyUsbProductId: 0x0008,
+	        usbOnly: false,
+	        memorySize: 1533 * 1024,
+	        masks: [0x33400000],
+	        getBlockSize: (_firmwareVersion) => 32,
+	        bluetoothSpec: [
+	            {
+	                serviceUuid: "13d63400-2c97-8004-0000-4c6564676572",
+	                notifyUuid: "13d63400-2c97-8004-0001-4c6564676572",
+	                writeUuid: "13d63400-2c97-8004-0002-4c6564676572",
+	                writeCmdUuid: "13d63400-2c97-8004-0003-4c6564676572",
+	            },
+	        ],
+	    },
 	    [DeviceModelId.stax]: {
 	        id: DeviceModelId.stax,
 	        productName: "Ledger Stax",
@@ -9001,20 +8808,14 @@
 	        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);
+	            serviceUuidToInfos[spec.serviceUuid] = serviceUuidToInfos[spec.serviceUuid.replace(/-/g, "")] = {
+	                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,
@@ -9027,159 +8828,156 @@
 	        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];
+	async function requestLedgerDevices() {
+	    const device = await 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);
-	    });
+	async function getLedgerDevices$1() {
+	    const devices = await 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];
-	    });
+	async function getFirstLedgerDevice$1() {
+	    const existingDevices = await getLedgerDevices$1();
+	    if (existingDevices.length > 0)
+	        return existingDevices[0];
+	    const devices = await requestLedgerDevices();
+	    return devices[0];
 	}
 	class TransportWebHID extends Transport {
+	    device;
+	    deviceModel;
+	    channel = Math.floor(Math.random() * 0xffff);
+	    packetSize = 64;
 	    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);
+	    inputs = [];
+	    inputCallback;
+	    read = () => {
+	        if (this.inputs.length) {
+	            return Promise.resolve(this.inputs.shift());
+	        }
+	        return new Promise(success => {
+	            this.inputCallback = success;
 	        });
-	    }
-	    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]);
+	    };
+	    onInputReport = (e) => {
+	        const buffer = Buffer.from(e.data.buffer);
+	        if (this.inputCallback) {
+	            this.inputCallback(buffer);
+	            this.inputCallback = null;
+	        }
+	        else {
+	            this.inputs.push(buffer);
+	        }
+	    };
+	    static isSupported = isSupported$1;
+	    static list = getLedgerDevices$1;
+	    static 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));
 	        });
-	    }
-	    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());
+	        function unsubscribe() {
+	            unsubscribed = true;
+	        }
+	        return {
+	            unsubscribe,
+	        };
+	    };
+	    static async request() {
+	        const [device] = await requestLedgerDevices();
+	        return TransportWebHID.open(device);
+	    }
+	    static async openConnected() {
+	        const devices = await getLedgerDevices$1();
+	        if (devices.length === 0)
+	            return null;
+	        return TransportWebHID.open(devices[0]);
+	    }
+	    static async open(device) {
+	        await 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;
+	    }
+	    _disconnectEmitted = false;
+	    _emitDisconnect = (e) => {
+	        if (this._disconnectEmitted)
+	            return;
+	        this._disconnectEmitted = true;
+	        this.emit("disconnect", e);
+	    };
+	    async close() {
+	        await this.exchangeBusyPromise;
+	        this.device.removeEventListener("inputreport", this.onInputReport);
+	        await this.device.close();
+	    }
+	    exchange = async (apdu) => {
+	        const b = await this.exchangeAtomicImpl(async () => {
+	            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++) {
+	                await this.device.sendReport(0, blocks[i]);
+	            }
+	            let result;
+	            let acc;
+	            while (!(result = framing.getReducedResult(acc))) {
+	                try {
+	                    const buffer = await this.read();
+	                    acc = framing.reduceResponse(acc, buffer);
 	                }
-	            };
-	            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();
+	                catch (e) {
+	                    if (e instanceof TransportError && e.id === "InvalidChannel") {
+	                        continue;
+	                    }
+	                    throw e;
+	                }
+	            }
+	            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;
+	    };
 	    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,
@@ -9188,192 +8986,159 @@
 
 	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;
+	async function requestLedgerDevice() {
+	    const device = await 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);
-	    });
+	async function getLedgerDevices() {
+	    const devices = await 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();
-	    });
+	async function getFirstLedgerDevice() {
+	    const existingDevices = await 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 {
+	    device;
+	    deviceModel;
+	    channel = Math.floor(Math.random() * 0xffff);
+	    packetSize = 64;
+	    interfaceNumber;
 	    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 isSupported = isSupported;
+	    static list = getLedgerDevices;
+	    static 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));
+	            }
 	        });
-	    }
-	    static open(device) {
-	        return __awaiter(this, void 0, void 0, function* () {
-	            yield device.open();
-	            if (device.configuration === null) {
-	                yield device.selectConfiguration(configurationValue);
+	        function unsubscribe() {
+	            unsubscribed = true;
+	        }
+	        return {
+	            unsubscribe,
+	        };
+	    };
+	    static async request() {
+	        const device = await requestLedgerDevice();
+	        return TransportWebUSB.open(device);
+	    }
+	    static async openConnected() {
+	        const devices = await getLedgerDevices();
+	        if (devices.length === 0)
+	            return null;
+	        return TransportWebUSB.open(devices[0]);
+	    }
+	    static async open(device) {
+	        await device.open();
+	        if (device.configuration === null) {
+	            await device.selectConfiguration(configurationValue);
+	        }
+	        await 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 {
+	            await device.claimInterface(interfaceNumber);
+	        }
+	        catch (e) {
+	            await 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());
 	            }
-	            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.");
+	        };
+	        navigator.usb.addEventListener("disconnect", onDisconnect);
+	        return transport;
+	    }
+	    _disconnectEmitted = false;
+	    _emitDisconnect = (e) => {
+	        if (this._disconnectEmitted)
+	            return;
+	        this._disconnectEmitted = true;
+	        this.emit("disconnect", e);
+	    };
+	    async close() {
+	        await this.exchangeBusyPromise;
+	        await this.device.releaseInterface(this.interfaceNumber);
+	        await gracefullyResetDevice(this.device);
+	        await this.device.close();
+	    }
+	    async exchange(apdu) {
+	        const b = await this.exchangeAtomicImpl(async () => {
+	            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++) {
+	                await this.device.transferOut(endpointNumber, blocks[i]);
 	            }
-	            const interfaceNumber = iface.interfaceNumber;
-	            try {
-	                yield device.claimInterface(interfaceNumber);
+	            let result;
+	            let acc;
+	            while (!(result = framing.getReducedResult(acc))) {
+	                const r = await this.device.transferIn(endpointNumber, packetSize);
+	                const buffer = Buffer.from(r.data.buffer);
+	                acc = framing.reduceResponse(acc, buffer);
 	            }
-	            catch (e) {
-	                yield device.close();
-	                throw new TransportInterfaceNotAvailable(e.message);
+	            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);
 	            }
-	            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;
+	            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;
+	async function gracefullyResetDevice(device) {
+	    try {
+	        await device.reset();
+	    }
+	    catch (err) {
+	        console.warn(err);
 	    }
-	    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({
@@ -9408,20 +9173,20 @@
 		hasRequiredPackageInfo = 1;
 		Object.defineProperty(packageInfo, "__esModule", { value: true });
 		packageInfo.packageInfo = void 0;
-		packageInfo.packageInfo = { name: '@pezkuwi/hw-ledger-transports', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '14.0.6' };
+		packageInfo.packageInfo = { name: '@pezkuwi/hw-ledger-transports', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '14.0.10' };
 		return packageInfo;
 	}
 
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.transports = exports.packageInfo = void 0;
+	(function (exports$1) {
+		Object.defineProperty(exports$1, "__esModule", { value: true });
+		exports$1.transports = exports$1.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]);
+		Object.defineProperty(exports$1, "packageInfo", { enumerable: true, get: function () { return packageInfo_js_1.packageInfo; } });
+		exports$1.transports = (0, util_js_1.createDefs)(['webusb', hw_transport_webusb_1.default], ['hid', hw_transport_webhid_1.default]);
 	} (browser));
 	getDefaultExportFromCjs(browser);