matterbridge 3.4.7 → 3.5.0-dev-20260113-96c82db

package/dist/utils/error.js

@@ -1,49 +1,8 @@
-/**
- * This file contains the error functions.
- *
- * @file error.ts
- * @author Luca Liguori
- * @created 2025-07-17
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { inspect } from 'node:util';
 import { RESET } from 'node-ansi-logger';
-/**
- * Logs an error message using the provided AnsiLogger instance.
- *
- * @param {AnsiLogger} log - The AnsiLogger instance to use for logging.
- * @param {string} message - The error message to log.
- * @param {unknown} error - The error object or value to log. If it's an Error instance,
- *                          its message and stack trace will be included in the log.
- */
 export function logError(log, message, error) {
     log.error(`${message}: ${error instanceof Error ? error.message + ' \nStack: \n' + error.stack : error}`);
 }
-/**
- * Logs an error message using the provided AnsiLogger instance with detailed inspection.
- * Uses util.inspect to get a detailed view of the error with a stack depth of 10 levels.
- * If the error is an Error instance, it also includes the error message.
- *
- * @param {AnsiLogger} log - The AnsiLogger instance to use for logging.
- * @param {string} message - The error message to log.
- * @param {unknown} error - The error object or value to log. Will be inspected with depth 10.
- * @returns {string} - The full logged message.
- */
 export function inspectError(log, message, error) {
     const errorMessage = error instanceof Error ? `${error.message} \n` : '';
     const inspectedError = inspect(error, { depth: 10, colors: true, showHidden: false });
@@ -51,4 +10,3 @@ export function inspectError(log, message, error) {
     log.error(fullMessage);
     return fullMessage;
 }
-//# sourceMappingURL=error.js.map

package/dist/utils/export.d.ts

@@ -10,4 +10,3 @@ export * from './createZip.js';
 export * from './wait.js';
 export * from './hex.js';
 export * from './error.js';
-//# sourceMappingURL=export.d.ts.map

package/dist/utils/export.js

@@ -10,4 +10,3 @@ export * from './createZip.js';
 export * from './wait.js';
 export * from './hex.js';
 export * from './error.js';
-//# sourceMappingURL=export.js.map

package/dist/utils/format.d.ts

@@ -1,53 +1,4 @@
-/**
- * @description This file contains the format functions.
- * @file format.ts
- * @author Luca Liguori
- * @created 2025-10-20
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Format a timestamp into a human-readable string.
- *
- * @param {number} timestamp - The timestamp in milliseconds since the Unix epoch.
- * @returns {string} - The formatted timestamp.
- */
 export declare function formatTimeStamp(timestamp: number): string;
-/**
- * Format a percentage into a human-readable string.
- *
- * @param {number} percent - The percentage value.
- * @param {number} digits - The number of decimal places.
- * @returns {string} - The formatted percentage.
- */
 export declare function formatPercent(percent: number, digits?: number): string;
-/**
- * Format bytes into a human-readable string.
- *
- * @param {number} bytes - The number of bytes.
- * @param {number} digits - The number of decimal places.
- * @returns {string} - The formatted byte string.
- */
 export declare function formatBytes(bytes: number, digits?: number): string;
-/**
- * Function to format system uptime with only the most significant unit
- *
- * @param {number} seconds - The number of seconds to format
- * @returns {string} The formatted uptime string
- */
 export declare function formatUptime(seconds: number): string;
-//# sourceMappingURL=format.d.ts.map

package/dist/utils/format.js

@@ -1,51 +1,9 @@
-/**
- * @description This file contains the format functions.
- * @file format.ts
- * @author Luca Liguori
- * @created 2025-10-20
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Format a timestamp into a human-readable string.
- *
- * @param {number} timestamp - The timestamp in milliseconds since the Unix epoch.
- * @returns {string} - The formatted timestamp.
- */
 export function formatTimeStamp(timestamp) {
     return `${new Date(timestamp).toLocaleString()}`;
 }
-/**
- * Format a percentage into a human-readable string.
- *
- * @param {number} percent - The percentage value.
- * @param {number} digits - The number of decimal places.
- * @returns {string} - The formatted percentage.
- */
 export function formatPercent(percent, digits = 2) {
     return `${percent.toFixed(digits)} %`;
 }
-/**
- * Format bytes into a human-readable string.
- *
- * @param {number} bytes - The number of bytes.
- * @param {number} digits - The number of decimal places.
- * @returns {string} - The formatted byte string.
- */
 export function formatBytes(bytes, digits = 2) {
     if (bytes === 0)
         return `${bytes.toFixed(digits)} B`;
@@ -54,12 +12,6 @@ export function formatBytes(bytes, digits = 2) {
     const value = bytes / Math.pow(1024, idx);
     return `${value.toFixed(digits)} ${units[idx]}`;
 }
-/**
- * Function to format system uptime with only the most significant unit
- *
- * @param {number} seconds - The number of seconds to format
- * @returns {string} The formatted uptime string
- */
 export function formatUptime(seconds) {
     if (seconds >= 86400) {
         const days = Math.floor(seconds / 86400);
@@ -75,4 +27,3 @@ export function formatUptime(seconds) {
     }
     return `${seconds} second${seconds !== 1 ? 's' : ''}`;
 }
-//# sourceMappingURL=format.js.map

package/dist/utils/hex.d.ts

@@ -1,89 +1,4 @@
-/**
- * This file contains the hex functions.
- *
- * @file hex.ts
- * @author Luca Liguori
- * @created 2025-05-06
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Converts an ArrayBuffer or Uint8Array to a hexadecimal string.
- *
- * Accepts any {ArrayBufferLike} input: a raw ArrayBuffer (binary data storage) or
- * a Uint8Array (TypedArray view over an ArrayBuffer). While an ArrayBuffer holds
- * the raw memory, a Uint8Array is a typed view into that memory, letting you access
- * its bytes directly. This function normalizes both by creating a Uint8Array view
- * before conversion.
- *
- * @param {ArrayBufferLike} buffer - The buffer or typed-array view to convert.
- * @returns {string} A lowercase hex string representation of the buffer's bytes.
- *
- * @throws {TypeError} If the input is not an ArrayBuffer or ArrayBufferView.
- */
 export declare function bufferToHex(buffer: ArrayBufferLike): string;
-/**
- * Converts a hexadecimal string to a Uint8Array.
- *
- * @param {string} hex - The hex string to convert. Can include uppercase or lowercase characters.
- * @returns {Uint8Array} A Uint8Array representing the corresponding binary data.
- *
- * @throws {TypeError} If the input is not a string.
- * @throws {Error} If the input length is odd or contains non-hex characters.
- */
 export declare function hexToBuffer(hex: string): Uint8Array;
-/**
- * Converts a PEM (Privacy-Enhanced Mail) formatted string to a Uint8Array.
- *
- * PEM format is a base64-encoded format commonly used for cryptographic keys and certificates,
- * wrapped with header and footer lines like "-----BEGIN CERTIFICATE-----" and "-----END CERTIFICATE-----".
- * This function extracts the base64 content and converts it to binary data using Node.js Buffer API.
- *
- * @param {string} pem - The PEM formatted string to convert.
- * @param {boolean} validate - Whether to validate the PEM content using Node.js crypto module. Default is false.
- * @returns {Uint8Array} A Uint8Array representing the decoded binary data.
- *
- * @throws {TypeError} If the input is not a string.
- * @throws {Error} If the PEM format is invalid, contains invalid base64 characters, or validation fails.
- */
 export declare function pemToBuffer(pem: string, validate?: boolean): Uint8Array;
-/**
- * Extracts the raw 32-byte private key scalar from an EC private key PEM.
- *
- * This function parses an EC private key in PEM format and extracts the raw
- * 32-byte private scalar (the "d" value) used in elliptic curve cryptography.
- * This is the actual secret key material.
- *
- * @param {string} pemPrivateKey - The EC private key in PEM format
- * @returns {Uint8Array} The raw 32-byte private key scalar
- * @throws {Error} If the input is not a valid EC private key PEM
- *
- * @example
- * ```typescript
- * const pemKey = `-----BEGIN EC PRIVATE KEY-----
- * MHcCAQEEIFBxqFkUxMoN2JkUXLFeiZnLNUpftjLi0sKMbZ6uajHXoAoGCCqGSM49
- * AwEHoUQDQgAEcJ3eH/rG3zf9WmqMjh5eBSkeXz3Cb4Fig1rTosfHmgyjx/WnLPEe
- * BF4SHvLo0G2COJEHa/VDE5EiKWO9ZR6AOQ==
- * -----END EC PRIVATE KEY-----`;
- *
- * const rawKey = extractPrivateKeyRaw(pemKey);
- * console.log(rawKey.length); // 32
- * console.log(bufferToHex(rawKey)); // hex representation of the private scalar
- * ```
- */
 export declare function extractPrivateKeyRaw(pemPrivateKey: string): Uint8Array;
-//# sourceMappingURL=hex.d.ts.map

package/dist/utils/hex.js

@@ -1,114 +1,39 @@
-/**
- * This file contains the hex functions.
- *
- * @file hex.ts
- * @author Luca Liguori
- * @created 2025-05-06
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import { createPublicKey, createPrivateKey, X509Certificate } from 'node:crypto';
-/**
- * Converts an ArrayBuffer or Uint8Array to a hexadecimal string.
- *
- * Accepts any {ArrayBufferLike} input: a raw ArrayBuffer (binary data storage) or
- * a Uint8Array (TypedArray view over an ArrayBuffer). While an ArrayBuffer holds
- * the raw memory, a Uint8Array is a typed view into that memory, letting you access
- * its bytes directly. This function normalizes both by creating a Uint8Array view
- * before conversion.
- *
- * @param {ArrayBufferLike} buffer - The buffer or typed-array view to convert.
- * @returns {string} A lowercase hex string representation of the buffer's bytes.
- *
- * @throws {TypeError} If the input is not an ArrayBuffer or ArrayBufferView.
- */
 export function bufferToHex(buffer) {
-    // Check if the input is an ArrayBuffer or ArrayBufferView
     if (!(buffer instanceof ArrayBuffer || ArrayBuffer.isView(buffer))) {
         throw new TypeError('Expected input to be an ArrayBuffer or ArrayBufferView');
     }
-    // Create a Uint8Array view over the buffer
     const bytes = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-    // Convert each byte to 2-digit hex
     return Array.from(bytes)
         .map((byte) => byte.toString(16).padStart(2, '0'))
         .join('');
 }
-/**
- * Converts a hexadecimal string to a Uint8Array.
- *
- * @param {string} hex - The hex string to convert. Can include uppercase or lowercase characters.
- * @returns {Uint8Array} A Uint8Array representing the corresponding binary data.
- *
- * @throws {TypeError} If the input is not a string.
- * @throws {Error} If the input length is odd or contains non-hex characters.
- */
 export function hexToBuffer(hex) {
-    // Ensure the input is a string
     if (typeof hex !== 'string') {
         throw new TypeError('Expected a string for hex input');
     }
-    // Trim any whitespace from the input string
     const cleaned = hex.trim();
-    // Check if the length of the hex string is even
     if (cleaned.length % 2 !== 0) {
         throw new Error('Invalid hex string length, must be even');
     }
-    // Validate that the string contains only valid hex characters
     if (!/^[0-9a-fA-F]*$/.test(cleaned)) {
         throw new Error('Invalid hex string, contains non-hex characters');
     }
-    // Calculate the length of the resulting Uint8Array
     const length = cleaned.length / 2;
-    // Create a Uint8Array to hold the binary data
     const result = new Uint8Array(length);
-    // Convert each pair of hex characters into a byte
     for (let i = 0; i < length; i++) {
         result[i] = parseInt(cleaned.substr(i * 2, 2), 16);
     }
-    // Return the resulting Uint8Array
     return result;
 }
-/**
- * Converts a PEM (Privacy-Enhanced Mail) formatted string to a Uint8Array.
- *
- * PEM format is a base64-encoded format commonly used for cryptographic keys and certificates,
- * wrapped with header and footer lines like "-----BEGIN CERTIFICATE-----" and "-----END CERTIFICATE-----".
- * This function extracts the base64 content and converts it to binary data using Node.js Buffer API.
- *
- * @param {string} pem - The PEM formatted string to convert.
- * @param {boolean} validate - Whether to validate the PEM content using Node.js crypto module. Default is false.
- * @returns {Uint8Array} A Uint8Array representing the decoded binary data.
- *
- * @throws {TypeError} If the input is not a string.
- * @throws {Error} If the PEM format is invalid, contains invalid base64 characters, or validation fails.
- */
 export function pemToBuffer(pem, validate = false) {
-    // Ensure the input is a string
     if (typeof pem !== 'string') {
         throw new TypeError('Expected a string for PEM input');
     }
-    // Trim whitespace from the input
     const cleaned = pem.trim();
-    // Check if the string appears to be in PEM format
     if (!cleaned.includes('-----BEGIN') || !cleaned.includes('-----END')) {
         throw new Error('Invalid PEM format: missing BEGIN/END markers');
     }
-    // Extract the base64 content between the header and footer
     const lines = cleaned.split('\n');
     const base64Lines = [];
     let inContent = false;
@@ -129,114 +54,65 @@ export function pemToBuffer(pem, validate = false) {
     if (base64Lines.length === 0) {
         throw new Error('Invalid PEM format: no content found between BEGIN/END markers');
     }
-    // Join all base64 lines together
     const base64String = base64Lines.join('');
-    // Validate base64 string format
     if (!/^[A-Za-z0-9+/]*={0,2}$/.test(base64String)) {
         throw new Error('Invalid PEM format: contains invalid base64 characters');
     }
     try {
-        // Use Node.js Buffer API instead of legacy atob()
         const buffer = Buffer.from(base64String, 'base64');
-        // Convert Buffer to Uint8Array
         const result = new Uint8Array(buffer);
-        // Validate PEM content using Node.js crypto module if requested
         if (validate) {
             try {
-                // Determine PEM type from the header and validate accordingly
                 const pemType = cleaned.match(/-----BEGIN\s+([^-]+)-----/)?.[1]?.trim();
                 if (pemType?.includes('CERTIFICATE')) {
-                    // Use X509Certificate for robust certificate validation
                     const cert = new X509Certificate(pem);
-                    // Check validity period
                     if (cert.validFrom && cert.validTo) {
                         const now = Date.now();
                         const from = Date.parse(cert.validFrom);
                         const to = Date.parse(cert.validTo);
-                        // istanbul ignore next if
                         if (now < from || now > to) {
                             throw new Error('Certificate is not currently valid');
                         }
                     }
-                    // Check subject/issuer fields
-                    // istanbul ignore next if
                     if (!cert.subject || !cert.issuer) {
                         throw new Error('Certificate missing subject or issuer');
                     }
-                    // Optionally check signature (not possible without CA chain)
                 }
                 else if (pemType?.includes('PRIVATE KEY')) {
-                    // For private keys, try to create a private key
                     createPrivateKey({ key: pem, format: 'pem' });
                 }
                 else if (pemType?.includes('PUBLIC KEY')) {
-                    // For public keys, try to create a public key
                     createPublicKey({ key: pem, format: 'pem' });
                 }
-                // If no specific type is detected, skip validation
             }
             catch (validationError) {
-                // istanbul ignore next
                 throw new Error(`PEM validation failed: ${validationError instanceof Error ? validationError.message : String(validationError)}`);
             }
         }
         return result;
     }
     catch (error) {
-        // istanbul ignore next
         throw new Error(`Failed to decode base64 content: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-/**
- * Extracts the raw 32-byte private key scalar from an EC private key PEM.
- *
- * This function parses an EC private key in PEM format and extracts the raw
- * 32-byte private scalar (the "d" value) used in elliptic curve cryptography.
- * This is the actual secret key material.
- *
- * @param {string} pemPrivateKey - The EC private key in PEM format
- * @returns {Uint8Array} The raw 32-byte private key scalar
- * @throws {Error} If the input is not a valid EC private key PEM
- *
- * @example
- * ```typescript
- * const pemKey = `-----BEGIN EC PRIVATE KEY-----
- * MHcCAQEEIFBxqFkUxMoN2JkUXLFeiZnLNUpftjLi0sKMbZ6uajHXoAoGCCqGSM49
- * AwEHoUQDQgAEcJ3eH/rG3zf9WmqMjh5eBSkeXz3Cb4Fig1rTosfHmgyjx/WnLPEe
- * BF4SHvLo0G2COJEHa/VDE5EiKWO9ZR6AOQ==
- * -----END EC PRIVATE KEY-----`;
- *
- * const rawKey = extractPrivateKeyRaw(pemKey);
- * console.log(rawKey.length); // 32
- * console.log(bufferToHex(rawKey)); // hex representation of the private scalar
- * ```
- */
 export function extractPrivateKeyRaw(pemPrivateKey) {
     if (typeof pemPrivateKey !== 'string') {
         throw new TypeError('Expected a string for PEM private key input');
     }
-    // Extract the private key block
     const keyBlock = /-----BEGIN (?:EC )?PRIVATE KEY-----[^-]+-----END (?:EC )?PRIVATE KEY-----/s.exec(pemPrivateKey);
     if (!keyBlock) {
         throw new Error('No EC PRIVATE KEY block found in the supplied PEM');
     }
     try {
-        // Create a private key object
         const privateKey = createPrivateKey(keyBlock[0]);
-        // Export as PKCS#8 DER format
         const pkcs8Der = privateKey.export({ format: 'der', type: 'pkcs8' });
-        // For P-256 curves, the private scalar is the last 32 bytes of the PKCS#8 DER
-        // istanbul ignore next
         if (pkcs8Der.length < 32) {
             throw new Error('Invalid private key: DER data too short');
         }
-        // Extract the last 32 bytes which contain the raw private scalar
         const rawPrivateKey = pkcs8Der.subarray(pkcs8Der.length - 32);
         return new Uint8Array(rawPrivateKey);
     }
     catch (error) {
-        // istanbul ignore next
         throw new Error(`Failed to extract private key: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-//# sourceMappingURL=hex.js.map

package/dist/utils/inspector.d.ts

@@ -1,39 +1,10 @@
-/**
- * This file contains the Inspector class.
- *
- * @file inspector.ts
- * @author Luca Liguori
- * @created 2025-10-12
- * @version 1.0.0
- * @license Apache-2.0
- *
- * Copyright 2025, 2026, 2027 Luca Liguori.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
 import EventEmitter from 'node:events';
 interface InspectorEvents {
-    /** Start the inspector */
     start: [];
-    /** Stop the inspector */
     stop: [];
-    /** Take a heap snapshot */
     snapshot: [];
-    /** Heap snapshot done */
     snapshot_done: [];
-    /** Run garbage collector */
     gc: [type?: 'major' | 'minor', execution?: 'sync' | 'async'];
-    /** Garbage collection done */
     gc_done: [type: 'major' | 'minor', execution: 'sync' | 'async'];
 }
 export declare class Inspector extends EventEmitter<InspectorEvents> {
@@ -45,43 +16,9 @@ export declare class Inspector extends EventEmitter<InspectorEvents> {
     private snapshotInProgress;
     private log;
     constructor(name?: string, debug?: boolean, verbose?: boolean);
-    /**
-     * Starts the inspector for heap sampling.
-     *
-     * This function is called when the -inspect parameter is passed to matterbridge.
-     *
-     * The -snapshotinterval parameter can be used to set the heap snapshot interval. Default is undefined. Minimum is 30000 ms.
-     * The snapshot is saved in the heap_profiles directory that is created in the current working directory.
-     * The snapshot can be analyzed using vscode or Chrome DevTools or other tools that support heap snapshots.
-     */
     start(): Promise<void>;
-    /**
-     * Stops the heap sampling and saves the profile to a file in the heap_profiles directory.
-     * This function is called when the inspector is stopped.
-     */
     stop(): Promise<void>;
-    /**
-     * Takes a heap snapshot and saves it to the file name 'heap_snapshots/<timestamp>.heapsnapshot'.
-     * If triggers a full garbage collection before and after taking the snapshot to reduce noise.
-     *
-     * This function is called periodically based on the -snapshotinterval parameter.
-     * The -snapshotinterval parameter must at least 30000 ms.
-     * The snapshot is saved in the heap_snapshots directory that is created in the current working directory.
-     * The snapshot can be analyzed using vscode or Chrome DevTools or other tools that support heap snapshots.
-     */
     takeHeapSnapshot(): Promise<void>;
-    /**
-     * Manually trigger garbage collection to free memory (if exposed with --expose-gc)
-     *
-     * @param {'major' | 'minor'} type - The type of garbage collection to perform ('major' or 'minor'). Default is 'major'.
-     * @param {'sync' | 'async'} execution - The execution mode of garbage collection ('sync' or 'async'). Default is 'async'.
-     *
-     * @remarks
-     * - major collection refers to old-generation mark-sweep/mark-compact cycles.
-     * - minor collection refers to young-generation collections (scavenges).
-     * - sync execution blocks the main thread until GC is complete, which can cause pauses.
-     */
     runGarbageCollector(type?: 'major' | 'minor', execution?: 'sync' | 'async'): void;
 }
 export {};
-//# sourceMappingURL=inspector.d.ts.map