@sip-protocol/sdk 0.5.1 → 0.6.0

package/dist/browser.js

@@ -5,6 +5,12 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,17 +21,3167 @@ var __copyProps = (to, from, except, desc) => {
       if (!__hasOwnProp.call(to, key) && key !== except)
         __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
   }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../node_modules/.pnpm/@ledgerhq+errors@6.27.0/node_modules/@ledgerhq/errors/lib-es/helpers.js
+function isObject(value) {
+  return typeof value === "object";
+}
+var errorClasses, deserializers, addCustomErrorDeserializer, createCustomErrorClass;
+var init_helpers = __esm({
+  "../../node_modules/.pnpm/@ledgerhq+errors@6.27.0/node_modules/@ledgerhq/errors/lib-es/helpers.js"() {
+    "use strict";
+    errorClasses = {};
+    deserializers = {};
+    addCustomErrorDeserializer = (name, deserializer) => {
+      deserializers[name] = deserializer;
+    };
+    createCustomErrorClass = (name) => {
+      class CustomErrorClass extends Error {
+        cause;
+        constructor(message, fields, options) {
+          super(message || name, options);
+          Object.setPrototypeOf(this, CustomErrorClass.prototype);
+          this.name = name;
+          if (fields) {
+            for (const k in fields) {
+              this[k] = fields[k];
+            }
+          }
+          if (options && isObject(options) && "cause" in options && !this.cause) {
+            const cause = options.cause;
+            this.cause = cause;
+            if ("stack" in cause) {
+              this.stack = this.stack + "\nCAUSE: " + cause.stack;
+            }
+          }
+        }
+      }
+      errorClasses[name] = CustomErrorClass;
+      return CustomErrorClass;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@ledgerhq+errors@6.27.0/node_modules/@ledgerhq/errors/lib-es/index.js
+function getAltStatusMessage(code) {
+  switch (code) {
+    // improve text of most common errors
+    case 26368:
+      return "Incorrect length";
+    case 26624:
+      return "Missing critical parameter";
+    case 27010:
+      return "Security not satisfied (dongle locked or have invalid access rights)";
+    case 27013:
+      return "Condition of use not satisfied (denied by the user?)";
+    case 27264:
+      return "Invalid data received";
+    case 27392:
+      return "Invalid parameter received";
+    case 21781:
+      return "Locked device";
+  }
+  if (28416 <= code && code <= 28671) {
+    return "Internal error, please report";
+  }
+}
+var AccountNameRequiredError, AccountNotSupported, AccountAwaitingSendPendingOperations, AmountRequired, BluetoothRequired, BtcUnmatchedApp, CantOpenDevice, CashAddrNotSupported, ClaimRewardsFeesWarning, CurrencyNotSupported, DeviceAppVerifyNotSupported, DeviceGenuineSocketEarlyClose, DeviceNotGenuineError, DeviceOnDashboardExpected, DeviceOnDashboardUnexpected, DeviceInOSUExpected, DeviceHalted, DeviceNameInvalid, DeviceSocketFail, DeviceSocketNoBulkStatus, DeviceNeedsRestart, UnresponsiveDeviceError, DisconnectedDevice, DisconnectedDeviceDuringOperation, DeviceExtractOnboardingStateError, DeviceOnboardingStatePollingError, EnpointConfigError, EthAppPleaseEnableContractData, CeloAppPleaseEnableContractData, FeeEstimationFailed, FirmwareNotRecognized, HardResetFail, InvalidXRPTag, InvalidAddress, InvalidNonce, InvalidAddressBecauseDestinationIsAlsoSource, LatestMCUInstalledError, LatestFirmwareVersionRequired, UnknownMCU, LedgerAPIError, LedgerAPIErrorWithMessage, LedgerAPINotAvailable, ManagerAppAlreadyInstalledError, ManagerAppRelyOnBTCError, ManagerAppDepInstallRequired, ManagerAppDepUninstallRequired, ManagerDeviceLockedError, ManagerFirmwareNotEnoughSpaceError, ManagerNotEnoughSpaceError, ManagerUninstallBTCDep, NetworkDown, NetworkError2, NoAddressesFound, NotEnoughBalance, NotEnoughBalanceFees, NotEnoughBalanceSwap, NotEnoughBalanceToDelegate, UnstakeNotEnoughStakedBalanceLeft, RestakeNotEnoughStakedBalanceLeft, NotEnoughToRestake, NotEnoughToUnstake, NotEnoughBalanceInParentAccount, NotEnoughSpendableBalance, NotEnoughBalanceBecauseDestinationNotCreated, NotEnoughToStake, NoAccessToCamera, NotEnoughGas, NotEnoughGasSwap, TronEmptyAccount, MaybeKeepTronAccountAlive, NotSupportedLegacyAddress, GasLessThanEstimate, PriorityFeeTooLow, PriorityFeeTooHigh, PriorityFeeHigherThanMaxFee, MaxFeeTooLow, PasswordsDontMatchError, PasswordIncorrectError, RecommendSubAccountsToEmpty, RecommendUndelegation, TimeoutTagged, UnexpectedBootloader, MCUNotGenuineToDashboard, RecipientRequired, UnavailableTezosOriginatedAccountReceive, UnavailableTezosOriginatedAccountSend, UpdateFetchFileFail, UpdateIncorrectHash, UpdateIncorrectSig, UpdateYourApp, UserRefusedDeviceNameChange, UserRefusedAddress, UserRefusedFirmwareUpdate, UserRefusedAllowManager, UserRefusedOnDevice, PinNotSet, ExpertModeRequired, TransportOpenUserCancelled, TransportInterfaceNotAvailable, TransportRaceCondition, TransportWebUSBGestureRequired, TransactionHasBeenValidatedError, TransportExchangeTimeoutError, DeviceShouldStayInApp, WebsocketConnectionError, WebsocketConnectionFailed, WrongDeviceForAccount, WrongDeviceForAccountPayout, MissingSwapPayloadParamaters, WrongDeviceForAccountRefund, WrongAppForCurrency, ETHAddressNonEIP, CantScanQRCode, FeeNotLoaded, FeeNotLoadedSwap, FeeRequired, FeeTooHigh, PendingOperation, SyncError, PairingFailed, PeerRemovedPairing, GenuineCheckFailed, LedgerAPI4xx, LedgerAPI5xx, FirmwareOrAppUpdateRequired, ReplacementTransactionUnderpriced, OpReturnDataSizeLimit, DustLimit, LanguageNotFound, NoDBPathGiven, DBWrongPassword, DBNotReset, SequenceNumberError, DisabledTransactionBroadcastError, HwTransportErrorType, TransportError, StatusCodes, TransportStatusError, LockedDeviceError;
+var init_lib_es = __esm({
+  "../../node_modules/.pnpm/@ledgerhq+errors@6.27.0/node_modules/@ledgerhq/errors/lib-es/index.js"() {
+    "use strict";
+    init_helpers();
+    AccountNameRequiredError = createCustomErrorClass("AccountNameRequired");
+    AccountNotSupported = createCustomErrorClass("AccountNotSupported");
+    AccountAwaitingSendPendingOperations = createCustomErrorClass("AccountAwaitingSendPendingOperations");
+    AmountRequired = createCustomErrorClass("AmountRequired");
+    BluetoothRequired = createCustomErrorClass("BluetoothRequired");
+    BtcUnmatchedApp = createCustomErrorClass("BtcUnmatchedApp");
+    CantOpenDevice = createCustomErrorClass("CantOpenDevice");
+    CashAddrNotSupported = createCustomErrorClass("CashAddrNotSupported");
+    ClaimRewardsFeesWarning = createCustomErrorClass("ClaimRewardsFeesWarning");
+    CurrencyNotSupported = createCustomErrorClass("CurrencyNotSupported");
+    DeviceAppVerifyNotSupported = createCustomErrorClass("DeviceAppVerifyNotSupported");
+    DeviceGenuineSocketEarlyClose = createCustomErrorClass("DeviceGenuineSocketEarlyClose");
+    DeviceNotGenuineError = createCustomErrorClass("DeviceNotGenuine");
+    DeviceOnDashboardExpected = createCustomErrorClass("DeviceOnDashboardExpected");
+    DeviceOnDashboardUnexpected = createCustomErrorClass("DeviceOnDashboardUnexpected");
+    DeviceInOSUExpected = createCustomErrorClass("DeviceInOSUExpected");
+    DeviceHalted = createCustomErrorClass("DeviceHalted");
+    DeviceNameInvalid = createCustomErrorClass("DeviceNameInvalid");
+    DeviceSocketFail = createCustomErrorClass("DeviceSocketFail");
+    DeviceSocketNoBulkStatus = createCustomErrorClass("DeviceSocketNoBulkStatus");
+    DeviceNeedsRestart = createCustomErrorClass("DeviceSocketNoBulkStatus");
+    UnresponsiveDeviceError = createCustomErrorClass("UnresponsiveDeviceError");
+    DisconnectedDevice = createCustomErrorClass("DisconnectedDevice");
+    DisconnectedDeviceDuringOperation = createCustomErrorClass("DisconnectedDeviceDuringOperation");
+    DeviceExtractOnboardingStateError = createCustomErrorClass("DeviceExtractOnboardingStateError");
+    DeviceOnboardingStatePollingError = createCustomErrorClass("DeviceOnboardingStatePollingError");
+    EnpointConfigError = createCustomErrorClass("EnpointConfig");
+    EthAppPleaseEnableContractData = createCustomErrorClass("EthAppPleaseEnableContractData");
+    CeloAppPleaseEnableContractData = createCustomErrorClass("CeloAppPleaseEnableContractData");
+    FeeEstimationFailed = createCustomErrorClass("FeeEstimationFailed");
+    FirmwareNotRecognized = createCustomErrorClass("FirmwareNotRecognized");
+    HardResetFail = createCustomErrorClass("HardResetFail");
+    InvalidXRPTag = createCustomErrorClass("InvalidXRPTag");
+    InvalidAddress = createCustomErrorClass("InvalidAddress");
+    InvalidNonce = createCustomErrorClass("InvalidNonce");
+    InvalidAddressBecauseDestinationIsAlsoSource = createCustomErrorClass("InvalidAddressBecauseDestinationIsAlsoSource");
+    LatestMCUInstalledError = createCustomErrorClass("LatestMCUInstalledError");
+    LatestFirmwareVersionRequired = createCustomErrorClass("LatestFirmwareVersionRequired");
+    UnknownMCU = createCustomErrorClass("UnknownMCU");
+    LedgerAPIError = createCustomErrorClass("LedgerAPIError");
+    LedgerAPIErrorWithMessage = createCustomErrorClass("LedgerAPIErrorWithMessage");
+    LedgerAPINotAvailable = createCustomErrorClass("LedgerAPINotAvailable");
+    ManagerAppAlreadyInstalledError = createCustomErrorClass("ManagerAppAlreadyInstalled");
+    ManagerAppRelyOnBTCError = createCustomErrorClass("ManagerAppRelyOnBTC");
+    ManagerAppDepInstallRequired = createCustomErrorClass("ManagerAppDepInstallRequired");
+    ManagerAppDepUninstallRequired = createCustomErrorClass("ManagerAppDepUninstallRequired");
+    ManagerDeviceLockedError = createCustomErrorClass("ManagerDeviceLocked");
+    ManagerFirmwareNotEnoughSpaceError = createCustomErrorClass("ManagerFirmwareNotEnoughSpace");
+    ManagerNotEnoughSpaceError = createCustomErrorClass("ManagerNotEnoughSpace");
+    ManagerUninstallBTCDep = createCustomErrorClass("ManagerUninstallBTCDep");
+    NetworkDown = createCustomErrorClass("NetworkDown");
+    NetworkError2 = createCustomErrorClass("NetworkError");
+    NoAddressesFound = createCustomErrorClass("NoAddressesFound");
+    NotEnoughBalance = createCustomErrorClass("NotEnoughBalance");
+    NotEnoughBalanceFees = createCustomErrorClass("NotEnoughBalanceFees");
+    NotEnoughBalanceSwap = createCustomErrorClass("NotEnoughBalanceSwap");
+    NotEnoughBalanceToDelegate = createCustomErrorClass("NotEnoughBalanceToDelegate");
+    UnstakeNotEnoughStakedBalanceLeft = createCustomErrorClass("UnstakeNotEnoughStakedBalanceLeft");
+    RestakeNotEnoughStakedBalanceLeft = createCustomErrorClass("RestakeNotEnoughStakedBalanceLeft");
+    NotEnoughToRestake = createCustomErrorClass("NotEnoughToRestake");
+    NotEnoughToUnstake = createCustomErrorClass("NotEnoughToUnstake");
+    NotEnoughBalanceInParentAccount = createCustomErrorClass("NotEnoughBalanceInParentAccount");
+    NotEnoughSpendableBalance = createCustomErrorClass("NotEnoughSpendableBalance");
+    NotEnoughBalanceBecauseDestinationNotCreated = createCustomErrorClass("NotEnoughBalanceBecauseDestinationNotCreated");
+    NotEnoughToStake = createCustomErrorClass("NotEnoughToStake");
+    NoAccessToCamera = createCustomErrorClass("NoAccessToCamera");
+    NotEnoughGas = createCustomErrorClass("NotEnoughGas");
+    NotEnoughGasSwap = createCustomErrorClass("NotEnoughGasSwap");
+    TronEmptyAccount = createCustomErrorClass("TronEmptyAccount");
+    MaybeKeepTronAccountAlive = createCustomErrorClass("MaybeKeepTronAccountAlive");
+    NotSupportedLegacyAddress = createCustomErrorClass("NotSupportedLegacyAddress");
+    GasLessThanEstimate = createCustomErrorClass("GasLessThanEstimate");
+    PriorityFeeTooLow = createCustomErrorClass("PriorityFeeTooLow");
+    PriorityFeeTooHigh = createCustomErrorClass("PriorityFeeTooHigh");
+    PriorityFeeHigherThanMaxFee = createCustomErrorClass("PriorityFeeHigherThanMaxFee");
+    MaxFeeTooLow = createCustomErrorClass("MaxFeeTooLow");
+    PasswordsDontMatchError = createCustomErrorClass("PasswordsDontMatch");
+    PasswordIncorrectError = createCustomErrorClass("PasswordIncorrect");
+    RecommendSubAccountsToEmpty = createCustomErrorClass("RecommendSubAccountsToEmpty");
+    RecommendUndelegation = createCustomErrorClass("RecommendUndelegation");
+    TimeoutTagged = createCustomErrorClass("TimeoutTagged");
+    UnexpectedBootloader = createCustomErrorClass("UnexpectedBootloader");
+    MCUNotGenuineToDashboard = createCustomErrorClass("MCUNotGenuineToDashboard");
+    RecipientRequired = createCustomErrorClass("RecipientRequired");
+    UnavailableTezosOriginatedAccountReceive = createCustomErrorClass("UnavailableTezosOriginatedAccountReceive");
+    UnavailableTezosOriginatedAccountSend = createCustomErrorClass("UnavailableTezosOriginatedAccountSend");
+    UpdateFetchFileFail = createCustomErrorClass("UpdateFetchFileFail");
+    UpdateIncorrectHash = createCustomErrorClass("UpdateIncorrectHash");
+    UpdateIncorrectSig = createCustomErrorClass("UpdateIncorrectSig");
+    UpdateYourApp = createCustomErrorClass("UpdateYourApp");
+    UserRefusedDeviceNameChange = createCustomErrorClass("UserRefusedDeviceNameChange");
+    UserRefusedAddress = createCustomErrorClass("UserRefusedAddress");
+    UserRefusedFirmwareUpdate = createCustomErrorClass("UserRefusedFirmwareUpdate");
+    UserRefusedAllowManager = createCustomErrorClass("UserRefusedAllowManager");
+    UserRefusedOnDevice = createCustomErrorClass("UserRefusedOnDevice");
+    PinNotSet = createCustomErrorClass("PinNotSet");
+    ExpertModeRequired = createCustomErrorClass("ExpertModeRequired");
+    TransportOpenUserCancelled = createCustomErrorClass("TransportOpenUserCancelled");
+    TransportInterfaceNotAvailable = createCustomErrorClass("TransportInterfaceNotAvailable");
+    TransportRaceCondition = createCustomErrorClass("TransportRaceCondition");
+    TransportWebUSBGestureRequired = createCustomErrorClass("TransportWebUSBGestureRequired");
+    TransactionHasBeenValidatedError = createCustomErrorClass("TransactionHasBeenValidatedError");
+    TransportExchangeTimeoutError = createCustomErrorClass("TransportExchangeTimeoutError");
+    DeviceShouldStayInApp = createCustomErrorClass("DeviceShouldStayInApp");
+    WebsocketConnectionError = createCustomErrorClass("WebsocketConnectionError");
+    WebsocketConnectionFailed = createCustomErrorClass("WebsocketConnectionFailed");
+    WrongDeviceForAccount = createCustomErrorClass("WrongDeviceForAccount");
+    WrongDeviceForAccountPayout = createCustomErrorClass("WrongDeviceForAccountPayout");
+    MissingSwapPayloadParamaters = createCustomErrorClass("MissingSwapPayloadParamaters");
+    WrongDeviceForAccountRefund = createCustomErrorClass("WrongDeviceForAccountRefund");
+    WrongAppForCurrency = createCustomErrorClass("WrongAppForCurrency");
+    ETHAddressNonEIP = createCustomErrorClass("ETHAddressNonEIP");
+    CantScanQRCode = createCustomErrorClass("CantScanQRCode");
+    FeeNotLoaded = createCustomErrorClass("FeeNotLoaded");
+    FeeNotLoadedSwap = createCustomErrorClass("FeeNotLoadedSwap");
+    FeeRequired = createCustomErrorClass("FeeRequired");
+    FeeTooHigh = createCustomErrorClass("FeeTooHigh");
+    PendingOperation = createCustomErrorClass("PendingOperation");
+    SyncError = createCustomErrorClass("SyncError");
+    PairingFailed = createCustomErrorClass("PairingFailed");
+    PeerRemovedPairing = createCustomErrorClass("PeerRemovedPairing");
+    GenuineCheckFailed = createCustomErrorClass("GenuineCheckFailed");
+    LedgerAPI4xx = createCustomErrorClass("LedgerAPI4xx");
+    LedgerAPI5xx = createCustomErrorClass("LedgerAPI5xx");
+    FirmwareOrAppUpdateRequired = createCustomErrorClass("FirmwareOrAppUpdateRequired");
+    ReplacementTransactionUnderpriced = createCustomErrorClass("ReplacementTransactionUnderpriced");
+    OpReturnDataSizeLimit = createCustomErrorClass("OpReturnSizeLimit");
+    DustLimit = createCustomErrorClass("DustLimit");
+    LanguageNotFound = createCustomErrorClass("LanguageNotFound");
+    NoDBPathGiven = createCustomErrorClass("NoDBPathGiven");
+    DBWrongPassword = createCustomErrorClass("DBWrongPassword");
+    DBNotReset = createCustomErrorClass("DBNotReset");
+    SequenceNumberError = createCustomErrorClass("SequenceNumberError");
+    DisabledTransactionBroadcastError = createCustomErrorClass("DisabledTransactionBroadcastError");
+    (function(HwTransportErrorType2) {
+      HwTransportErrorType2["Unknown"] = "Unknown";
+      HwTransportErrorType2["LocationServicesDisabled"] = "LocationServicesDisabled";
+      HwTransportErrorType2["LocationServicesUnauthorized"] = "LocationServicesUnauthorized";
+      HwTransportErrorType2["BluetoothScanStartFailed"] = "BluetoothScanStartFailed";
+    })(HwTransportErrorType || (HwTransportErrorType = {}));
+    TransportError = class extends Error {
+      id;
+      constructor(message, id2) {
+        const name = "TransportError";
+        super(message || name);
+        this.name = name;
+        this.message = message;
+        this.stack = new Error(message).stack;
+        this.id = id2;
+      }
+    };
+    addCustomErrorDeserializer("TransportError", (e) => new TransportError(e.message, e.id));
+    StatusCodes = {
+      ACCESS_CONDITION_NOT_FULFILLED: 38916,
+      ALGORITHM_NOT_SUPPORTED: 38020,
+      CLA_NOT_SUPPORTED: 28160,
+      CODE_BLOCKED: 38976,
+      CODE_NOT_INITIALIZED: 38914,
+      COMMAND_INCOMPATIBLE_FILE_STRUCTURE: 27009,
+      CONDITIONS_OF_USE_NOT_SATISFIED: 27013,
+      CONTRADICTION_INVALIDATION: 38928,
+      CONTRADICTION_SECRET_CODE_STATUS: 38920,
+      DEVICE_IN_RECOVERY_MODE: 26159,
+      CUSTOM_IMAGE_EMPTY: 26158,
+      FILE_ALREADY_EXISTS: 27273,
+      FILE_NOT_FOUND: 37892,
+      GP_AUTH_FAILED: 25344,
+      HALTED: 28586,
+      INCONSISTENT_FILE: 37896,
+      INCORRECT_DATA: 27264,
+      INCORRECT_LENGTH: 26368,
+      INCORRECT_P1_P2: 27392,
+      INS_NOT_SUPPORTED: 27904,
+      DEVICE_NOT_ONBOARDED: 27911,
+      DEVICE_NOT_ONBOARDED_2: 26129,
+      INVALID_KCV: 38021,
+      INVALID_OFFSET: 37890,
+      LICENSING: 28482,
+      LOCKED_DEVICE: 21781,
+      MAX_VALUE_REACHED: 38992,
+      MEMORY_PROBLEM: 37440,
+      MISSING_CRITICAL_PARAMETER: 26624,
+      NO_EF_SELECTED: 37888,
+      NOT_ENOUGH_MEMORY_SPACE: 27268,
+      OK: 36864,
+      PIN_REMAINING_ATTEMPTS: 25536,
+      REFERENCED_DATA_NOT_FOUND: 27272,
+      SECURITY_STATUS_NOT_SATISFIED: 27010,
+      TECHNICAL_PROBLEM: 28416,
+      UNKNOWN_APDU: 27906,
+      USER_REFUSED_ON_DEVICE: 21761,
+      NOT_ENOUGH_SPACE: 20738,
+      APP_NOT_FOUND_OR_INVALID_CONTEXT: 20771,
+      INVALID_APP_NAME_LENGTH: 26378,
+      GEN_AES_KEY_FAILED: 21529,
+      INTERNAL_CRYPTO_OPERATION_FAILED: 21530,
+      INTERNAL_COMPUTE_AES_CMAC_FAILED: 21531,
+      ENCRYPT_APP_STORAGE_FAILED: 21532,
+      INVALID_BACKUP_STATE: 26178,
+      PIN_NOT_SET: 21762,
+      INVALID_BACKUP_LENGTH: 26419,
+      INVALID_RESTORE_STATE: 26179,
+      INVALID_CHUNK_LENGTH: 26420,
+      INVALID_BACKUP_HEADER: 26698,
+      // Not documented:
+      TRUSTCHAIN_WRONG_SEED: 45063
+    };
+    TransportStatusError = class _TransportStatusError extends Error {
+      statusCode;
+      statusText;
+      /**
+       * @param statusCode The error status code coming from a Transport implementation
+       * @param options containing:
+       *  - canBeMappedToChildError: enable the mapping of TransportStatusError to an error extending/inheriting from it
+       *  . Ex: LockedDeviceError. Default to true.
+       */
+      constructor(statusCode, { canBeMappedToChildError = true } = {}) {
+        const statusText = Object.keys(StatusCodes).find((k) => StatusCodes[k] === statusCode) || "UNKNOWN_ERROR";
+        const smsg = getAltStatusMessage(statusCode) || statusText;
+        const statusCodeStr = statusCode.toString(16);
+        const message = `Ledger device: ${smsg} (0x${statusCodeStr})`;
+        super(message);
+        this.name = "TransportStatusError";
+        this.statusCode = statusCode;
+        this.statusText = statusText;
+        Object.setPrototypeOf(this, _TransportStatusError.prototype);
+        if (canBeMappedToChildError && statusCode === StatusCodes.LOCKED_DEVICE) {
+          return new LockedDeviceError(message);
+        }
+      }
+    };
+    LockedDeviceError = class _LockedDeviceError extends TransportStatusError {
+      constructor(message) {
+        super(StatusCodes.LOCKED_DEVICE, { canBeMappedToChildError: false });
+        if (message) {
+          this.message = message;
+        }
+        this.name = "LockedDeviceError";
+        Object.setPrototypeOf(this, _LockedDeviceError.prototype);
+      }
+    };
+    addCustomErrorDeserializer("TransportStatusError", (e) => new TransportStatusError(e.statusCode));
+  }
+});
+
+// ../../node_modules/.pnpm/@ledgerhq+logs@6.13.0/node_modules/@ledgerhq/logs/lib-es/index.js
+function dispatch(log2) {
+  for (let i = 0; i < subscribers.length; i++) {
+    try {
+      subscribers[i](log2);
+    } catch (e) {
+      console.error(e);
+    }
+  }
+}
+var id, subscribers, log, trace, LocalTracer, listen;
+var init_lib_es2 = __esm({
+  "../../node_modules/.pnpm/@ledgerhq+logs@6.13.0/node_modules/@ledgerhq/logs/lib-es/index.js"() {
+    "use strict";
+    id = 0;
+    subscribers = [];
+    log = (type, message, data) => {
+      const obj = {
+        type,
+        id: String(++id),
+        date: /* @__PURE__ */ new Date()
+      };
+      if (message)
+        obj.message = message;
+      if (data)
+        obj.data = data;
+      dispatch(obj);
+    };
+    trace = ({ type, message, data, context }) => {
+      const obj = {
+        type,
+        id: String(++id),
+        date: /* @__PURE__ */ new Date()
+      };
+      if (message)
+        obj.message = message;
+      if (data)
+        obj.data = data;
+      if (context)
+        obj.context = context;
+      dispatch(obj);
+    };
+    LocalTracer = class _LocalTracer {
+      type;
+      context;
+      constructor(type, context) {
+        this.type = type;
+        this.context = context;
+      }
+      trace(message, data) {
+        trace({
+          type: this.type,
+          message,
+          data,
+          context: this.context
+        });
+      }
+      getContext() {
+        return this.context;
+      }
+      setContext(context) {
+        this.context = context;
+      }
+      updateContext(contextToAdd) {
+        this.context = { ...this.context, ...contextToAdd };
+      }
+      getType() {
+        return this.type;
+      }
+      setType(type) {
+        this.type = type;
+      }
+      /**
+       * Create a new instance of the LocalTracer with an updated `type`
+       *
+       * It does not mutate the calling instance, but returns a new LocalTracer,
+       * following a simple builder pattern.
+       */
+      withType(type) {
+        return new _LocalTracer(type, this.context);
+      }
+      /**
+       * Create a new instance of the LocalTracer with a new `context`
+       *
+       * It does not mutate the calling instance, but returns a new LocalTracer,
+       * following a simple builder pattern.
+       *
+       * @param context A TraceContext, that can undefined to reset the context
+       */
+      withContext(context) {
+        return new _LocalTracer(this.type, context);
+      }
+      /**
+       * Create a new instance of the LocalTracer with an updated `context`,
+       * on which an additional context is merged with the existing one.
+       *
+       * It does not mutate the calling instance, but returns a new LocalTracer,
+       * following a simple builder pattern.
+       */
+      withUpdatedContext(contextToAdd) {
+        return new _LocalTracer(this.type, { ...this.context, ...contextToAdd });
+      }
+    };
+    listen = (cb) => {
+      subscribers.push(cb);
+      return () => {
+        const i = subscribers.indexOf(cb);
+        if (i !== -1) {
+          subscribers[i] = subscribers[subscribers.length - 1];
+          subscribers.pop();
+        }
+      };
+    };
+    if (typeof window !== "undefined") {
+      window.__ledgerLogsListen = listen;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@ledgerhq+hw-transport@6.31.13/node_modules/@ledgerhq/hw-transport/lib-es/Transport.js
+var import_events, DEFAULT_LOG_TYPE, Transport;
+var init_Transport = __esm({
+  "../../node_modules/.pnpm/@ledgerhq+hw-transport@6.31.13/node_modules/@ledgerhq/hw-transport/lib-es/Transport.js"() {
+    "use strict";
+    import_events = __toESM(require("events"));
+    init_lib_es();
+    init_lib_es2();
+    DEFAULT_LOG_TYPE = "transport";
+    Transport = class {
+      exchangeTimeout = 3e4;
+      unresponsiveTimeout = 15e3;
+      deviceModel = null;
+      tracer;
+      constructor({ context, logType } = {}) {
+        this.tracer = new LocalTracer(logType ?? DEFAULT_LOG_TYPE, context);
+      }
+      /**
+       * Check if the transport is supported on the current platform/browser.
+       * @returns {Promise<boolean>} A promise that resolves with a boolean indicating support.
+       */
+      static isSupported;
+      /**
+       * List all available descriptors for the transport.
+       * For a better granularity, checkout `listen()`.
+       *
+       * @returns {Promise<Array<any>>} A promise that resolves with an array of descriptors.
+       * @example
+       * TransportFoo.list().then(descriptors => ...)
+       */
+      static list;
+      /**
+       * Listen for device events for the transport. The method takes an observer of DescriptorEvent and returns a Subscription.
+       * A DescriptorEvent is an object containing a "descriptor" and a "type" field. The "type" field can be "add" or "remove", and the "descriptor" field can be passed to the "open" method.
+       * The "listen" method will first emit all currently connected devices and then will emit events as they occur, such as when a USB device is plugged in or a Bluetooth device becomes discoverable.
+       * @param {Observer<DescriptorEvent<any>>} observer - An object with "next", "error", and "complete" functions, following the observer pattern.
+       * @returns {Subscription} A Subscription object on which you can call ".unsubscribe()" to stop listening to descriptors.
+       * @example
+      const sub = TransportFoo.listen({
+      next: e => {
+        if (e.type==="add") {
+          sub.unsubscribe();
+          const transport = await TransportFoo.open(e.descriptor);
+          ...
+        }
+      },
+      error: error => {},
+      complete: () => {}
+      })
+       */
+      static listen;
+      /**
+       * Attempt to create a Transport instance with a specific descriptor.
+       * @param {any} descriptor - The descriptor to open the transport with.
+       * @param {number} timeout - An optional timeout for the transport connection.
+       * @param {TraceContext} context Optional tracing/log context
+       * @returns {Promise<Transport>} A promise that resolves with a Transport instance.
+       * @example
+      TransportFoo.open(descriptor).then(transport => ...)
+       */
+      static open;
+      /**
+       * Send data to the device using a low level API.
+       * It's recommended to use the "send" method for a higher level API.
+       * @param {Buffer} apdu - The data to send.
+       * @param {Object} options - Contains optional options for the exchange function
+       *  - abortTimeoutMs: stop the exchange after a given timeout. Another timeout exists
+       *    to detect unresponsive device (see `unresponsiveTimeout`). This timeout aborts the exchange.
+       * @returns {Promise<Buffer>} A promise that resolves with the response data from the device.
+       */
+      exchange(_apdu, { abortTimeoutMs: _abortTimeoutMs } = {}) {
+        throw new Error("exchange not implemented");
+      }
+      /**
+       * Send apdus in batch to the device using a low level API.
+       * The default implementation is to call exchange for each apdu.
+       * @param {Array<Buffer>} apdus - array of apdus to send.
+       * @param {Observer<Buffer>} observer - an observer that will receive the response of each apdu.
+       * @returns {Subscription} A Subscription object on which you can call ".unsubscribe()" to stop sending apdus.
+       */
+      exchangeBulk(apdus, observer) {
+        let unsubscribed = false;
+        const unsubscribe = () => {
+          unsubscribed = true;
+        };
+        const main = async () => {
+          if (unsubscribed)
+            return;
+          for (const apdu of apdus) {
+            const r = await this.exchange(apdu);
+            if (unsubscribed)
+              return;
+            const status = r.readUInt16BE(r.length - 2);
+            if (status !== StatusCodes.OK) {
+              throw new TransportStatusError(status);
+            }
+            observer.next(r);
+          }
+        };
+        main().then(() => !unsubscribed && observer.complete(), (e) => !unsubscribed && observer.error(e));
+        return { unsubscribe };
+      }
+      /**
+       * Set the "scramble key" for the next data exchanges with the device.
+       * Each app can have a different scramble key and it is set internally during instantiation.
+       * @param {string} key - The scramble key to set.
+       * deprecated This method is no longer needed for modern transports and should be migrated away from.
+       * no @ before deprecated as it breaks documentationjs on version 14.0.2
+       * https://github.com/documentationjs/documentation/issues/1596
+       */
+      setScrambleKey(_key) {
+      }
+      /**
+       * Close the connection with the device.
+       *
+       * Note: for certain transports (hw-transport-node-hid-singleton for ex), once the promise resolved,
+       * the transport instance is actually still cached, and the device is disconnected only after a defined timeout.
+       * But for the consumer of the Transport, this does not matter and it can consider the transport to be closed.
+       *
+       * @returns {Promise<void>} A promise that resolves when the transport is closed.
+       */
+      close() {
+        return Promise.resolve();
+      }
+      _events = new import_events.default();
+      /**
+       * Listen for an event on the transport instance.
+       * Transport implementations may have specific events. Common events include:
+       * "disconnect" : triggered when the transport is disconnected.
+       * @param {string} eventName - The name of the event to listen for.
+       * @param {(...args: Array<any>) => any} cb - The callback function to be invoked when the event occurs.
+       */
+      on(eventName, cb) {
+        this._events.on(eventName, cb);
+      }
+      /**
+       * Stop listening to an event on an instance of transport.
+       */
+      off(eventName, cb) {
+        this._events.removeListener(eventName, cb);
+      }
+      emit(event, ...args) {
+        this._events.emit(event, ...args);
+      }
+      /**
+       * Enable or not logs of the binary exchange
+       */
+      setDebugMode() {
+        console.warn("setDebugMode is deprecated. use @ledgerhq/logs instead. No logs are emitted in this anymore.");
+      }
+      /**
+       * Set a timeout (in milliseconds) for the exchange call. Only some transport might implement it. (e.g. U2F)
+       */
+      setExchangeTimeout(exchangeTimeout) {
+        this.exchangeTimeout = exchangeTimeout;
+      }
+      /**
+       * Define the delay before emitting "unresponsive" on an exchange that does not respond
+       */
+      setExchangeUnresponsiveTimeout(unresponsiveTimeout) {
+        this.unresponsiveTimeout = unresponsiveTimeout;
+      }
+      /**
+       * Send data to the device using the higher level API.
+       *
+       * @param {number} cla - The instruction class for the command.
+       * @param {number} ins - The instruction code for the command.
+       * @param {number} p1 - The first parameter for the instruction.
+       * @param {number} p2 - The second parameter for the instruction.
+       * @param {Buffer} data - The data to be sent. Defaults to an empty buffer.
+       * @param {Array<number>} statusList - A list of acceptable status codes for the response. Defaults to [StatusCodes.OK].
+       * @param {Object} options - Contains optional options for the exchange function
+       *  - abortTimeoutMs: stop the send after a given timeout. Another timeout exists
+       *    to detect unresponsive device (see `unresponsiveTimeout`). This timeout aborts the exchange.
+       * @returns {Promise<Buffer>} A promise that resolves with the response data from the device.
+       */
+      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(
+          // The size of the data is added in 1 byte just before `data`
+          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;
+      };
+      /**
+       * create() allows to open the first descriptor available or
+       * throw if there is none or if timeout is reached.
+       * This is a light helper, alternative to using listen() and open() (that you may need for any more advanced usecase)
+       * @example
+      TransportFoo.create().then(transport => ...)
+       */
+      static create(openTimeout = 3e3, listenTimeout) {
+        return new Promise((resolve, reject) => {
+          let found = false;
+          const sub = this.listen({
+            next: (e) => {
+              found = true;
+              if (sub)
+                sub.unsubscribe();
+              if (listenTimeoutId)
+                clearTimeout(listenTimeoutId);
+              this.open(e.descriptor, openTimeout).then(resolve, reject);
+            },
+            error: (e) => {
+              if (listenTimeoutId)
+                clearTimeout(listenTimeoutId);
+              reject(e);
+            },
+            complete: () => {
+              if (listenTimeoutId)
+                clearTimeout(listenTimeoutId);
+              if (!found) {
+                reject(new TransportError(this.ErrorMessage_NoDeviceFound, "NoDeviceFound"));
+              }
+            }
+          });
+          const listenTimeoutId = listenTimeout ? setTimeout(() => {
+            sub.unsubscribe();
+            reject(new TransportError(this.ErrorMessage_ListenTimeout, "ListenTimeout"));
+          }, listenTimeout) : null;
+        });
+      }
+      // Blocks other exchange to happen concurrently
+      exchangeBusyPromise;
+      /**
+       * Wrapper to make an exchange "atomic" (blocking any other exchange)
+       *
+       * It also handles "unresponsiveness" by emitting "unresponsive" and "responsive" events.
+       *
+       * @param f The exchange job, using the transport to run
+       * @returns a Promise resolving with the output of the given job
+       */
+      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
+          });
+          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 async (...args) => {
+          const { _appAPIlock } = this;
+          if (_appAPIlock) {
+            return Promise.reject(new TransportError("Ledger Device is busy (lock " + _appAPIlock + ")", "TransportLocked"));
+          }
+          try {
+            this._appAPIlock = methodName;
+            this.setScrambleKey(scrambleKey);
+            return await f.apply(ctx, args);
+          } finally {
+            this._appAPIlock = null;
+          }
+        };
+      }
+      /**
+       * Sets the context used by the logging/tracing mechanism
+       *
+       * Useful when re-using (cached) the same Transport instance,
+       * but with a new tracing context.
+       *
+       * @param context A TraceContext, that can undefined to reset the context
+       */
+      setTraceContext(context) {
+        this.tracer = this.tracer.withContext(context);
+      }
+      /**
+       * Updates the context used by the logging/tracing mechanism
+       *
+       * The update only overrides the key-value that are already defined in the current context.
+       *
+       * @param contextToAdd A TraceContext that will be added to the current context
+       */
+      updateTraceContext(contextToAdd) {
+        this.tracer.updateContext(contextToAdd);
+      }
+      /**
+       * Gets the tracing context of the transport instance
+       */
+      getTraceContext() {
+        return this.tracer.getContext();
+      }
+      static ErrorMessage_ListenTimeout = "No Ledger device found (timeout)";
+      static ErrorMessage_NoDeviceFound = "No Ledger device found";
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@ledgerhq+devices@8.7.0/node_modules/@ledgerhq/devices/lib-es/hid-framing.js
+function asUInt16BE(value) {
+  const b = Buffer.alloc(2);
+  b.writeUInt16BE(value, 0);
+  return b;
+}
+var Tag, initialAcc, createHIDframing, hid_framing_default;
+var init_hid_framing = __esm({
+  "../../node_modules/.pnpm/@ledgerhq+devices@8.7.0/node_modules/@ledgerhq/devices/lib-es/hid-framing.js"() {
+    "use strict";
+    init_lib_es();
+    Tag = 5;
+    initialAcc = {
+      data: Buffer.alloc(0),
+      dataLength: 0,
+      sequence: 0
+    };
+    createHIDframing = (channel, packetSize) => {
+      return {
+        /**
+         * Frames/encodes an APDU message into HID USB packets/frames
+         *
+         * @param apdu The APDU message to send, in a Buffer containing [cla, ins, p1, p2, data length, data(if not empty)]
+         * @returns an array of HID USB frames ready to be sent
+         */
+        makeBlocks(apdu) {
+          let data = Buffer.concat([asUInt16BE(apdu.length), apdu]);
+          const blockSize = packetSize - 5;
+          const nbBlocks = Math.ceil(data.length / blockSize);
+          data = Buffer.concat([data, Buffer.alloc(nbBlocks * blockSize - data.length + 1).fill(0)]);
+          const blocks = [];
+          for (let i = 0; i < nbBlocks; i++) {
+            const head = Buffer.alloc(5);
+            head.writeUInt16BE(channel, 0);
+            head.writeUInt8(Tag, 2);
+            head.writeUInt16BE(i, 3);
+            const chunk = data.slice(i * blockSize, (i + 1) * blockSize);
+            blocks.push(Buffer.concat([head, chunk]));
+          }
+          return blocks;
+        },
+        /**
+         * Reduces HID USB packets/frames to one response.
+         *
+         * @param acc The value resulting from (accumulating) the previous call of reduceResponse.
+         *   On first call initialized to `initialAcc`. The accumulator enables handling multi-frames messages.
+         * @param chunk Current chunk to reduce into accumulator
+         * @returns An accumulator value updated with the current chunk
+         */
+        reduceResponse(acc, chunk) {
+          let { data, dataLength, sequence } = acc || initialAcc;
+          if (chunk.readUInt16BE(0) !== channel) {
+            throw new TransportError("Invalid channel", "InvalidChannel");
+          }
+          if (chunk.readUInt8(2) !== Tag) {
+            throw new TransportError("Invalid tag", "InvalidTag");
+          }
+          if (chunk.readUInt16BE(3) !== sequence) {
+            throw new TransportError("Invalid sequence", "InvalidSequence");
+          }
+          if (!acc) {
+            dataLength = chunk.readUInt16BE(5);
+          }
+          sequence++;
+          const chunkData = chunk.slice(acc ? 5 : 7);
+          data = Buffer.concat([data, chunkData]);
+          if (data.length > dataLength) {
+            data = data.slice(0, dataLength);
+          }
+          return {
+            data,
+            dataLength,
+            sequence
+          };
+        },
+        /**
+         * Returns the response message that has been reduced from the HID USB frames
+         *
+         * @param acc The accumulator
+         * @returns A Buffer containing the cleaned response message, or null if no response message, or undefined if the
+         *   accumulator is incorrect (message length is not valid)
+         */
+        getReducedResult(acc) {
+          if (acc && acc.dataLength === acc.data.length) {
+            return acc.data;
+          }
+        }
+      };
+    };
+    hid_framing_default = createHIDframing;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/constants.js
+var require_constants = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/constants.js"(exports2, module2) {
+    "use strict";
+    var SEMVER_SPEC_VERSION = "2.0.0";
+    var MAX_LENGTH = 256;
+    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
+    9007199254740991;
+    var MAX_SAFE_COMPONENT_LENGTH = 16;
+    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
+    var RELEASE_TYPES = [
+      "major",
+      "premajor",
+      "minor",
+      "preminor",
+      "patch",
+      "prepatch",
+      "prerelease"
+    ];
+    module2.exports = {
+      MAX_LENGTH,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_SAFE_INTEGER,
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 1,
+      FLAG_LOOSE: 2
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/debug.js
+var require_debug = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/debug.js"(exports2, module2) {
+    "use strict";
+    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error("SEMVER", ...args) : () => {
+    };
+    module2.exports = debug;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/re.js
+var require_re = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/re.js"(exports2, module2) {
+    "use strict";
+    var {
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
+      MAX_LENGTH
+    } = require_constants();
+    var debug = require_debug();
+    exports2 = module2.exports = {};
+    var re = exports2.re = [];
+    var safeRe = exports2.safeRe = [];
+    var src = exports2.src = [];
+    var safeSrc = exports2.safeSrc = [];
+    var t = exports2.t = {};
+    var R = 0;
+    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
+    var safeRegexReplacements = [
+      ["\\s", 1],
+      ["\\d", MAX_LENGTH],
+      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
+    ];
+    var makeSafeRegex = (value) => {
+      for (const [token, max] of safeRegexReplacements) {
+        value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+      }
+      return value;
+    };
+    var createToken = (name, value, isGlobal) => {
+      const safe = makeSafeRegex(value);
+      const index = R++;
+      debug(name, index, value);
+      t[name] = index;
+      src[index] = value;
+      safeSrc[index] = safe;
+      re[index] = new RegExp(value, isGlobal ? "g" : void 0);
+      safeRe[index] = new RegExp(safe, isGlobal ? "g" : void 0);
+    };
+    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
+    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
+    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
+    createToken("MAINVERSION", `(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})\\.(${src[t.NUMERICIDENTIFIER]})`);
+    createToken("MAINVERSIONLOOSE", `(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})\\.(${src[t.NUMERICIDENTIFIERLOOSE]})`);
+    createToken("PRERELEASEIDENTIFIER", `(?:${src[t.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]}(?:\\.${src[t.PRERELEASEIDENTIFIERLOOSE]})*))`);
+    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
+    createToken("BUILD", `(?:\\+(${src[t.BUILDIDENTIFIER]}(?:\\.${src[t.BUILDIDENTIFIER]})*))`);
+    createToken("FULLPLAIN", `v?${src[t.MAINVERSION]}${src[t.PRERELEASE]}?${src[t.BUILD]}?`);
+    createToken("FULL", `^${src[t.FULLPLAIN]}$`);
+    createToken("LOOSEPLAIN", `[v=\\s]*${src[t.MAINVERSIONLOOSE]}${src[t.PRERELEASELOOSE]}?${src[t.BUILD]}?`);
+    createToken("LOOSE", `^${src[t.LOOSEPLAIN]}$`);
+    createToken("GTLT", "((?:<|>)?=?)");
+    createToken("XRANGEIDENTIFIERLOOSE", `${src[t.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
+    createToken("XRANGEIDENTIFIER", `${src[t.NUMERICIDENTIFIER]}|x|X|\\*`);
+    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:\\.(${src[t.XRANGEIDENTIFIER]})(?:${src[t.PRERELEASE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t.XRANGEIDENTIFIERLOOSE]})(?:${src[t.PRERELEASELOOSE]})?${src[t.BUILD]}?)?)?`);
+    createToken("XRANGE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAIN]}$`);
+    createToken("XRANGELOOSE", `^${src[t.GTLT]}\\s*${src[t.XRANGEPLAINLOOSE]}$`);
+    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\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);
+    exports2.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);
+    exports2.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);
+    exports2.comparatorTrimReplace = "$1$2$3";
+    createToken("HYPHENRANGE", `^\\s*(${src[t.XRANGEPLAIN]})\\s+-\\s+(${src[t.XRANGEPLAIN]})\\s*$`);
+    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t.XRANGEPLAINLOOSE]})\\s*$`);
+    createToken("STAR", "(<|>)?=?\\s*\\*");
+    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
+    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/parse-options.js
+var require_parse_options = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/parse-options.js"(exports2, module2) {
+    "use strict";
+    var looseOption = Object.freeze({ loose: true });
+    var emptyOpts = Object.freeze({});
+    var parseOptions = (options) => {
+      if (!options) {
+        return emptyOpts;
+      }
+      if (typeof options !== "object") {
+        return looseOption;
+      }
+      return options;
+    };
+    module2.exports = parseOptions;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/identifiers.js
+var require_identifiers = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/identifiers.js"(exports2, module2) {
+    "use strict";
+    var numeric = /^[0-9]+$/;
+    var compareIdentifiers = (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) {
+        a = +a;
+        b = +b;
+      }
+      return a === b ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a < b ? -1 : 1;
+    };
+    var rcompareIdentifiers = (a, b) => compareIdentifiers(b, a);
+    module2.exports = {
+      compareIdentifiers,
+      rcompareIdentifiers
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/semver.js
+var require_semver = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/semver.js"(exports2, module2) {
+    "use strict";
+    var debug = require_debug();
+    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants();
+    var { safeRe: re, t } = require_re();
+    var parseOptions = require_parse_options();
+    var { compareIdentifiers } = require_identifiers();
+    var SemVer = class _SemVer {
+      constructor(version, options) {
+        options = parseOptions(options);
+        if (version instanceof _SemVer) {
+          if (version.loose === !!options.loose && version.includePrerelease === !!options.includePrerelease) {
+            return version;
+          } else {
+            version = version.version;
+          }
+        } else if (typeof version !== "string") {
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
+        }
+        if (version.length > MAX_LENGTH) {
+          throw new TypeError(
+            `version is longer than ${MAX_LENGTH} characters`
+          );
+        }
+        debug("SemVer", version, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        const m = version.trim().match(options.loose ? re[t.LOOSE] : re[t.FULL]);
+        if (!m) {
+          throw new TypeError(`Invalid Version: ${version}`);
+        }
+        this.raw = version;
+        this.major = +m[1];
+        this.minor = +m[2];
+        this.patch = +m[3];
+        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
+          throw new TypeError("Invalid major version");
+        }
+        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
+          throw new TypeError("Invalid minor version");
+        }
+        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
+          throw new TypeError("Invalid patch version");
+        }
+        if (!m[4]) {
+          this.prerelease = [];
+        } else {
+          this.prerelease = m[4].split(".").map((id2) => {
+            if (/^[0-9]+$/.test(id2)) {
+              const num = +id2;
+              if (num >= 0 && num < MAX_SAFE_INTEGER) {
+                return num;
+              }
+            }
+            return id2;
+          });
+        }
+        this.build = m[5] ? m[5].split(".") : [];
+        this.format();
+      }
+      format() {
+        this.version = `${this.major}.${this.minor}.${this.patch}`;
+        if (this.prerelease.length) {
+          this.version += `-${this.prerelease.join(".")}`;
+        }
+        return this.version;
+      }
+      toString() {
+        return this.version;
+      }
+      compare(other) {
+        debug("SemVer.compare", this.version, this.options, other);
+        if (!(other instanceof _SemVer)) {
+          if (typeof other === "string" && other === this.version) {
+            return 0;
+          }
+          other = new _SemVer(other, this.options);
+        }
+        if (other.version === this.version) {
+          return 0;
+        }
+        return this.compareMain(other) || this.comparePre(other);
+      }
+      compareMain(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        if (this.major < other.major) {
+          return -1;
+        }
+        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;
+        }
+        let i = 0;
+        do {
+          const a = this.prerelease[i];
+          const b = other.prerelease[i];
+          debug("prerelease compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      compareBuild(other) {
+        if (!(other instanceof _SemVer)) {
+          other = new _SemVer(other, this.options);
+        }
+        let i = 0;
+        do {
+          const a = this.build[i];
+          const b = other.build[i];
+          debug("build compare", i, a, b);
+          if (a === void 0 && b === void 0) {
+            return 0;
+          } else if (b === void 0) {
+            return 1;
+          } else if (a === void 0) {
+            return -1;
+          } else if (a === b) {
+            continue;
+          } else {
+            return compareIdentifiers(a, b);
+          }
+        } while (++i);
+      }
+      // preminor will bump the version up to the next minor release, and immediately
+      // down to pre-release. premajor and prepatch work the same way.
+      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[t.PRERELEASELOOSE] : re[t.PRERELEASE]);
+            if (!match || match[1] !== identifier) {
+              throw new Error(`invalid identifier: ${identifier}`);
+            }
+          }
+        }
+        switch (release) {
+          case "premajor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor = 0;
+            this.major++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "preminor":
+            this.prerelease.length = 0;
+            this.patch = 0;
+            this.minor++;
+            this.inc("pre", identifier, identifierBase);
+            break;
+          case "prepatch":
+            this.prerelease.length = 0;
+            this.inc("patch", identifier, identifierBase);
+            this.inc("pre", identifier, identifierBase);
+            break;
+          // If the input is a non-prerelease version, this acts the same as
+          // prepatch.
+          case "prerelease":
+            if (this.prerelease.length === 0) {
+              this.inc("patch", identifier, identifierBase);
+            }
+            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 || this.patch !== 0 || this.prerelease.length === 0) {
+              this.major++;
+            }
+            this.minor = 0;
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "minor":
+            if (this.patch !== 0 || this.prerelease.length === 0) {
+              this.minor++;
+            }
+            this.patch = 0;
+            this.prerelease = [];
+            break;
+          case "patch":
+            if (this.prerelease.length === 0) {
+              this.patch++;
+            }
+            this.prerelease = [];
+            break;
+          // This probably shouldn't be used publicly.
+          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
+          case "pre": {
+            const base = Number(identifierBase) ? 1 : 0;
+            if (this.prerelease.length === 0) {
+              this.prerelease = [base];
+            } else {
+              let i = this.prerelease.length;
+              while (--i >= 0) {
+                if (typeof this.prerelease[i] === "number") {
+                  this.prerelease[i]++;
+                  i = -2;
+                }
+              }
+              if (i === -1) {
+                if (identifier === this.prerelease.join(".") && identifierBase === false) {
+                  throw new Error("invalid increment argument: identifier already exists");
+                }
+                this.prerelease.push(base);
+              }
+            }
+            if (identifier) {
+              let prerelease = [identifier, base];
+              if (identifierBase === false) {
+                prerelease = [identifier];
+              }
+              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+                if (isNaN(this.prerelease[1])) {
+                  this.prerelease = prerelease;
+                }
+              } else {
+                this.prerelease = prerelease;
+              }
+            }
+            break;
+          }
+          default:
+            throw new Error(`invalid increment argument: ${release}`);
+        }
+        this.raw = this.format();
+        if (this.build.length) {
+          this.raw += `+${this.build.join(".")}`;
+        }
+        return this;
+      }
+    };
+    module2.exports = SemVer;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/parse.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = (version, options, throwErrors = false) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      try {
+        return new SemVer(version, options);
+      } catch (er) {
+        if (!throwErrors) {
+          return null;
+        }
+        throw er;
+      }
+    };
+    module2.exports = parse;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/valid.js
+var require_valid = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/valid.js"(exports2, module2) {
+    "use strict";
+    var parse = require_parse();
+    var valid = (version, options) => {
+      const v = parse(version, options);
+      return v ? v.version : null;
+    };
+    module2.exports = valid;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/clean.js
+var require_clean = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/clean.js"(exports2, module2) {
+    "use strict";
+    var parse = require_parse();
+    var clean = (version, options) => {
+      const s = parse(version.trim().replace(/^[=v]+/, ""), options);
+      return s ? s.version : null;
+    };
+    module2.exports = clean;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/inc.js
+var require_inc = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/inc.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var inc = (version, release, options, identifier, identifierBase) => {
+      if (typeof options === "string") {
+        identifierBase = identifier;
+        identifier = options;
+        options = void 0;
+      }
+      try {
+        return new SemVer(
+          version instanceof SemVer ? version.version : version,
+          options
+        ).inc(release, identifier, identifierBase).version;
+      } catch (er) {
+        return null;
+      }
+    };
+    module2.exports = inc;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/diff.js
+var require_diff = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/diff.js"(exports2, module2) {
+    "use strict";
+    var parse = require_parse();
+    var diff = (version1, version2) => {
+      const v1 = parse(version1, null, true);
+      const v2 = parse(version2, null, true);
+      const comparison = v1.compare(v2);
+      if (comparison === 0) {
+        return null;
+      }
+      const v1Higher = comparison > 0;
+      const highVersion = v1Higher ? v1 : v2;
+      const lowVersion = v1Higher ? v2 : v1;
+      const highHasPre = !!highVersion.prerelease.length;
+      const lowHasPre = !!lowVersion.prerelease.length;
+      if (lowHasPre && !highHasPre) {
+        if (!lowVersion.patch && !lowVersion.minor) {
+          return "major";
+        }
+        if (lowVersion.compareMain(highVersion) === 0) {
+          if (lowVersion.minor && !lowVersion.patch) {
+            return "minor";
+          }
+          return "patch";
+        }
+      }
+      const prefix = highHasPre ? "pre" : "";
+      if (v1.major !== v2.major) {
+        return prefix + "major";
+      }
+      if (v1.minor !== v2.minor) {
+        return prefix + "minor";
+      }
+      if (v1.patch !== v2.patch) {
+        return prefix + "patch";
+      }
+      return "prerelease";
+    };
+    module2.exports = diff;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/major.js
+var require_major = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/major.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var major = (a, loose) => new SemVer(a, loose).major;
+    module2.exports = major;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/minor.js
+var require_minor = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/minor.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var minor = (a, loose) => new SemVer(a, loose).minor;
+    module2.exports = minor;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/patch.js
+var require_patch = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/patch.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var patch = (a, loose) => new SemVer(a, loose).patch;
+    module2.exports = patch;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/prerelease.js
+var require_prerelease = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/prerelease.js"(exports2, module2) {
+    "use strict";
+    var parse = require_parse();
+    var prerelease = (version, options) => {
+      const parsed = parse(version, options);
+      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
+    };
+    module2.exports = prerelease;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare.js
+var require_compare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var compare = (a, b, loose) => new SemVer(a, loose).compare(new SemVer(b, loose));
+    module2.exports = compare;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/rcompare.js
+var require_rcompare = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/rcompare.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var rcompare = (a, b, loose) => compare(b, a, loose);
+    module2.exports = rcompare;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare-loose.js
+var require_compare_loose = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare-loose.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var compareLoose = (a, b) => compare(a, b, true);
+    module2.exports = compareLoose;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare-build.js
+var require_compare_build = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/compare-build.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var compareBuild = (a, b, loose) => {
+      const versionA = new SemVer(a, loose);
+      const versionB = new SemVer(b, loose);
+      return versionA.compare(versionB) || versionA.compareBuild(versionB);
+    };
+    module2.exports = compareBuild;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/sort.js
+var require_sort = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/sort.js"(exports2, module2) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var sort = (list, loose) => list.sort((a, b) => compareBuild(a, b, loose));
+    module2.exports = sort;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/rsort.js
+var require_rsort = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/rsort.js"(exports2, module2) {
+    "use strict";
+    var compareBuild = require_compare_build();
+    var rsort = (list, loose) => list.sort((a, b) => compareBuild(b, a, loose));
+    module2.exports = rsort;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/gt.js
+var require_gt = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/gt.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var gt = (a, b, loose) => compare(a, b, loose) > 0;
+    module2.exports = gt;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/lt.js
+var require_lt = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/lt.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var lt = (a, b, loose) => compare(a, b, loose) < 0;
+    module2.exports = lt;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/eq.js
+var require_eq = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/eq.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var eq = (a, b, loose) => compare(a, b, loose) === 0;
+    module2.exports = eq;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/neq.js
+var require_neq = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/neq.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var neq = (a, b, loose) => compare(a, b, loose) !== 0;
+    module2.exports = neq;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/gte.js
+var require_gte = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/gte.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
+    module2.exports = gte;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/lte.js
+var require_lte = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/lte.js"(exports2, module2) {
+    "use strict";
+    var compare = require_compare();
+    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
+    module2.exports = lte;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/cmp.js
+var require_cmp = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/cmp.js"(exports2, module2) {
+    "use strict";
+    var eq = require_eq();
+    var neq = require_neq();
+    var gt = require_gt();
+    var gte = require_gte();
+    var lt = require_lt();
+    var lte = require_lte();
+    var cmp = (a, op, b, loose) => {
+      switch (op) {
+        case "===":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a === b;
+        case "!==":
+          if (typeof a === "object") {
+            a = a.version;
+          }
+          if (typeof b === "object") {
+            b = b.version;
+          }
+          return a !== b;
+        case "":
+        case "=":
+        case "==":
+          return eq(a, b, loose);
+        case "!=":
+          return neq(a, b, loose);
+        case ">":
+          return gt(a, b, loose);
+        case ">=":
+          return gte(a, b, loose);
+        case "<":
+          return lt(a, b, loose);
+        case "<=":
+          return lte(a, b, loose);
+        default:
+          throw new TypeError(`Invalid operator: ${op}`);
+      }
+    };
+    module2.exports = cmp;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/coerce.js
+var require_coerce = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/coerce.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var parse = require_parse();
+    var { safeRe: re, t } = require_re();
+    var coerce = (version, options) => {
+      if (version instanceof SemVer) {
+        return version;
+      }
+      if (typeof version === "number") {
+        version = String(version);
+      }
+      if (typeof version !== "string") {
+        return null;
+      }
+      options = options || {};
+      let match = null;
+      if (!options.rtl) {
+        match = version.match(options.includePrerelease ? re[t.COERCEFULL] : re[t.COERCE]);
+      } else {
+        const coerceRtlRegex = options.includePrerelease ? re[t.COERCERTLFULL] : re[t.COERCERTL];
+        let next;
+        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;
+          }
+          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
+        }
+        coerceRtlRegex.lastIndex = -1;
+      }
+      if (match === null) {
+        return null;
+      }
+      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(`${major}.${minor}.${patch}${prerelease}${build}`, options);
+    };
+    module2.exports = coerce;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/lrucache.js
+var require_lrucache = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/internal/lrucache.js"(exports2, module2) {
+    "use strict";
+    var LRUCache = class {
+      constructor() {
+        this.max = 1e3;
+        this.map = /* @__PURE__ */ new Map();
+      }
+      get(key) {
+        const value = this.map.get(key);
+        if (value === void 0) {
+          return void 0;
+        } else {
+          this.map.delete(key);
+          this.map.set(key, value);
+          return value;
+        }
+      }
+      delete(key) {
+        return this.map.delete(key);
+      }
+      set(key, value) {
+        const deleted = this.delete(key);
+        if (!deleted && value !== void 0) {
+          if (this.map.size >= this.max) {
+            const firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
+          }
+          this.map.set(key, value);
+        }
+        return this;
+      }
+    };
+    module2.exports = LRUCache;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/range.js
+var require_range = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/range.js"(exports2, module2) {
+    "use strict";
+    var SPACE_CHARACTERS = /\s+/g;
+    var Range = class _Range {
+      constructor(range, options) {
+        options = parseOptions(options);
+        if (range instanceof _Range) {
+          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
+            return range;
+          } else {
+            return new _Range(range.raw, options);
+          }
+        }
+        if (range instanceof Comparator) {
+          this.raw = range.value;
+          this.set = [[range]];
+          this.formatted = void 0;
+          return this;
+        }
+        this.options = options;
+        this.loose = !!options.loose;
+        this.includePrerelease = !!options.includePrerelease;
+        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
+        if (!this.set.length) {
+          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
+        }
+        if (this.set.length > 1) {
+          const first = this.set[0];
+          this.set = this.set.filter((c) => !isNullSet(c[0]));
+          if (this.set.length === 0) {
+            this.set = [first];
+          } else if (this.set.length > 1) {
+            for (const c of this.set) {
+              if (c.length === 1 && isAny(c[0])) {
+                this.set = [c];
+                break;
+              }
+            }
+          }
+        }
+        this.formatted = void 0;
+      }
+      get range() {
+        if (this.formatted === void 0) {
+          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() {
+        return this.range;
+      }
+      toString() {
+        return this.range;
+      }
+      parseRange(range) {
+        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+        const memoKey = memoOpts + ":" + range;
+        const cached = cache.get(memoKey);
+        if (cached) {
+          return cached;
+        }
+        const loose = this.options.loose;
+        const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
+        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range);
+        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range);
+        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range);
+        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug("caret trim", range);
+        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        if (loose) {
+          rangeList = rangeList.filter((comp) => {
+            debug("loose invalid filter", comp, this.options);
+            return !!comp.match(re[t.COMPARATORLOOSE]);
+          });
+        }
+        debug("range list", rangeList);
+        const rangeMap = /* @__PURE__ */ new Map();
+        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
+        for (const comp of comparators) {
+          if (isNullSet(comp)) {
+            return [comp];
+          }
+          rangeMap.set(comp.value, comp);
+        }
+        if (rangeMap.size > 1 && rangeMap.has("")) {
+          rangeMap.delete("");
+        }
+        const result = [...rangeMap.values()];
+        cache.set(memoKey, result);
+        return result;
+      }
+      intersects(range, options) {
+        if (!(range instanceof _Range)) {
+          throw new TypeError("a Range is required");
+        }
+        return this.set.some((thisComparators) => {
+          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
+              return rangeComparators.every((rangeComparator) => {
+                return thisComparator.intersects(rangeComparator, options);
+              });
+            });
+          });
+        });
+      }
+      // if ANY of the sets match ALL of its comparators, then pass
+      test(version) {
+        if (!version) {
+          return false;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        for (let i = 0; i < this.set.length; i++) {
+          if (testSet(this.set[i], version, this.options)) {
+            return true;
+          }
+        }
+        return false;
+      }
+    };
+    module2.exports = Range;
+    var LRU = require_lrucache();
+    var cache = new LRU();
+    var parseOptions = require_parse_options();
+    var Comparator = require_comparator();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var {
+      safeRe: re,
+      t,
+      comparatorTrimReplace,
+      tildeTrimReplace,
+      caretTrimReplace
+    } = require_re();
+    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants();
+    var isNullSet = (c) => c.value === "<0.0.0-0";
+    var isAny = (c) => c.value === "";
+    var isSatisfiable = (comparators, options) => {
+      let result = true;
+      const remainingComparators = comparators.slice();
+      let testComparator = remainingComparators.pop();
+      while (result && remainingComparators.length) {
+        result = remainingComparators.every((otherComparator) => {
+          return testComparator.intersects(otherComparator, options);
+        });
+        testComparator = remainingComparators.pop();
+      }
+      return result;
+    };
+    var parseComparator = (comp, options) => {
+      comp = comp.replace(re[t.BUILD], "");
+      debug("comp", comp, options);
+      comp = replaceCarets(comp, options);
+      debug("caret", comp);
+      comp = replaceTildes(comp, options);
+      debug("tildes", comp);
+      comp = replaceXRanges(comp, options);
+      debug("xrange", comp);
+      comp = replaceStars(comp, options);
+      debug("stars", comp);
+      return comp;
+    };
+    var isX = (id2) => !id2 || id2.toLowerCase() === "x" || id2 === "*";
+    var replaceTildes = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceTilde(c, options)).join(" ");
+    };
+    var replaceTilde = (comp, options) => {
+      const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("tilde", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0 <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          ret = `>=${M}.${m}.0 <${M}.${+m + 1}.0-0`;
+        } else if (pr) {
+          debug("replaceTilde pr", pr);
+          ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+        } else {
+          ret = `>=${M}.${m}.${p} <${M}.${+m + 1}.0-0`;
+        }
+        debug("tilde return", ret);
+        return ret;
+      });
+    };
+    var replaceCarets = (comp, options) => {
+      return comp.trim().split(/\s+/).map((c) => replaceCaret(c, options)).join(" ");
+    };
+    var replaceCaret = (comp, options) => {
+      debug("caret", comp, options);
+      const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
+      const z = options.includePrerelease ? "-0" : "";
+      return comp.replace(r, (_, M, m, p, pr) => {
+        debug("caret", comp, _, M, m, p, pr);
+        let ret;
+        if (isX(M)) {
+          ret = "";
+        } else if (isX(m)) {
+          ret = `>=${M}.0.0${z} <${+M + 1}.0.0-0`;
+        } else if (isX(p)) {
+          if (M === "0") {
+            ret = `>=${M}.${m}.0${z} <${M}.${+m + 1}.0-0`;
+          } else {
+            ret = `>=${M}.${m}.0${z} <${+M + 1}.0.0-0`;
+          }
+        } else if (pr) {
+          debug("replaceCaret pr", pr);
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}-${pr} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p}-${pr} <${+M + 1}.0.0-0`;
+          }
+        } else {
+          debug("no pr");
+          if (M === "0") {
+            if (m === "0") {
+              ret = `>=${M}.${m}.${p}${z} <${M}.${m}.${+p + 1}-0`;
+            } else {
+              ret = `>=${M}.${m}.${p}${z} <${M}.${+m + 1}.0-0`;
+            }
+          } else {
+            ret = `>=${M}.${m}.${p} <${+M + 1}.0.0-0`;
+          }
+        }
+        debug("caret return", ret);
+        return ret;
+      });
+    };
+    var replaceXRanges = (comp, options) => {
+      debug("replaceXRanges", comp, options);
+      return comp.split(/\s+/).map((c) => replaceXRange(c, options)).join(" ");
+    };
+    var replaceXRange = (comp, options) => {
+      comp = comp.trim();
+      const r = options.loose ? re[t.XRANGELOOSE] : re[t.XRANGE];
+      return comp.replace(r, (ret, gtlt, M, m, p, pr) => {
+        debug("xRange", comp, ret, gtlt, M, m, p, pr);
+        const xM = isX(M);
+        const xm = xM || isX(m);
+        const xp = xm || isX(p);
+        const anyX = xp;
+        if (gtlt === "=" && anyX) {
+          gtlt = "";
+        }
+        pr = options.includePrerelease ? "-0" : "";
+        if (xM) {
+          if (gtlt === ">" || gtlt === "<") {
+            ret = "<0.0.0-0";
+          } else {
+            ret = "*";
+          }
+        } else if (gtlt && anyX) {
+          if (xm) {
+            m = 0;
+          }
+          p = 0;
+          if (gtlt === ">") {
+            gtlt = ">=";
+            if (xm) {
+              M = +M + 1;
+              m = 0;
+              p = 0;
+            } else {
+              m = +m + 1;
+              p = 0;
+            }
+          } else if (gtlt === "<=") {
+            gtlt = "<";
+            if (xm) {
+              M = +M + 1;
+            } else {
+              m = +m + 1;
+            }
+          }
+          if (gtlt === "<") {
+            pr = "-0";
+          }
+          ret = `${gtlt + M}.${m}.${p}${pr}`;
+        } else if (xm) {
+          ret = `>=${M}.0.0${pr} <${+M + 1}.0.0-0`;
+        } else if (xp) {
+          ret = `>=${M}.${m}.0${pr} <${M}.${+m + 1}.0-0`;
+        }
+        debug("xRange return", ret);
+        return ret;
+      });
+    };
+    var replaceStars = (comp, options) => {
+      debug("replaceStars", comp, options);
+      return comp.trim().replace(re[t.STAR], "");
+    };
+    var replaceGTE0 = (comp, options) => {
+      debug("replaceGTE0", comp, options);
+      return comp.trim().replace(re[options.includePrerelease ? t.GTE0PRE : t.GTE0], "");
+    };
+    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
+      if (isX(fM)) {
+        from = "";
+      } else if (isX(fm)) {
+        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
+      } else if (isX(fp)) {
+        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
+      } else if (fpr) {
+        from = `>=${from}`;
+      } else {
+        from = `>=${from}${incPr ? "-0" : ""}`;
+      }
+      if (isX(tM)) {
+        to = "";
+      } else if (isX(tm)) {
+        to = `<${+tM + 1}.0.0-0`;
+      } else if (isX(tp)) {
+        to = `<${tM}.${+tm + 1}.0-0`;
+      } else if (tpr) {
+        to = `<=${tM}.${tm}.${tp}-${tpr}`;
+      } else if (incPr) {
+        to = `<${tM}.${tm}.${+tp + 1}-0`;
+      } else {
+        to = `<=${to}`;
+      }
+      return `${from} ${to}`.trim();
+    };
+    var testSet = (set, version, options) => {
+      for (let i = 0; i < set.length; i++) {
+        if (!set[i].test(version)) {
+          return false;
+        }
+      }
+      if (version.prerelease.length && !options.includePrerelease) {
+        for (let i = 0; i < set.length; i++) {
+          debug(set[i].semver);
+          if (set[i].semver === Comparator.ANY) {
+            continue;
+          }
+          if (set[i].semver.prerelease.length > 0) {
+            const allowed = set[i].semver;
+            if (allowed.major === version.major && allowed.minor === version.minor && allowed.patch === version.patch) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      return true;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/comparator.js
+var require_comparator = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/classes/comparator.js"(exports2, module2) {
+    "use strict";
+    var ANY = Symbol("SemVer ANY");
+    var Comparator = class _Comparator {
+      static get ANY() {
+        return ANY;
+      }
+      constructor(comp, options) {
+        options = parseOptions(options);
+        if (comp instanceof _Comparator) {
+          if (comp.loose === !!options.loose) {
+            return comp;
+          } else {
+            comp = comp.value;
+          }
+        }
+        comp = comp.trim().split(/\s+/).join(" ");
+        debug("comparator", comp, options);
+        this.options = options;
+        this.loose = !!options.loose;
+        this.parse(comp);
+        if (this.semver === ANY) {
+          this.value = "";
+        } else {
+          this.value = this.operator + this.semver.version;
+        }
+        debug("comp", this);
+      }
+      parse(comp) {
+        const r = this.options.loose ? re[t.COMPARATORLOOSE] : re[t.COMPARATOR];
+        const m = comp.match(r);
+        if (!m) {
+          throw new TypeError(`Invalid comparator: ${comp}`);
+        }
+        this.operator = m[1] !== void 0 ? m[1] : "";
+        if (this.operator === "=") {
+          this.operator = "";
+        }
+        if (!m[2]) {
+          this.semver = ANY;
+        } else {
+          this.semver = new SemVer(m[2], this.options.loose);
+        }
+      }
+      toString() {
+        return this.value;
+      }
+      test(version) {
+        debug("Comparator.test", version, this.options.loose);
+        if (this.semver === ANY || version === ANY) {
+          return true;
+        }
+        if (typeof version === "string") {
+          try {
+            version = new SemVer(version, this.options);
+          } catch (er) {
+            return false;
+          }
+        }
+        return cmp(version, this.operator, this.semver, this.options);
+      }
+      intersects(comp, options) {
+        if (!(comp instanceof _Comparator)) {
+          throw new TypeError("a Comparator is required");
+        }
+        if (this.operator === "") {
+          if (this.value === "") {
+            return true;
+          }
+          return new Range(comp.value, options).test(this.value);
+        } else if (comp.operator === "") {
+          if (comp.value === "") {
+            return true;
+          }
+          return new Range(this.value, options).test(comp.semver);
+        }
+        options = parseOptions(options);
+        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
+          return false;
+        }
+        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
+          return false;
+        }
+        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
+          return true;
+        }
+        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
+          return true;
+        }
+        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
+          return true;
+        }
+        return false;
+      }
+    };
+    module2.exports = Comparator;
+    var parseOptions = require_parse_options();
+    var { safeRe: re, t } = require_re();
+    var cmp = require_cmp();
+    var debug = require_debug();
+    var SemVer = require_semver();
+    var Range = require_range();
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/satisfies.js
+var require_satisfies = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/functions/satisfies.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var satisfies = (version, range, options) => {
+      try {
+        range = new Range(range, options);
+      } catch (er) {
+        return false;
+      }
+      return range.test(version);
+    };
+    module2.exports = satisfies;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/to-comparators.js
+var require_to_comparators = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/to-comparators.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c) => c.value).join(" ").trim().split(" "));
+    module2.exports = toComparators;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/max-satisfying.js
+var require_max_satisfying = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/max-satisfying.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var maxSatisfying = (versions, range, options) => {
+      let max = null;
+      let maxSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!max || maxSV.compare(v) === -1) {
+            max = v;
+            maxSV = new SemVer(max, options);
+          }
+        }
+      });
+      return max;
+    };
+    module2.exports = maxSatisfying;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/min-satisfying.js
+var require_min_satisfying = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/min-satisfying.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var minSatisfying = (versions, range, options) => {
+      let min = null;
+      let minSV = null;
+      let rangeObj = null;
+      try {
+        rangeObj = new Range(range, options);
+      } catch (er) {
+        return null;
+      }
+      versions.forEach((v) => {
+        if (rangeObj.test(v)) {
+          if (!min || minSV.compare(v) === 1) {
+            min = v;
+            minSV = new SemVer(min, options);
+          }
+        }
+      });
+      return min;
+    };
+    module2.exports = minSatisfying;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/min-version.js
+var require_min_version = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/min-version.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Range = require_range();
+    var gt = require_gt();
+    var minVersion = (range, loose) => {
+      range = new Range(range, loose);
+      let minver = new SemVer("0.0.0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = new SemVer("0.0.0-0");
+      if (range.test(minver)) {
+        return minver;
+      }
+      minver = null;
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let setMin = null;
+        comparators.forEach((comparator) => {
+          const compver = new SemVer(comparator.semver.version);
+          switch (comparator.operator) {
+            case ">":
+              if (compver.prerelease.length === 0) {
+                compver.patch++;
+              } else {
+                compver.prerelease.push(0);
+              }
+              compver.raw = compver.format();
+            /* fallthrough */
+            case "":
+            case ">=":
+              if (!setMin || gt(compver, setMin)) {
+                setMin = compver;
+              }
+              break;
+            case "<":
+            case "<=":
+              break;
+            /* istanbul ignore next */
+            default:
+              throw new Error(`Unexpected operation: ${comparator.operator}`);
+          }
+        });
+        if (setMin && (!minver || gt(minver, setMin))) {
+          minver = setMin;
+        }
+      }
+      if (minver && range.test(minver)) {
+        return minver;
+      }
+      return null;
+    };
+    module2.exports = minVersion;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/valid.js
+var require_valid2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/valid.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var validRange = (range, options) => {
+      try {
+        return new Range(range, options).range || "*";
+      } catch (er) {
+        return null;
+      }
+    };
+    module2.exports = validRange;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/outside.js
+var require_outside = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/outside.js"(exports2, module2) {
+    "use strict";
+    var SemVer = require_semver();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var Range = require_range();
+    var satisfies = require_satisfies();
+    var gt = require_gt();
+    var lt = require_lt();
+    var lte = require_lte();
+    var gte = require_gte();
+    var outside = (version, range, hilo, options) => {
+      version = new SemVer(version, options);
+      range = new Range(range, options);
+      let gtfn, ltefn, ltfn, comp, ecomp;
+      switch (hilo) {
+        case ">":
+          gtfn = gt;
+          ltefn = lte;
+          ltfn = lt;
+          comp = ">";
+          ecomp = ">=";
+          break;
+        case "<":
+          gtfn = lt;
+          ltefn = gte;
+          ltfn = gt;
+          comp = "<";
+          ecomp = "<=";
+          break;
+        default:
+          throw new TypeError('Must provide a hilo val of "<" or ">"');
+      }
+      if (satisfies(version, range, options)) {
+        return false;
+      }
+      for (let i = 0; i < range.set.length; ++i) {
+        const comparators = range.set[i];
+        let high = null;
+        let low = null;
+        comparators.forEach((comparator) => {
+          if (comparator.semver === ANY) {
+            comparator = new Comparator(">=0.0.0");
+          }
+          high = high || comparator;
+          low = low || comparator;
+          if (gtfn(comparator.semver, high.semver, options)) {
+            high = comparator;
+          } else if (ltfn(comparator.semver, low.semver, options)) {
+            low = comparator;
+          }
+        });
+        if (high.operator === comp || high.operator === ecomp) {
+          return false;
+        }
+        if ((!low.operator || low.operator === comp) && ltefn(version, low.semver)) {
+          return false;
+        } else if (low.operator === ecomp && ltfn(version, low.semver)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    module2.exports = outside;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/gtr.js
+var require_gtr = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/gtr.js"(exports2, module2) {
+    "use strict";
+    var outside = require_outside();
+    var gtr = (version, range, options) => outside(version, range, ">", options);
+    module2.exports = gtr;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/ltr.js
+var require_ltr = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/ltr.js"(exports2, module2) {
+    "use strict";
+    var outside = require_outside();
+    var ltr = (version, range, options) => outside(version, range, "<", options);
+    module2.exports = ltr;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/intersects.js
+var require_intersects = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/intersects.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var intersects = (r1, r2, options) => {
+      r1 = new Range(r1, options);
+      r2 = new Range(r2, options);
+      return r1.intersects(r2, options);
+    };
+    module2.exports = intersects;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/simplify.js
+var require_simplify = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/simplify.js"(exports2, module2) {
+    "use strict";
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    module2.exports = (versions, range, options) => {
+      const set = [];
+      let first = null;
+      let prev = null;
+      const v = versions.sort((a, b) => compare(a, b, options));
+      for (const version of v) {
+        const included = satisfies(version, range, options);
+        if (included) {
+          prev = version;
+          if (!first) {
+            first = version;
+          }
+        } else {
+          if (prev) {
+            set.push([first, prev]);
+          }
+          prev = null;
+          first = null;
+        }
+      }
+      if (first) {
+        set.push([first, null]);
+      }
+      const ranges = [];
+      for (const [min, max] of set) {
+        if (min === max) {
+          ranges.push(min);
+        } else if (!max && min === v[0]) {
+          ranges.push("*");
+        } else if (!max) {
+          ranges.push(`>=${min}`);
+        } else if (min === v[0]) {
+          ranges.push(`<=${max}`);
+        } else {
+          ranges.push(`${min} - ${max}`);
+        }
+      }
+      const simplified = ranges.join(" || ");
+      const original = typeof range.raw === "string" ? range.raw : String(range);
+      return simplified.length < original.length ? simplified : range;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/subset.js
+var require_subset = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/ranges/subset.js"(exports2, module2) {
+    "use strict";
+    var Range = require_range();
+    var Comparator = require_comparator();
+    var { ANY } = Comparator;
+    var satisfies = require_satisfies();
+    var compare = require_compare();
+    var subset = (sub, dom, options = {}) => {
+      if (sub === dom) {
+        return true;
+      }
+      sub = new Range(sub, options);
+      dom = new Range(dom, options);
+      let sawNonNull = false;
+      OUTER: for (const simpleSub of sub.set) {
+        for (const simpleDom of dom.set) {
+          const isSub = simpleSubset(simpleSub, simpleDom, options);
+          sawNonNull = sawNonNull || isSub !== null;
+          if (isSub) {
+            continue OUTER;
+          }
+        }
+        if (sawNonNull) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
+    var minimumVersion = [new Comparator(">=0.0.0")];
+    var simpleSubset = (sub, dom, options) => {
+      if (sub === dom) {
+        return true;
+      }
+      if (sub.length === 1 && sub[0].semver === ANY) {
+        if (dom.length === 1 && dom[0].semver === ANY) {
+          return true;
+        } else if (options.includePrerelease) {
+          sub = minimumVersionWithPreRelease;
+        } else {
+          sub = minimumVersion;
+        }
+      }
+      if (dom.length === 1 && dom[0].semver === ANY) {
+        if (options.includePrerelease) {
+          return true;
+        } else {
+          dom = minimumVersion;
+        }
+      }
+      const eqSet = /* @__PURE__ */ new Set();
+      let gt, lt;
+      for (const c of sub) {
+        if (c.operator === ">" || c.operator === ">=") {
+          gt = higherGT(gt, c, options);
+        } else if (c.operator === "<" || c.operator === "<=") {
+          lt = lowerLT(lt, c, options);
+        } else {
+          eqSet.add(c.semver);
+        }
+      }
+      if (eqSet.size > 1) {
+        return null;
+      }
+      let gtltComp;
+      if (gt && lt) {
+        gtltComp = compare(gt.semver, lt.semver, options);
+        if (gtltComp > 0) {
+          return null;
+        } else if (gtltComp === 0 && (gt.operator !== ">=" || lt.operator !== "<=")) {
+          return null;
+        }
+      }
+      for (const eq of eqSet) {
+        if (gt && !satisfies(eq, String(gt), options)) {
+          return null;
+        }
+        if (lt && !satisfies(eq, String(lt), options)) {
+          return null;
+        }
+        for (const c of dom) {
+          if (!satisfies(eq, String(c), options)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      let higher, lower;
+      let hasDomLT, hasDomGT;
+      let needDomLTPre = lt && !options.includePrerelease && lt.semver.prerelease.length ? lt.semver : false;
+      let needDomGTPre = gt && !options.includePrerelease && gt.semver.prerelease.length ? gt.semver : false;
+      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt.operator === "<" && needDomLTPre.prerelease[0] === 0) {
+        needDomLTPre = false;
+      }
+      for (const c of dom) {
+        hasDomGT = hasDomGT || c.operator === ">" || c.operator === ">=";
+        hasDomLT = hasDomLT || c.operator === "<" || c.operator === "<=";
+        if (gt) {
+          if (needDomGTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomGTPre.major && c.semver.minor === needDomGTPre.minor && c.semver.patch === needDomGTPre.patch) {
+              needDomGTPre = false;
+            }
+          }
+          if (c.operator === ">" || c.operator === ">=") {
+            higher = higherGT(gt, c, options);
+            if (higher === c && higher !== gt) {
+              return false;
+            }
+          } else if (gt.operator === ">=" && !satisfies(gt.semver, String(c), options)) {
+            return false;
+          }
+        }
+        if (lt) {
+          if (needDomLTPre) {
+            if (c.semver.prerelease && c.semver.prerelease.length && c.semver.major === needDomLTPre.major && c.semver.minor === needDomLTPre.minor && c.semver.patch === needDomLTPre.patch) {
+              needDomLTPre = false;
+            }
+          }
+          if (c.operator === "<" || c.operator === "<=") {
+            lower = lowerLT(lt, c, options);
+            if (lower === c && lower !== lt) {
+              return false;
+            }
+          } else if (lt.operator === "<=" && !satisfies(lt.semver, String(c), options)) {
+            return false;
+          }
+        }
+        if (!c.operator && (lt || gt) && gtltComp !== 0) {
+          return false;
+        }
+      }
+      if (gt && hasDomLT && !lt && gtltComp !== 0) {
+        return false;
+      }
+      if (lt && hasDomGT && !gt && gtltComp !== 0) {
+        return false;
+      }
+      if (needDomGTPre || needDomLTPre) {
+        return false;
+      }
+      return true;
+    };
+    var higherGT = (a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp > 0 ? a : comp < 0 ? b : b.operator === ">" && a.operator === ">=" ? b : a;
+    };
+    var lowerLT = (a, b, options) => {
+      if (!a) {
+        return b;
+      }
+      const comp = compare(a.semver, b.semver, options);
+      return comp < 0 ? a : comp > 0 ? b : b.operator === "<" && a.operator === "<=" ? b : a;
+    };
+    module2.exports = subset;
+  }
+});
+
+// ../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/index.js
+var require_semver2 = __commonJS({
+  "../../node_modules/.pnpm/semver@7.7.3/node_modules/semver/index.js"(exports2, module2) {
+    "use strict";
+    var internalRe = require_re();
+    var constants = require_constants();
+    var SemVer = require_semver();
+    var identifiers = require_identifiers();
+    var parse = require_parse();
+    var valid = require_valid();
+    var clean = require_clean();
+    var inc = require_inc();
+    var diff = require_diff();
+    var major = require_major();
+    var minor = require_minor();
+    var patch = require_patch();
+    var prerelease = require_prerelease();
+    var compare = require_compare();
+    var rcompare = require_rcompare();
+    var compareLoose = require_compare_loose();
+    var compareBuild = require_compare_build();
+    var sort = require_sort();
+    var rsort = require_rsort();
+    var gt = require_gt();
+    var lt = require_lt();
+    var eq = require_eq();
+    var neq = require_neq();
+    var gte = require_gte();
+    var lte = require_lte();
+    var cmp = require_cmp();
+    var coerce = require_coerce();
+    var Comparator = require_comparator();
+    var Range = require_range();
+    var satisfies = require_satisfies();
+    var toComparators = require_to_comparators();
+    var maxSatisfying = require_max_satisfying();
+    var minSatisfying = require_min_satisfying();
+    var minVersion = require_min_version();
+    var validRange = require_valid2();
+    var outside = require_outside();
+    var gtr = require_gtr();
+    var ltr = require_ltr();
+    var intersects = require_intersects();
+    var simplifyRange = require_simplify();
+    var subset = require_subset();
+    module2.exports = {
+      parse,
+      valid,
+      clean,
+      inc,
+      diff,
+      major,
+      minor,
+      patch,
+      prerelease,
+      compare,
+      rcompare,
+      compareLoose,
+      compareBuild,
+      sort,
+      rsort,
+      gt,
+      lt,
+      eq,
+      neq,
+      gte,
+      lte,
+      cmp,
+      coerce,
+      Comparator,
+      Range,
+      satisfies,
+      toComparators,
+      maxSatisfying,
+      minSatisfying,
+      minVersion,
+      validRange,
+      outside,
+      gtr,
+      ltr,
+      intersects,
+      simplifyRange,
+      subset,
+      SemVer,
+      re: internalRe.re,
+      src: internalRe.src,
+      tokens: internalRe.t,
+      SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
+      RELEASE_TYPES: constants.RELEASE_TYPES,
+      compareIdentifiers: identifiers.compareIdentifiers,
+      rcompareIdentifiers: identifiers.rcompareIdentifiers
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/@ledgerhq+devices@8.7.0/node_modules/@ledgerhq/devices/lib-es/index.js
+var import_semver, DeviceModelId, devices, productMap, devicesList, ledgerUSBVendorId, identifyUSBProductId, bluetoothServices, serviceUuidToInfos;
+var init_lib_es3 = __esm({
+  "../../node_modules/.pnpm/@ledgerhq+devices@8.7.0/node_modules/@ledgerhq/devices/lib-es/index.js"() {
+    "use strict";
+    import_semver = __toESM(require_semver2());
+    (function(DeviceModelId2) {
+      DeviceModelId2["blue"] = "blue";
+      DeviceModelId2["nanoS"] = "nanoS";
+      DeviceModelId2["nanoSP"] = "nanoSP";
+      DeviceModelId2["nanoX"] = "nanoX";
+      DeviceModelId2["stax"] = "stax";
+      DeviceModelId2["europa"] = "europa";
+      DeviceModelId2["apex"] = "apex";
+    })(DeviceModelId || (DeviceModelId = {}));
+    devices = {
+      [DeviceModelId.blue]: {
+        id: DeviceModelId.blue,
+        productName: "Ledger\xA0Blue",
+        productIdMM: 0,
+        legacyUsbProductId: 0,
+        usbOnly: true,
+        memorySize: 480 * 1024,
+        masks: [822083584, 822149120],
+        getBlockSize: (_firwareVersion) => 4 * 1024
+      },
+      [DeviceModelId.nanoS]: {
+        id: DeviceModelId.nanoS,
+        productName: "Ledger\xA0Nano\xA0S",
+        productIdMM: 16,
+        legacyUsbProductId: 1,
+        usbOnly: true,
+        memorySize: 320 * 1024,
+        masks: [823132160],
+        getBlockSize: (firmwareVersion) => import_semver.default.lt(import_semver.default.coerce(firmwareVersion) ?? "", "2.0.0") ? 4 * 1024 : 2 * 1024
+      },
+      [DeviceModelId.nanoX]: {
+        id: DeviceModelId.nanoX,
+        productName: "Ledger\xA0Nano\xA0X",
+        productIdMM: 64,
+        legacyUsbProductId: 4,
+        usbOnly: false,
+        memorySize: 2 * 1024 * 1024,
+        masks: [855638016],
+        getBlockSize: (_firwareVersion) => 4 * 1024,
+        bluetoothSpec: [
+          {
+            serviceUuid: "13d63400-2c97-0004-0000-4c6564676572",
+            notifyUuid: "13d63400-2c97-0004-0001-4c6564676572",
+            writeUuid: "13d63400-2c97-0004-0002-4c6564676572",
+            writeCmdUuid: "13d63400-2c97-0004-0003-4c6564676572"
+          }
+        ]
+      },
+      [DeviceModelId.nanoSP]: {
+        id: DeviceModelId.nanoSP,
+        productName: "Ledger Nano S Plus",
+        productIdMM: 80,
+        legacyUsbProductId: 5,
+        usbOnly: true,
+        memorySize: 1533 * 1024,
+        masks: [856686592],
+        getBlockSize: (_firmwareVersion) => 32
+      },
+      [DeviceModelId.apex]: {
+        id: DeviceModelId.apex,
+        productName: "Ledger\xA0Nano\xA0Gen5",
+        productIdMM: 128,
+        legacyUsbProductId: 8,
+        usbOnly: false,
+        memorySize: 1533 * 1024,
+        masks: [859832320],
+        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\xA0Stax",
+        productIdMM: 96,
+        legacyUsbProductId: 6,
+        usbOnly: false,
+        memorySize: 1533 * 1024,
+        masks: [857735168],
+        getBlockSize: (_firmwareVersion) => 32,
+        bluetoothSpec: [
+          {
+            serviceUuid: "13d63400-2c97-6004-0000-4c6564676572",
+            notifyUuid: "13d63400-2c97-6004-0001-4c6564676572",
+            writeUuid: "13d63400-2c97-6004-0002-4c6564676572",
+            writeCmdUuid: "13d63400-2c97-6004-0003-4c6564676572"
+          }
+        ]
+      },
+      [DeviceModelId.europa]: {
+        id: DeviceModelId.europa,
+        productName: "Ledger\xA0Flex",
+        productIdMM: 112,
+        legacyUsbProductId: 7,
+        usbOnly: false,
+        memorySize: 1533 * 1024,
+        masks: [858783744],
+        getBlockSize: (_firmwareVersion) => 32,
+        bluetoothSpec: [
+          {
+            serviceUuid: "13d63400-2c97-3004-0000-4c6564676572",
+            notifyUuid: "13d63400-2c97-3004-0001-4c6564676572",
+            writeUuid: "13d63400-2c97-3004-0002-4c6564676572",
+            writeCmdUuid: "13d63400-2c97-3004-0003-4c6564676572"
+          }
+        ]
+      }
+    };
+    productMap = {
+      Blue: DeviceModelId.blue,
+      "Nano S": DeviceModelId.nanoS,
+      "Nano S Plus": DeviceModelId.nanoSP,
+      "Nano X": DeviceModelId.nanoX,
+      Stax: DeviceModelId.stax,
+      Europa: DeviceModelId.europa
+    };
+    devicesList = Object.values(devices);
+    ledgerUSBVendorId = 11415;
+    identifyUSBProductId = (usbProductId) => {
+      const legacy = devicesList.find((d) => d.legacyUsbProductId === usbProductId);
+      if (legacy)
+        return legacy;
+      const mm = usbProductId >> 8;
+      const deviceModel = devicesList.find((d) => d.productIdMM === mm);
+      return deviceModel;
+    };
+    bluetoothServices = [];
+    serviceUuidToInfos = {};
+    for (const id2 in devices) {
+      const deviceModel = devices[id2];
+      const { bluetoothSpec } = deviceModel;
+      if (bluetoothSpec) {
+        for (let i = 0; i < bluetoothSpec.length; i++) {
+          const spec = bluetoothSpec[i];
+          bluetoothServices.push(spec.serviceUuid);
+          serviceUuidToInfos[spec.serviceUuid] = serviceUuidToInfos[spec.serviceUuid.replace(/-/g, "")] = {
+            deviceModel,
+            ...spec
+          };
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.29.13/node_modules/@ledgerhq/hw-transport-webusb/lib-es/webusb.js
+async function requestLedgerDevice() {
+  const device = await navigator.usb.requestDevice({
+    filters: ledgerDevices
+  });
+  return device;
+}
+async function getLedgerDevices() {
+  const devices2 = await navigator.usb.getDevices();
+  return devices2.filter((d) => d.vendorId === ledgerUSBVendorId);
+}
+async function getFirstLedgerDevice() {
+  const existingDevices = await getLedgerDevices();
+  if (existingDevices.length > 0)
+    return existingDevices[0];
+  return requestLedgerDevice();
+}
+var ledgerDevices, isSupported;
+var init_webusb = __esm({
+  "../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.29.13/node_modules/@ledgerhq/hw-transport-webusb/lib-es/webusb.js"() {
+    "use strict";
+    init_lib_es3();
+    ledgerDevices = [
+      {
+        vendorId: ledgerUSBVendorId
+      }
+    ];
+    isSupported = () => Promise.resolve(!!navigator && !!navigator.usb && typeof navigator.usb.getDevices === "function");
+  }
+});
+
+// ../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.29.13/node_modules/@ledgerhq/hw-transport-webusb/lib-es/TransportWebUSB.js
+var TransportWebUSB_exports = {};
+__export(TransportWebUSB_exports, {
+  default: () => TransportWebUSB
+});
+async function gracefullyResetDevice(device) {
+  try {
+    await device.reset();
+  } catch (err) {
+    console.warn(err);
+  }
+}
+var configurationValue, endpointNumber, TransportWebUSB;
+var init_TransportWebUSB = __esm({
+  "../../node_modules/.pnpm/@ledgerhq+hw-transport-webusb@6.29.13/node_modules/@ledgerhq/hw-transport-webusb/lib-es/TransportWebUSB.js"() {
+    "use strict";
+    init_Transport();
+    init_hid_framing();
+    init_lib_es3();
+    init_lib_es2();
+    init_lib_es();
+    init_webusb();
+    configurationValue = 1;
+    endpointNumber = 3;
+    TransportWebUSB = class _TransportWebUSB extends Transport {
+      device;
+      deviceModel;
+      channel = Math.floor(Math.random() * 65535);
+      packetSize = 64;
+      interfaceNumber;
+      constructor(device, interfaceNumber) {
+        super();
+        this.device = device;
+        this.interfaceNumber = interfaceNumber;
+        this.deviceModel = identifyUSBProductId(device.productId);
+      }
+      /**
+       * Check if WebUSB transport is supported.
+       */
+      static isSupported = isSupported;
+      /**
+       * List the WebUSB devices that was previously authorized by the user.
+       */
+      static list = getLedgerDevices;
+      /**
+       * Actively listen to WebUSB devices and emit ONE device
+       * that was either accepted before, if not it will trigger the native permission UI.
+       *
+       * Important: it must be called in the context of a UI click!
+       */
+      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));
+          }
+        });
+        function unsubscribe() {
+          unsubscribed = true;
+        }
+        return {
+          unsubscribe
+        };
+      };
+      /**
+       * Similar to create() except it will always display the device permission (even if some devices are already accepted).
+       */
+      static async request() {
+        const device = await requestLedgerDevice();
+        return _TransportWebUSB.open(device);
+      }
+      /**
+       * Similar to create() except it will never display the device permission (it returns a Promise<?Transport>, null if it fails to find a device).
+       */
+      static async openConnected() {
+        const devices2 = await getLedgerDevices();
+        if (devices2.length === 0)
+          return null;
+        return _TransportWebUSB.open(devices2[0]);
+      }
+      /**
+       * Create a Ledger transport with a USBDevice
+       */
+      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());
+          }
+        };
+        navigator.usb.addEventListener("disconnect", onDisconnect);
+        return transport;
+      }
+      _disconnectEmitted = false;
+      _emitDisconnect = (e) => {
+        if (this._disconnectEmitted)
+          return;
+        this._disconnectEmitted = true;
+        this.emit("disconnect", e);
+      };
+      /**
+       * Release the transport device
+       */
+      async close() {
+        await this.exchangeBusyPromise;
+        await this.device.releaseInterface(this.interfaceNumber);
+        await gracefullyResetDevice(this.device);
+        await this.device.close();
+      }
+      /**
+       * Exchange with the device using APDU protocol.
+       * @param apdu
+       * @returns a promise of apdu response
+       */
+      async exchange(apdu) {
+        const b = await this.exchangeAtomicImpl(async () => {
+          const { channel, packetSize } = this;
+          log("apdu", "=> " + apdu.toString("hex"));
+          const framing = hid_framing_default(channel, packetSize);
+          const blocks = framing.makeBlocks(apdu);
+          for (let i = 0; i < blocks.length; i++) {
+            await this.device.transferOut(endpointNumber, blocks[i]);
+          }
+          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);
+          }
+          log("apdu", "<= " + result.toString("hex"));
+          return result;
+        }).catch((e) => {
+          if (e && e.message && e.message.includes("disconnected")) {
+            this._emitDisconnect(e);
+            throw new DisconnectedDeviceDuringOperation(e.message);
+          }
+          throw e;
+        });
+        return b;
+      }
+      setScrambleKey() {
+      }
+    };
+  }
+});
 
 // src/browser.ts
 var browser_exports = {};
@@ -2952,6 +6108,31 @@ var SIP = class {
   intentsAdapter;
   /** Cache of pending swaps by intent ID */
   pendingSwaps = /* @__PURE__ */ new Map();
+  /**
+   * Create a new SIP SDK client
+   *
+   * @param config - Configuration options for the client
+   * @throws {ValidationError} If configuration is invalid
+   *
+   * @example Minimal configuration
+   * ```typescript
+   * const sip = new SIP({ network: 'testnet' })
+   * ```
+   *
+   * @example Full configuration
+   * ```typescript
+   * const sip = new SIP({
+   *   network: 'mainnet',
+   *   mode: 'production',
+   *   defaultPrivacy: PrivacyLevel.COMPLIANT,
+   *   proofProvider: await NoirProofProvider.create(),
+   *   intentsAdapter: { jwtToken: process.env.JWT },
+   *   rpcEndpoints: {
+   *     ethereum: 'https://eth-mainnet.g.alchemy.com/v2/KEY',
+   *   },
+   * })
+   * ```
+   */
   constructor(config) {
     if (!config || typeof config !== "object") {
       throw new ValidationError("config must be an object");
@@ -4435,11 +7616,11 @@ function computeAttestationHash(message) {
   return (0, import_sha2569.sha256)(toHash);
 }
 function getChainNumericId(chain) {
-  const id = CHAIN_NUMERIC_IDS[chain];
-  if (id === void 0) {
+  const id2 = CHAIN_NUMERIC_IDS[chain];
+  if (id2 === void 0) {
     throw new ValidationError(`Unknown chain: ${chain}`, "chain");
   }
-  return id;
+  return id2;
 }
 function normalizeToBytes(hex, length, field) {
   const stripped = hex.startsWith("0x") ? hex.slice(2) : hex;
@@ -11632,8 +14813,8 @@ var WalletRegistry = class {
    *
    * @param id - The wallet identifier
    */
-  unregister(id) {
-    this.entries.delete(id);
+  unregister(id2) {
+    this.entries.delete(id2);
   }
   /**
    * Get wallet info by ID
@@ -11641,8 +14822,8 @@ var WalletRegistry = class {
    * @param id - The wallet identifier
    * @returns The wallet info or undefined
    */
-  getInfo(id) {
-    return this.entries.get(id)?.info;
+  getInfo(id2) {
+    return this.entries.get(id2)?.info;
   }
   /**
    * Get all registered wallet infos
@@ -11693,8 +14874,8 @@ var WalletRegistry = class {
    * @param id - The wallet identifier
    * @returns True if wallet is detected
    */
-  isAvailable(id) {
-    const entry = this.entries.get(id);
+  isAvailable(id2) {
+    const entry = this.entries.get(id2);
     return entry ? entry.detect() : false;
   }
   /**
@@ -11704,10 +14885,10 @@ var WalletRegistry = class {
    * @returns A new wallet adapter instance
    * @throws If wallet is not registered
    */
-  create(id) {
-    const entry = this.entries.get(id);
+  create(id2) {
+    const entry = this.entries.get(id2);
     if (!entry) {
-      throw new Error(`Wallet '${id}' is not registered`);
+      throw new Error(`Wallet '${id2}' is not registered`);
     }
     return entry.factory();
   }
@@ -11718,8 +14899,8 @@ var WalletRegistry = class {
    * @returns A connected wallet adapter
    * @throws If wallet is not registered or connection fails
    */
-  async connect(id) {
-    const wallet = this.create(id);
+  async connect(id2) {
+    const wallet = this.create(id2);
     await wallet.connect();
     return wallet;
   }
@@ -13593,8 +16774,8 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
     }
     this._connectionState = "connecting";
     try {
-      const TransportWebUSB = await this.loadTransport();
-      this.transport = await TransportWebUSB.create();
+      const TransportWebUSB2 = await this.loadTransport();
+      this.transport = await TransportWebUSB2.create();
       this.app = await this.loadApp();
       this._account = await this.getAccountFromDevice();
       this._deviceInfo = {
@@ -13743,7 +16924,7 @@ var LedgerWalletAdapter = class extends BaseWalletAdapter {
    */
   async loadTransport() {
     try {
-      const module2 = await import("@ledgerhq/hw-transport-webusb");
+      const module2 = await Promise.resolve().then(() => (init_TransportWebUSB(), TransportWebUSB_exports));
       return module2.default;
     } catch {
       throw new HardwareWalletError(
@@ -16053,9 +19234,9 @@ var BrowserNoirProvider = class _BrowserNoirProvider {
       };
       this.worker.onerror = (error) => {
         console.error("[BrowserNoirProvider] Worker error:", error);
-        for (const [id, { reject }] of this.workerPending) {
+        for (const [id2, { reject }] of this.workerPending) {
           reject(new Error(`Worker error: ${error.message}`));
-          this.workerPending.delete(id);
+          this.workerPending.delete(id2);
         }
         this.worker?.terminate();
         this.worker = null;
@@ -17021,9 +20202,9 @@ var ProofWorker = class _ProofWorker {
     };
     this.worker.onerror = (error) => {
       console.error("[ProofWorker] Worker error:", error);
-      for (const [id, { reject }] of this.pendingRequests) {
+      for (const [id2, { reject }] of this.pendingRequests) {
         reject(new Error(`Worker error: ${error.message}`));
-        this.pendingRequests.delete(id);
+        this.pendingRequests.delete(id2);
       }
     };
     await this.sendRequest("init", void 0, config);
@@ -17064,9 +20245,9 @@ var ProofWorker = class _ProofWorker {
         reject(new Error("Worker not available"));
         return;
       }
-      const id = `req_${++this.requestCounter}_${Date.now()}`;
-      this.pendingRequests.set(id, { resolve, reject, onProgress });
-      const request = { id, type, params, config };
+      const id2 = `req_${++this.requestCounter}_${Date.now()}`;
+      this.pendingRequests.set(id2, { resolve, reject, onProgress });
+      const request = { id: id2, type, params, config };
       this.worker.postMessage(request);
     });
   }