@trezor/connect 9.6.3-beta.2 → 9.6.4-beta.1

package/lib/types/api/thpRemoveCredentials.d.ts

@@ -1,5 +1,5 @@
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
 import type { ThpCredentials } from '@trezor/protocol';
-import type { PROTO } from '../../constants';
 import type { CommonParams, Response } from '../params';
 export declare function thpRemoveCredentials(params: CommonParams & {
     credentials?: ThpCredentials[];

package/lib/types/api/unlockPath.d.ts

@@ -1,5 +1,5 @@
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
 import { Static } from '@trezor/schema-utils';
-import type { PROTO } from '../../constants';
 import { Params, Response } from '../params';
 export type UnlockPathParams = Static<typeof UnlockPathParams>;
 export declare const UnlockPathParams: import("@trezor/schema-utils").TObject<{

package/lib/types/api/verifyMessage.d.ts

@@ -1,4 +1,4 @@
-import type { PROTO } from '../../constants';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
 import type { Params, Response } from '../params';
 import type { VerifyMessage } from './bitcoin';
 export declare function verifyMessage(params: Params<VerifyMessage>): Response<PROTO.Success>;

package/lib/types/api/wipeDevice.d.ts

@@ -1,4 +1,4 @@
-import type { PROTO } from '../../constants';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
 import type { CommonParams, Response } from '../params';
 export declare function wipeDevice(params?: CommonParams): Response<PROTO.Success>;
 //# sourceMappingURL=wipeDevice.d.ts.map

package/lib/types/device.d.ts

@@ -1,9 +1,11 @@
 import { FeaturesNarrowing, FirmwareType } from '@trezor/device-utils';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
 import type { ThpStateSerialized } from '@trezor/protocol';
+import { Descriptor } from '@trezor/transport';
 import { Branded } from '@trezor/type-utils';
-import type { PROTO } from '../constants';
 import type { FirmwareReleaseConfigInfo } from './firmware';
-export type DeviceStatus = 'available' | 'occupied' | 'used' | 'busy';
+export type DeviceBusyStatus = 'busy' | 'rebooting' | 'bootloader-locked' | 'hard-locked' | 'pin-locked' | 'thp-locked';
+export type DeviceStatus = 'available' | 'occupied' | 'used' | DeviceBusyStatus;
 export type DeviceMode = 'normal' | 'bootloader' | 'initialize' | 'seedless';
 export type DeviceFirmwareStatus = 'valid' | 'outdated' | 'required' | 'unknown' | 'custom' | 'none';
 export type UnavailableCapability = 'no-capability' | 'no-support' | 'update-required' | 'trezor-connect-outdated';
@@ -36,13 +38,16 @@ export type FirmwareHashCheckResult = {
     errorPayload?: unknown;
 };
 export type DeviceUniquePath = string & Branded<'DeviceUniquePath'>;
-export declare const DeviceUniquePath: (id: string) => DeviceUniquePath;
+export declare const asDeviceUniquePath: (id: string) => DeviceUniquePath;
 type BaseDevice = {
     path: DeviceUniquePath;
     name: string;
+    descriptor: Pick<Descriptor, 'apiType' | 'id'>;
 };
+export type BluetoothDeviceId = string & Branded<'BluetoothDeviceId'>;
+export declare const asBluetoothDeviceId: (id: string) => BluetoothDeviceId;
 export type BluetoothDeviceProps = {
-    id: string;
+    id: BluetoothDeviceId;
 };
 export type KnownDevice = BaseDevice & {
     type: 'acquired';

package/lib/types/device.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DeviceUniquePath = void 0;
-const DeviceUniquePath = (id) => id;
-exports.DeviceUniquePath = DeviceUniquePath;
+exports.asBluetoothDeviceId = exports.asDeviceUniquePath = void 0;
+const asDeviceUniquePath = (id) => id;
+exports.asDeviceUniquePath = asDeviceUniquePath;
+const asBluetoothDeviceId = (id) => id;
+exports.asBluetoothDeviceId = asBluetoothDeviceId;
 //# sourceMappingURL=device.js.map

package/lib/types/firmware.d.ts

@@ -21,4 +21,5 @@ export type FirmwareReleaseConfigInfo = {
     translations?: Record<string, string>;
 };
 export type FirmwareUpdateFlowType = 'reboot_and_wait' | 'reboot_and_upgrade' | 'manual' | 'unknown_flow';
+export type FirmwareUpdateSource = 'production' | 'test-unsigned' | 'test-unsigned-stable' | 'test-signed' | 'localhost-unsigned' | 'localhost-signed';
 //# sourceMappingURL=firmware.d.ts.map

package/lib/types/settings.d.ts

@@ -3,7 +3,7 @@ import type { DeviceModelInternal } from '@trezor/device-utils';
 import type { ThpCredentials, ThpPairingMethod } from '@trezor/protocol';
 import type { Transport } from '@trezor/transport';
 import { PartialRecord } from '@trezor/type-utils';
-import { FirmwareUpdateSource } from '../data/firmwareInfo';
+import type { FirmwareUpdateSource } from '../types/firmware';
 export type { SystemInfo } from '@trezor/connect-common';
 export interface Manifest {
     appName: string;
@@ -17,7 +17,7 @@ export type LocalFirmwares = {
     firmwareDir: string;
     firmwareList: string[];
 };
-type KnownTransport = Exclude<Transport['name'], 'NativeUsbTransport' | 'BluetoothTransport'>;
+type KnownTransport = Exclude<Transport['name'], 'NativeUsbTransport' | 'BluetoothTransport' | 'NativeBluetoothTransport'>;
 export type ThpSettings = {
     hostName?: string;
     appName?: string;

package/lib/types/workflow.d.ts

@@ -5,4 +5,8 @@ export type WorkflowContext = {
     method: AbstractMethod<any>;
     signal: AbortSignal;
 };
+export type TpnWorkflowContext = {
+    device: Device;
+    message: number[];
+};
 //# sourceMappingURL=workflow.d.ts.map

package/lib/utils/assetUtils.d.ts

@@ -1,8 +1,10 @@
 import { DeviceModelInternal, FirmwareRelease, FirmwareType, VersionArray } from '@trezor/device-utils';
-export declare const getReleasesAssetByDeviceModelAndFirmwareType: (deviceModel: DeviceModelInternal, firmwareType: FirmwareType) => {
-    [file: string]: FirmwareRelease;
-};
+export declare class HttpRequestError extends Error {
+    response: Response;
+    constructor(response: Response);
+}
+export declare const getReleasesAssetByDeviceModelAndFirmwareType: (deviceModel: DeviceModelInternal, firmwareType: FirmwareType) => FirmwareRelease[];
 export declare const getReleaseAsset: (deviceModel: DeviceModelInternal, version: VersionArray, firmwareType: FirmwareType) => FirmwareRelease;
 export declare const firmwareReleaseConfigAssets: any;
-export declare const tryLocalAssetRequire: (url: string) => any;
+export declare const tryLocalAssetRequire: (url: string) => unknown;
 //# sourceMappingURL=assetUtils.d.ts.map

package/lib/utils/assetUtils.js

@@ -1,11 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.tryLocalAssetRequire = exports.firmwareReleaseConfigAssets = exports.getReleaseAsset = exports.getReleasesAssetByDeviceModelAndFirmwareType = void 0;
+exports.tryLocalAssetRequire = exports.firmwareReleaseConfigAssets = exports.getReleaseAsset = exports.getReleasesAssetByDeviceModelAndFirmwareType = exports.HttpRequestError = void 0;
 const connect_common_1 = require("@trezor/connect-common");
 const device_utils_1 = require("@trezor/device-utils");
+const utils_1 = require("@trezor/utils");
+class HttpRequestError extends Error {
+    response;
+    constructor(response) {
+        const message = `${response.status} while fetching ${response.url}`;
+        super(message);
+        this.response = response;
+    }
+}
+exports.HttpRequestError = HttpRequestError;
 const getReleasesAssetByDeviceModelAndFirmwareType = (deviceModel, firmwareType) => {
     const firmwareTypeInFileName = firmwareType === device_utils_1.FirmwareType.BitcoinOnly ? 'bitcoinonly' : 'universal';
-    return connect_common_1.firmwareAssets[deviceModel.toLowerCase()][firmwareTypeInFileName];
+    const availableReleasesRecord = connect_common_1.firmwareAssets?.[deviceModel.toLowerCase()]?.[firmwareTypeInFileName] ?? {};
+    return Object.values(availableReleasesRecord).sort((a, b) => utils_1.versionUtils.isNewer(b.version, a.version) ? 1 : -1);
 };
 exports.getReleasesAssetByDeviceModelAndFirmwareType = getReleasesAssetByDeviceModelAndFirmwareType;
 const getReleaseAsset = (deviceModel, version, firmwareType) => {

package/lib/utils/assets-browser.d.ts

@@ -1,7 +1,3 @@
 import { HttpRequestOptions, HttpRequestReturnType, HttpRequestType } from './assetsTypes';
-export declare class HttpRequestError extends Error {
-    response: Response;
-    constructor(response: Response);
-}
 export declare const httpRequest: <T extends HttpRequestType>(url: string, type?: T, options?: HttpRequestOptions) => Promise<HttpRequestReturnType<T>>;
 //# sourceMappingURL=assets-browser.d.ts.map

package/lib/utils/assets-browser.js

@@ -1,17 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.httpRequest = exports.HttpRequestError = void 0;
+exports.httpRequest = void 0;
 const tslib_1 = require("tslib");
 const cross_fetch_1 = tslib_1.__importDefault(require("cross-fetch"));
-class HttpRequestError extends Error {
-    response;
-    constructor(response) {
-        const message = `${response.status} while fetching ${response.url}`;
-        super(message);
-        this.response = response;
-    }
-}
-exports.HttpRequestError = HttpRequestError;
+const assetUtils_1 = require("./assetUtils");
 const httpRequest = async (url, type = 'text', options) => {
     const init = { ...options, credentials: 'same-origin' };
     const response = await (0, cross_fetch_1.default)(url, init);
@@ -25,7 +17,7 @@ const httpRequest = async (url, type = 'text', options) => {
         }
         return response.text();
     }
-    throw new HttpRequestError(response);
+    throw new assetUtils_1.HttpRequestError(response);
 };
 exports.httpRequest = httpRequest;
 //# sourceMappingURL=assets-browser.js.map

package/lib/utils/assets.native.js

@@ -10,7 +10,7 @@ function httpRequest(url, type, options) {
         })
             .then(response => {
             if (!response.ok) {
-                throw new Error(`HTTP request failed with status ${response.status} ${response.statusText}`);
+                throw new assetUtils_1.HttpRequestError(response);
             }
             if (type === 'binary') {
                 return response.arrayBuffer();

package/lib/utils/deviceFeaturesUtils.d.ts

@@ -1,5 +1,5 @@
 import { DeviceModelInternal } from '@trezor/device-utils';
-import { PROTO } from '../constants';
+import { MessagesSchema as PROTO } from '@trezor/protobuf';
 import { CoinInfo, Features, UnavailableCapabilities } from '../types';
 export declare const parseCapabilities: (features?: Features) => PROTO.Capability[];
 export declare const getUnavailableCapabilities: (features: Features, coins: CoinInfo[]) => UnavailableCapabilities;

package/lib/utils/firmwareUtils.d.ts

@@ -1,12 +1,15 @@
-import type { DeviceModelInternal, FirmwareRelease } from '@trezor/device-utils';
-import { CurrentVersion } from '../data/firmwareInfo';
-import { Features, FirmwareType, StrictFeatures, VersionArray } from '../types';
+import { FirmwareType } from '@trezor/device-utils';
+import type { DeviceModelInternal, FirmwareRelease, VersionArray } from '@trezor/device-utils';
+import type { CurrentVersion } from '../data/firmwareInfo';
+import type { Features, StrictFeatures } from '../types/device';
 export declare const isStrictFeatures: (extFeatures: Features) => extFeatures is StrictFeatures;
 type VersionCheckProperty = 'min_firmware_version' | 'min_bootloader_version';
-export declare const findBestCompatibleRelease: (releasesOfDevice: Record<string, FirmwareRelease>, currentVesion: CurrentVersion, checkProperty: VersionCheckProperty) => FirmwareRelease | undefined;
+export declare const findBestCompatibleRelease: (availableFirmwares: FirmwareRelease[], currentVesion: CurrentVersion, checkProperty: VersionCheckProperty) => FirmwareRelease | undefined;
+export declare const buildLocalReleaseName: (firmwareType: FirmwareType, deviceModel: DeviceModelInternal, version: VersionArray) => string;
 export declare const buildLocalFirmwareFileName: (firmwareType: FirmwareType, deviceModel: DeviceModelInternal, version: VersionArray) => string;
 export declare const buildIntermediaryFirmwareFileName: (internalModel: DeviceModelInternal, version: number) => string;
 export declare const getFirmwareMode: (features: Features) => "normal" | "bootloader" | "initialize" | "seedless";
 export declare const getFirmwareType: (features: Features) => FirmwareType;
+export declare const isFirmwareCacheUsedForSelectedSource: () => boolean;
 export {};
 //# sourceMappingURL=firmwareUtils.d.ts.map

package/lib/utils/firmwareUtils.js

@@ -1,18 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFirmwareType = exports.getFirmwareMode = exports.buildIntermediaryFirmwareFileName = exports.buildLocalFirmwareFileName = exports.findBestCompatibleRelease = exports.isStrictFeatures = void 0;
+exports.isFirmwareCacheUsedForSelectedSource = exports.getFirmwareType = exports.getFirmwareMode = exports.buildIntermediaryFirmwareFileName = exports.buildLocalFirmwareFileName = exports.buildLocalReleaseName = exports.findBestCompatibleRelease = exports.isStrictFeatures = void 0;
+const device_utils_1 = require("@trezor/device-utils");
 const utils_1 = require("@trezor/utils");
-const types_1 = require("../types");
+const DataManager_1 = require("../data/DataManager");
 const isStrictFeatures = (extFeatures) => [1, 2].includes(extFeatures.major_version) &&
     (extFeatures.firmware_present === false ||
         extFeatures.bootloader_mode == null ||
         extFeatures.bootloader_mode === true);
 exports.isStrictFeatures = isStrictFeatures;
-const findBestCompatibleRelease = (releasesOfDevice, currentVesion, checkProperty) => {
-    if (!releasesOfDevice || Object.keys(releasesOfDevice).length === 0) {
+const findBestCompatibleRelease = (availableFirmwares, currentVesion, checkProperty) => {
+    if (!availableFirmwares || availableFirmwares.length === 0) {
         return;
     }
-    const availableFirmwares = Object.values(releasesOfDevice);
     const currentFirmwareVersion = currentVesion.firmwareVersion;
     const currentBootloaderVersion = currentVesion.bootloaderVersion;
     let versionToCompare = currentFirmwareVersion;
@@ -33,10 +33,15 @@ const findBestCompatibleRelease = (releasesOfDevice, currentVesion, checkPropert
     return compatibleFirmware;
 };
 exports.findBestCompatibleRelease = findBestCompatibleRelease;
-const buildLocalFirmwareFileName = (firmwareType, deviceModel, version) => {
-    const firmwareTypeFileString = firmwareType === types_1.FirmwareType.BitcoinOnly ? '-bitcoinonly' : '';
-    return `trezor-${deviceModel.toLowerCase()}-${version.join('.')}${firmwareTypeFileString}.bin`;
+const buildLocalFileBaseName = (firmwareType, deviceModel, version) => {
+    const firmwareSuffix = firmwareType === device_utils_1.FirmwareType.BitcoinOnly ? '-bitcoinonly' : '';
+    const model = deviceModel.toLowerCase();
+    const versionString = version.join('.');
+    return `trezor-${model}-${versionString}${firmwareSuffix}`;
 };
+const buildLocalReleaseName = (firmwareType, deviceModel, version) => `${buildLocalFileBaseName(firmwareType, deviceModel, version)}.json`;
+exports.buildLocalReleaseName = buildLocalReleaseName;
+const buildLocalFirmwareFileName = (firmwareType, deviceModel, version) => `${buildLocalFileBaseName(firmwareType, deviceModel, version)}.bin`;
 exports.buildLocalFirmwareFileName = buildLocalFirmwareFileName;
 const buildIntermediaryFirmwareFileName = (internalModel, version) => `trezor-${internalModel.toLowerCase()}-inter-v${version}.bin`;
 exports.buildIntermediaryFirmwareFileName = buildIntermediaryFirmwareFileName;
@@ -51,25 +56,27 @@ const getFirmwareMode = (features) => {
 };
 exports.getFirmwareMode = getFirmwareMode;
 const getFirmwareType = (features) => {
-    let type = types_1.FirmwareType.Universal;
+    let type = device_utils_1.FirmwareType.Universal;
     if (features.fw_vendor === 'Trezor Bitcoin-only') {
-        type = types_1.FirmwareType.BitcoinOnly;
+        type = device_utils_1.FirmwareType.BitcoinOnly;
     }
     else if (features.fw_vendor === 'Trezor') {
-        type = types_1.FirmwareType.Universal;
+        type = device_utils_1.FirmwareType.Universal;
     }
     else if ((0, exports.getFirmwareMode)(features) !== 'bootloader') {
         type =
             features.capabilities &&
                 features.capabilities.length > 0 &&
                 !features.capabilities.includes('Capability_Bitcoin_like')
-                ? types_1.FirmwareType.BitcoinOnly
-                : types_1.FirmwareType.Universal;
+                ? device_utils_1.FirmwareType.BitcoinOnly
+                : device_utils_1.FirmwareType.Universal;
     }
     else if ((0, exports.getFirmwareMode)(features) === 'bootloader' && features.unit_btconly) {
-        type = types_1.FirmwareType.BitcoinOnly;
+        type = device_utils_1.FirmwareType.BitcoinOnly;
     }
     return type;
 };
 exports.getFirmwareType = getFirmwareType;
+const isFirmwareCacheUsedForSelectedSource = () => DataManager_1.DataManager.getSettings('firmwareUpdateSource') === 'production';
+exports.isFirmwareCacheUsedForSelectedSource = isFirmwareCacheUsedForSelectedSource;
 //# sourceMappingURL=firmwareUtils.js.map

package/lib/utils/pathUtils.d.ts

@@ -1,5 +1,6 @@
 import { PROTO } from '../constants';
-import type { CoinInfo, DerivationPath, ProtoWithAddressN, ProtoWithDerivationPath } from '../types';
+import type { CoinInfo } from '../types/coinInfo';
+import type { DerivationPath, ProtoWithAddressN, ProtoWithDerivationPath } from '../types/params';
 export declare const HD_HARDENED = 2147483648;
 export declare const toHardened: (n: number) => number;
 export declare const fromHardened: (n: number) => number;
@@ -8,7 +9,7 @@ export declare const getHDPath: (path: string) => number[];
 export declare const isSegwitPath: (path: number[] | undefined) => boolean;
 export declare const isBech32Path: (path: number[] | undefined) => boolean;
 export declare const isTaprootPath: (path: number[] | undefined) => boolean;
-export declare const getAccountType: (path: number[] | undefined) => "p2pkh" | "p2sh" | "p2tr" | "p2wpkh";
+export declare const getAccountType: (path: number[] | undefined) => "p2tr" | "p2wpkh" | "p2sh" | "p2pkh";
 export declare const getScriptType: (path: number[] | undefined) => PROTO.InternalInputScriptType | undefined;
 export declare const getOutputScriptType: (path?: number[]) => PROTO.ChangeOutputScriptType | undefined;
 export declare const validatePath: (path: DerivationPath, length?: number, base?: boolean) => number[];

package/lib/utils/uiPromiseManager.d.ts

@@ -6,23 +6,23 @@ export declare const createUiPromiseManager: (interactionTimeout: () => void) =>
     resolve: (event: UiPromiseResponse) => boolean;
     rejectAll: (error: Error) => void;
     disconnected: (devicePath: DeviceUniquePath) => boolean;
-    get: <T extends UiPromiseResponse["type"]>(type: T) => Promise<Extract<import("../events").UiResponsePopupHandshake, {
+    get: <T extends UiPromiseResponse["type"]>(type: T) => Promise<Extract<import("../events").UiResponsePin, {
         type: T;
-    }> | Extract<import("../events").UiResponsePermission, {
+    }> | Extract<import("../events").UiResponsePassphrase, {
         type: T;
-    }> | Extract<import("../events").UiResponseConfirmation, {
+    }> | Extract<import("../events").UiResponseWord, {
         type: T;
-    }> | Extract<import("../events").UiResponseFirmwares, {
+    }> | Extract<import("../events").UiResponseThpPairingTag, {
         type: T;
-    }> | Extract<import("../events").UiResponseDevice, {
+    }> | Extract<import("../events").UiResponsePopupHandshake, {
         type: T;
-    }> | Extract<import("../events").UiResponsePin, {
+    }> | Extract<import("../events").UiResponsePermission, {
         type: T;
-    }> | Extract<import("../events").UiResponseWord, {
+    }> | Extract<import("../events").UiResponseConfirmation, {
         type: T;
-    }> | Extract<import("../events").UiResponsePassphrase, {
+    }> | Extract<import("../events").UiResponseFirmwares, {
         type: T;
-    }> | Extract<import("../events").UiResponseThpPairingTag, {
+    }> | Extract<import("../events").UiResponseDevice, {
         type: T;
     }> | Extract<import("../events").UiResponsePassphraseAction, {
         type: T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trezor/connect",
-  "version": "9.6.3-beta.2",
+  "version": "9.6.4-beta.1",
   "author": "Trezor <info@trezor.io>",
   "homepage": "https://github.com/trezor/trezor-suite/tree/develop/packages/connect",
   "description": "High-level javascript interface for Trezor hardware wallet.",
@@ -79,21 +79,21 @@
     "@solana-program/token": "^0.5.1",
     "@solana-program/token-2022": "^0.4.2",
     "@solana/kit": "^2.3.0",
-    "@trezor/blockchain-link": "2.5.3-beta.1",
-    "@trezor/blockchain-link-types": "1.4.3-beta.1",
-    "@trezor/blockchain-link-utils": "1.4.3-beta.1",
-    "@trezor/connect-analytics": "1.3.5",
-    "@trezor/connect-common": "0.4.3-beta.2",
-    "@trezor/crypto-utils": "1.1.4",
-    "@trezor/device-utils": "1.1.3-beta.2",
-    "@trezor/env-utils": "^1.4.3-beta.1",
-    "@trezor/protobuf": "1.4.3-beta.1",
-    "@trezor/protocol": "1.2.9-beta.1",
+    "@trezor/blockchain-link": "2.5.4-beta.1",
+    "@trezor/blockchain-link-types": "1.4.4-beta.1",
+    "@trezor/blockchain-link-utils": "1.4.4-beta.1",
+    "@trezor/connect-analytics": "1.3.6",
+    "@trezor/connect-common": "0.4.4-beta.1",
+    "@trezor/crypto-utils": "1.1.5-beta.1",
+    "@trezor/device-utils": "1.1.4-beta.1",
+    "@trezor/env-utils": "^1.4.3",
+    "@trezor/protobuf": "1.4.4-beta.1",
+    "@trezor/protocol": "1.2.10-beta.1",
     "@trezor/schema-utils": "1.3.4",
-    "@trezor/transport": "1.5.3-beta.2",
-    "@trezor/type-utils": "1.1.9-beta.1",
-    "@trezor/utils": "9.4.3-beta.1",
-    "@trezor/utxo-lib": "2.4.3-beta.1",
+    "@trezor/transport": "1.5.4-beta.1",
+    "@trezor/type-utils": "1.1.9",
+    "@trezor/utils": "9.4.4-beta.1",
+    "@trezor/utxo-lib": "2.4.4-beta.1",
     "blakejs": "^1.2.1",
     "bs58": "^6.0.0",
     "bs58check": "^4.0.0",
@@ -107,6 +107,7 @@
     "@trezor/trezor-user-env-link": "1.0.2",
     "@types/jws": "^3.2.10",
     "@types/karma": "^6.3.9",
+    "@types/node-fetch": "^2.6.12",
     "babel-loader": "^10.0.0",
     "jest": "29.7.0",
     "karma": "^6.4.4",