iobroker.javascript 8.9.2 → 9.0.1

package/{lib → build-backend/lib}/debugger.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createRepl;
 /*
  * Copyright Node.js contributors. All rights reserved.
  *
@@ -19,16 +22,13 @@
  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  * IN THE SOFTWARE.
  */
-'use strict';
-// const FS = require('fs');
-const Path = require('node:path');
-const Repl = require('repl');
-const util = require('node:util');
-const vm = require('vm');
-const fileURLToPath = require('node:url').fileURLToPath;
-
-const debuglog = util.debuglog('inspect');
-
+const node_path_1 = require("node:path");
+const repl_1 = require("repl");
+const node_util_1 = require("node:util");
+const node_vm_1 = require("node:vm");
+const node_url_1 = require("node:url");
+const node_module_1 = require("node:module");
+const debuglog = (0, node_util_1.debuglog)('inspect');
 /*const SHORTCUTS = {
     cont: 'c',
     next: 'n',
@@ -78,78 +78,66 @@ profiles[n].save(filepath = 'node.cpuprofile')
 takeHeapSnapshot(filepath = 'node.heapsnapshot')
                       Take a heap snapshot and save to disk as JSON.
 `.trim();*/
-
 const FUNCTION_NAME_PATTERN = /^(?:function\*? )?([^(\s]+)\(/;
 function extractFunctionName(description) {
-    const fnNameMatch = description.match(FUNCTION_NAME_PATTERN);
+    const fnNameMatch = description?.match(FUNCTION_NAME_PATTERN);
     return fnNameMatch ? `: ${fnNameMatch[1]}` : '';
 }
-
-const PUBLIC_BUILTINS = require('module').builtinModules;
-const NATIVES = PUBLIC_BUILTINS ? process.binding('natives') : {};
+// process.binding is a method available on the process object, which allows you to load internal modules written in C++
+// @ts-expect-error binding is internal function
+const NATIVES = node_module_1.builtinModules ? process.binding('natives') : {};
 function isNativeUrl(url) {
     url = url.replace(/\.js$/, '');
-    if (PUBLIC_BUILTINS) {
-        if (url.startsWith('internal/') || PUBLIC_BUILTINS.includes(url))
+    if (node_module_1.builtinModules) {
+        if (url.startsWith('internal/') || node_module_1.builtinModules.includes(url)) {
             return true;
+        }
     }
-
     return url in NATIVES || url === 'bootstrap_node';
 }
-
 function getRelativePath(filenameOrURL) {
-    const dir = Path.join(Path.resolve(), 'x').slice(0, -1);
-
-    const filename = filenameOrURL.startsWith('file://') ?
-        fileURLToPath(filenameOrURL) : filenameOrURL;
-
-    // Change path to relative, if possible
+    const dir = (0, node_path_1.join)((0, node_path_1.resolve)(), 'x').slice(0, -1);
+    const filename = filenameOrURL.startsWith('file://') ? (0, node_url_1.fileURLToPath)(filenameOrURL) : filenameOrURL;
+    // Change a path to relative, if possible
     if (filename.indexOf(dir) === 0) {
         return filename.slice(dir.length);
     }
     return filename;
 }
-
 function toCallback(promise, callback) {
     function forward(...args) {
         process.nextTick(() => callback(...args));
     }
     promise.then(forward.bind(null, null), forward);
 }
-
 // Adds spaces and prefix to number
 // maxN is a maximum number we should have space for
 function leftPad(n, prefix, maxN) {
     const s = n.toString();
     const nchars = Math.max(2, String(maxN).length) + 1;
     const nspaces = nchars - s.length - 1;
-
     return prefix + ' '.repeat(nspaces) + s;
 }
-
 function markSourceColumn(sourceText, position, useColors) {
     if (!sourceText) {
         return '';
     }
-
     const head = sourceText.slice(0, position);
     let tail = sourceText.slice(position);
-
     // Colorize char if stdout supports colours
     if (useColors) {
         tail = tail.replace(/(.+?)([^\w]|$)/, '\u001b[32m$1\u001b[39m$2');
     }
-
     // Return source line with coloured char at `position`
     return [head, tail].join('');
 }
-
 function extractErrorMessage(stack) {
-    if (!stack) return '<unknown>';
+    if (!stack) {
+        return '<unknown>';
+    }
     const m = stack.match(/^\w+: ([^\n]+)/);
     return m ? m[1] : stack;
 }
-
 function convertResultToError(result) {
     const { className, description } = result;
     const err = new Error(extractErrorMessage(description));
@@ -157,37 +145,41 @@ function convertResultToError(result) {
     Object.defineProperty(err, 'name', { value: className });
     return err;
 }
-
 class RemoteObject {
+    type;
+    subtype;
+    className;
+    value;
+    unserializableValue;
+    description;
+    objectId;
+    preview;
+    customPreview;
     constructor(attributes) {
+        this.type = 'undefined';
         Object.assign(this, attributes);
         if (this.type === 'number') {
-            this.value =
-                this.unserializableValue ? +this.unserializableValue : +this.value;
+            this.value = this.unserializableValue ? +this.unserializableValue : +this.value;
         }
     }
-
-    [util.inspect.custom](depth, opts) {
+    [node_util_1.inspect.custom](_depth, opts) {
         function formatProperty(prop) {
             switch (prop.type) {
                 case 'string':
                 case 'undefined':
-                    return util.inspect(prop.value, opts);
-
+                    return (0, node_util_1.inspect)(prop.value, opts);
                 case 'number':
                 case 'boolean':
                     return opts.stylize(prop.value, prop.type);
-
                 case 'object':
                 case 'symbol':
                     if (prop.subtype === 'date') {
-                        return util.inspect(new Date(prop.value), opts);
+                        return (0, node_util_1.inspect)(new Date(prop.value), opts);
                     }
                     if (prop.subtype === 'array') {
                         return opts.stylize(prop.value, 'special');
                     }
                     return opts.stylize(prop.value, prop.subtype || 'special');
-
                 default:
                     return prop.value;
             }
@@ -197,87 +189,99 @@ class RemoteObject {
             case 'number':
             case 'string':
             case 'undefined':
-                return util.inspect(this.value, opts);
-
+                return (0, node_util_1.inspect)(this.value, opts);
             case 'symbol':
                 return opts.stylize(this.description, 'special');
-
             case 'function': {
                 const fnName = extractFunctionName(this.description);
                 const formatted = `[${this.className}${fnName}]`;
                 return opts.stylize(formatted, 'special');
             }
-
             case 'object':
                 switch (this.subtype) {
                     case 'date':
-                        return util.inspect(new Date(this.description), opts);
-
+                        return (0, node_util_1.inspect)(new Date(this.description), opts);
                     case 'null':
-                        return util.inspect(null, opts);
-
+                        return (0, node_util_1.inspect)(null, opts);
                     case 'regexp':
                         return opts.stylize(this.description, 'regexp');
-
                     default:
                         break;
                 }
                 if (this.preview) {
-                    const props = this.preview.properties
-                        .map((prop, idx) => {
-                            const value = formatProperty(prop);
-                            if (prop.name === `${idx}`) return value;
-                            return `${prop.name}: ${value}`;
-                        });
+                    const props = this.preview.properties.map((prop, idx) => {
+                        const value = formatProperty(prop);
+                        if (prop.name === `${idx}`) {
+                            return value;
+                        }
+                        return `${prop.name}: ${value}`;
+                    });
                     if (this.preview.overflow) {
                         props.push('...');
                     }
                     const singleLine = props.join(', ');
-                    const propString =
-                        singleLine.length > 60 ? props.join(',\n  ') : singleLine;
-
-                    return this.subtype === 'array' ?
-                        `[ ${propString} ]` : `{ ${propString} }`;
+                    const propString = singleLine.length > 60 ? props.join(',\n  ') : singleLine;
+                    return this.subtype === 'array' ? `[ ${propString} ]` : `{ ${propString} }`;
                 }
-                return this.description;
-
+                return this.description || '';
             default:
-                return this.description;
+                return this.description || '';
         }
     }
-
     static fromEvalResult({ result, wasThrown }) {
-        if (wasThrown) return convertResultToError(result);
+        if (wasThrown) {
+            return convertResultToError(result);
+        }
         return new RemoteObject(result);
     }
 }
-
 class ScopeSnapshot {
+    /**
+     * Scope type.
+     */
+    type;
+    /**
+     * Object representing the scope. For <code>global</code> and <code>with</code> scopes it represents the actual object; for the rest of the scopes, it is artificial transient object enumerating scope variables as its properties.
+     */
+    object;
+    name;
+    /**
+     * Location in the source code where scope starts
+     */
+    startLocation;
+    /**
+     * Location in the source code where scope ends
+     */
+    endLocation;
+    properties;
+    completionGroup;
     constructor(scope, properties) {
+        this.type = scope.type;
+        this.object = scope.object;
         Object.assign(this, scope);
-        this.properties = new Map(properties.map((prop) => {
+        this.properties = new Map(properties.map(prop => {
             const value = new RemoteObject(prop.value);
             return [prop.name, value];
         }));
-        this.completionGroup = properties.map((prop) => prop.name);
+        this.completionGroup = properties.map(prop => prop.name);
     }
-
-    [util.inspect.custom](depth, opts) {
+    [node_util_1.inspect.custom](_depth, opts) {
         const type = `${this.type[0].toUpperCase()}${this.type.slice(1)}`;
         const name = this.name ? `<${this.name}>` : '';
         const prefix = `${type}${name} `;
-        return util.inspect(this.properties, opts)
-            .replace(/^Map /, prefix);
+        return (0, node_util_1.inspect)(this.properties, opts).replace(/^Map /, prefix);
     }
 }
-
-function copyOwnProperties(target, source) {
-    Object.getOwnPropertyNames(source).forEach((prop) => {
+/*
+function copyOwnProperties(target: any, source: any): void {
+    Object.getOwnPropertyNames(source).forEach(prop => {
         const descriptor = Object.getOwnPropertyDescriptor(source, prop);
-        Object.defineProperty(target, prop, descriptor);
+        if (descriptor) {
+            Object.defineProperty(target, prop, descriptor);
+        }
     });
 }
-/*
+
 function aliasProperties(target, mapping) {
     Object.keys(mapping).forEach((key) => {
         const descriptor = Object.getOwnPropertyDescriptor(target, key);
@@ -287,77 +291,71 @@ function aliasProperties(target, mapping) {
 */
 function createRepl(inspector) {
     const { Debugger, /*HeapProfiler, Profiler,*/ Runtime } = inspector;
-
-    let repl; // eslint-disable-line prefer-const
-
+    let repl;
     // Things we want to keep around
     // const history = { control: [], debug: [] };
     // const watchedExpressions = [];
     // const knownBreakpoints = [];
     // let pauseOnExceptionState = 'none';
     let lastCommand;
-
     // Things we need to reset when the app restarts
-    let knownScripts;
+    let knownScripts = {};
     let currentBacktrace;
     let selectedFrame;
     let exitDebugRepl;
-
     function resetOnStart() {
         knownScripts = {};
-        currentBacktrace = null;
-        selectedFrame = null;
-
-        if (exitDebugRepl) exitDebugRepl();
-        exitDebugRepl = null;
+        currentBacktrace = undefined;
+        selectedFrame = undefined;
+        if (exitDebugRepl) {
+            exitDebugRepl();
+        }
+        exitDebugRepl = undefined;
     }
     resetOnStart();
-
     const INSPECT_OPTIONS = { colors: inspector.stdout.isTTY };
     function inspect(value) {
-        return util.inspect(value, INSPECT_OPTIONS);
+        return (0, node_util_1.inspect)(value, INSPECT_OPTIONS);
     }
-
     function print(value, oneline = false) {
         const text = typeof value === 'string' ? value : inspect(value);
         return inspector.print(text, oneline);
     }
-
     function getCurrentLocation() {
         if (!selectedFrame) {
             throw new Error('Requires execution to be paused');
         }
         return selectedFrame.location;
     }
-
     function isCurrentScript(script) {
-        return selectedFrame && getCurrentLocation().scriptId === script.scriptId;
+        return !!selectedFrame && getCurrentLocation().scriptId === script.scriptId;
     }
-
     function formatScripts(displayNatives = false) {
         function isVisible(script) {
-            if (displayNatives) return true;
+            if (displayNatives) {
+                return true;
+            }
             return !script.isNative || isCurrentScript(script);
         }
-
         return Object.keys(knownScripts)
-            .map((scriptId) => knownScripts[scriptId])
+            .map(scriptId => knownScripts[scriptId])
             .filter(isVisible)
-            .map((script) => {
-                const isCurrent = isCurrentScript(script);
-                const { isNative, url } = script;
-                const name = `${getRelativePath(url)}${isNative ? ' <native>' : ''}`;
-                return `${isCurrent ? '*' : ' '} ${script.scriptId}: ${name}`;
-            })
+            .map(script => {
+            const isCurrent = isCurrentScript(script);
+            const { isNative, url } = script;
+            const name = `${getRelativePath(url)}${isNative ? ' <native>' : ''}`;
+            return `${isCurrent ? '*' : ' '} ${script.scriptId}: ${name}`;
+        })
             .join('\n');
     }
     function listScripts(displayNatives = false) {
         print(formatScripts(displayNatives));
     }
-    listScripts[util.inspect.custom] = function listWithoutInternal() {
+    // @ts-expect-error no idea what this is
+    listScripts[node_util_1.inspect.custom] = function listWithoutInternal() {
         return formatScripts();
     };
-/*
+    /*
     const profiles = [];
     class Profile {
         constructor(data) {
@@ -384,101 +382,137 @@ function createRepl(inspector) {
     }
 */
     class SourceSnippet {
+        scriptSource;
+        /**
+         * Script identifier as reported in the <code>Debugger.scriptParsed</code>.
+         */
+        scriptId;
+        /**
+         * Line number in the script (0-based).
+         */
+        lineNumber;
+        /**
+         * Column number in the script (0-based).
+         */
+        columnNumber;
+        delta;
         constructor(location, delta, scriptSource) {
-            Object.assign(this, location);
+            this.lineNumber = location.lineNumber;
+            this.columnNumber = location.columnNumber || 0;
+            this.scriptId = location.scriptId;
             this.scriptSource = scriptSource;
             this.delta = delta;
+            Object.assign(this, location);
         }
-
-        [util.inspect.custom](depth, options) {
+        [node_util_1.inspect.custom](_depth, options) {
             const { /* scriptId, */ lineNumber, columnNumber, delta, scriptSource } = this;
             const start = Math.max(1, lineNumber - delta + 1);
             const end = lineNumber + delta + 1;
-
             const lines = scriptSource.split('\n');
-            return lines.slice(start - 1, end).map((lineText, offset) => {
+            return lines
+                .slice(start - 1, end)
+                .map((lineText, offset) => {
                 const i = start + offset;
-                const isCurrent = i === (lineNumber + 1);
-
-                const markedLine = isCurrent
-                    ? markSourceColumn(lineText, columnNumber, options.colors)
-                    : lineText;
-
+                const isCurrent = i === lineNumber + 1;
+                const markedLine = isCurrent ? markSourceColumn(lineText, columnNumber, options.colors) : lineText;
                 /*
-                let isBreakpoint = false;
-                knownBreakpoints.forEach(({ location }) => {
-                    if (!location) return;
-                    if (scriptId === location.scriptId &&
-                        i === (location.lineNumber + 1)) {
-                        isBreakpoint = true;
-                    }
-                });
-                */
-
+            let isBreakpoint = false;
+            knownBreakpoints.forEach(({ location }) => {
+                if (!location) return;
+                if (scriptId === location.scriptId &&
+                    i === (location.lineNumber + 1)) {
+                    isBreakpoint = true;
+                }
+            });
+            */
                 let prefixChar = ' ';
                 if (isCurrent) {
                     prefixChar = '>';
                 } /*else if (isBreakpoint) {
-                    prefixChar = '*';
-                }*/
+                prefixChar = '*';
+            }*/
                 return `${leftPad(i, prefixChar, end)} ${markedLine}`;
-            }).join('\n');
+            })
+                .join('\n');
         }
     }
-
     function getSourceSnippet(location, delta = 5) {
         const { scriptId } = location;
-        return Debugger.getScriptSource({ scriptId })
-            .then(({ scriptSource }) =>
-                new SourceSnippet(location, delta, scriptSource));
+        return Debugger.getScriptSource({ scriptId }).then(({ scriptSource }) => new SourceSnippet(location, delta, scriptSource));
     }
-
     class CallFrame {
+        /**
+         * Call frame identifier. This identifier is only valid while the virtual machine is paused.
+         */
+        callFrameId;
+        /**
+         * Name of the JavaScript function called on this call frame.
+         */
+        functionName;
+        /**
+         * Location in the source code.
+         */
+        functionLocation;
+        /**
+         * Location in the source code.
+         */
+        location;
+        /**
+         * JavaScript script name or url.
+         */
+        url;
+        /**
+         * Scope chain for this call frame.
+         */
+        scopeChain;
+        /**
+         * <code>this</code> object for this call frame.
+         */
+        this;
+        /**
+         * The value being returned if the function is at return point.
+         */
+        returnValue;
         constructor(callFrame) {
+            this.functionName = callFrame.functionName;
+            this.url = callFrame.url;
+            this.scopeChain = callFrame.scopeChain;
+            this.this = callFrame.this;
+            this.returnValue = callFrame.returnValue;
+            this.location = callFrame.location;
+            this.callFrameId = callFrame.callFrameId;
             Object.assign(this, callFrame);
         }
-
         loadScopes() {
-            return Promise.all(
-                this.scopeChain
-                    .filter(scope => scope.type !== 'global')
-                    .map(scope => {
-                        const { objectId } = scope.object;
-                        return Runtime.getProperties({
-                            objectId,
-                            generatePreview: true,
-                        })
-                            .then(({ result }) => new ScopeSnapshot(scope, result));
-                    })
-            );
+            return Promise.all(this.scopeChain
+                .filter(scope => scope.type !== 'global')
+                .map(scope => {
+                const { objectId } = scope.object;
+                return Runtime.getProperties({
+                    objectId,
+                    generatePreview: true,
+                }).then(({ result }) => {
+                    return new ScopeSnapshot(scope, result);
+                });
+            }));
         }
-
         list(delta = 5) {
             return getSourceSnippet(this.location, delta);
         }
     }
-
     class Backtrace extends Array {
-        [util.inspect.custom]() {
+        [node_util_1.inspect.custom]() {
             return this.map((callFrame, idx) => {
-                const {
-                    location: { scriptId, lineNumber, columnNumber },
-                    functionName
-                } = callFrame;
+                const { location: { scriptId, lineNumber, columnNumber }, functionName, } = callFrame;
                 const name = functionName || '(anonymous)';
-
                 const script = knownScripts[scriptId];
-                const relativeUrl =
-                    (script && getRelativePath(script.url)) || '<unknown>';
-                const frameLocation =
-                    `${relativeUrl}:${lineNumber + 1}:${columnNumber}`;
-
+                const relativeUrl = (script && getRelativePath(script.url)) || '<unknown>';
+                const frameLocation = `${relativeUrl}:${lineNumber + 1}:${columnNumber}`;
                 return `#${idx} ${name} ${frameLocation}`;
             }).join('\n');
         }
-
         static from(callFrames) {
-            return super.from(Array.from(callFrames).map((callFrame) => {
+            return super.from(Array.from(callFrames).map(callFrame => {
                 if (callFrame instanceof CallFrame) {
                     return callFrame;
                 }
@@ -486,19 +520,20 @@ function createRepl(inspector) {
             }));
         }
     }
-
     function prepareControlCode(input) {
-        if (input === '\n') return lastCommand;
+        if (input === '\n') {
+            return lastCommand;
+        }
         // exec process.title => exec("process.title");
         const match = input.match(/^\s*exec\s+([^\n]*)/);
         if (match) {
             lastCommand = `exec(${JSON.stringify(match[1])})`;
-        } else {
+        }
+        else {
             lastCommand = input;
         }
         return lastCommand;
     }
-
     // function evalInCurrentContext(code) {
     //     // Repl asked for scope variables
     //     if (code === '.scope') {
@@ -524,28 +559,25 @@ function createRepl(inspector) {
     //         generatePreview: true,
     //     }).then(RemoteObject.fromEvalResult);
     // }
-
     function controlEval(input, context, filename, callback) {
         debuglog('eval:', input);
         function returnToCallback(error, result) {
             debuglog('end-eval:', input, error);
             callback(error, result);
         }
-
         try {
             const code = prepareControlCode(input);
-            const result = vm.runInContext(code, context, filename);
-
+            const result = (0, node_vm_1.runInContext)(code, context, filename);
             if (result && typeof result.then === 'function') {
                 toCallback(result, returnToCallback);
                 return;
             }
             returnToCallback(null, result);
-        } catch (e) {
+        }
+        catch (e) {
             returnToCallback(e);
         }
     }
-
     // function debugEval(input, context, filename, callback) {
     //     debuglog('eval:', input);
     //     function returnToCallback(error, result) {
@@ -565,7 +597,6 @@ function createRepl(inspector) {
     //         returnToCallback(e);
     //     }
     // }
-
     /*function formatWatchers(verbose = false) {
         if (!watchedExpressions.length) {
             return Promise.resolve('');
@@ -594,11 +625,9 @@ function createRepl(inspector) {
                 return verbose ? `Watchers:\n${valueList}\n` : valueList;
             });
     }*/
-
     //function watchers(verbose = false) {
     //    return formatWatchers(verbose).then(print);
     //}
-
     // List source code
     // function list(delta = 5) {
     //     return selectedFrame.list(delta)
@@ -607,7 +636,6 @@ function createRepl(inspector) {
     //             throw error;
     //         });
     // }
-
     //function handleBreakpointResolved({ breakpointId, location }) {
     //     const script = knownScripts[location.scriptId];
     //     const scriptUrl = script && script.url;
@@ -625,7 +653,6 @@ function createRepl(inspector) {
     //         knownBreakpoints.push({ breakpointId, location });
     //     }
     //}
-
     // function listBreakpoints() {
     //     if (!knownBreakpoints.length) {
     //         print('No breakpoints yet');
@@ -643,7 +670,6 @@ function createRepl(inspector) {
     //         .join('\n');
     //     print(breaklist);
     // }
-
     // function setBreakpoint(script, line, condition, silent) {
     //     function registerBreakpoint({ breakpointId, actualLocation }) {
     //         handleBreakpointResolved({ breakpointId, location: actualLocation });
@@ -778,53 +804,45 @@ function createRepl(inspector) {
     //         print(`${results.length} breakpoints restored.`);
     //     });
     // }
-
     // function setPauseOnExceptions(state) {
     //     return Debugger.setPauseOnExceptions({ state })
     //         .then(() => {
     //             pauseOnExceptionState = state;
     //         });
     // }
-
-    Debugger.on('paused', ({ callFrames, reason /* , hitBreakpoints */ }) => {
+    Debugger.on('paused', (data) => {
+        const callFrames = data.callFrames;
+        const reason = data.reason;
         if (process.env.NODE_INSPECT_RESUME_ON_START === '1' && reason === 'Break on start') {
             debuglog('Paused on start, but NODE_INSPECT_RESUME_ON_START environment variable is set to 1, resuming');
             inspector.client.callMethod('Debugger.resume');
             return;
         }
-
         // Save execution context's data
         currentBacktrace = Backtrace.from(callFrames);
         selectedFrame = currentBacktrace[0];
         const { scriptId, lineNumber } = selectedFrame.location;
-
         const breakType = reason === 'other' ? 'break' : reason;
         const script = knownScripts[scriptId];
         const scriptUrl = script ? getRelativePath(script.url) : '[unknown]';
-
         const header = `${breakType} in ${scriptUrl}:${lineNumber + 1}`;
-
-        inspector.suspendReplWhile(() =>
-            Promise.all([/*formatWatchers(true), */selectedFrame.list(3)])
-                .then(([/*watcherList, */context]) => {
-                    /*if (watcherList) {
-                        return `${watcherList}\n${inspect(context)}`;
-                    }*/
-                    return inspect(context);
-                }).then((breakContext) => {
-                    print(`${header}\n${breakContext}`);
-                }));
+        void inspector.suspendReplWhile(() => Promise.all([/*formatWatchers(true), */ selectedFrame?.list(3)])
+            .then(([/*watcherList, */ context]) => {
+            /*if (watcherList) {
+                return `${watcherList}\n${inspect(context)}`;
+            }*/
+            return inspect(context);
+        })
+            .then(breakContext => {
+            print(`${header}\n${breakContext}`);
+        }));
     });
-
     function handleResumed() {
-        currentBacktrace = null;
-        selectedFrame = null;
+        currentBacktrace = undefined;
+        selectedFrame = undefined;
     }
-
     Debugger.on('resumed', handleResumed);
-
     //Debugger.on('breakpointResolved', handleBreakpointResolved);
-
     Debugger.on('scriptParsed', (script) => {
         const { scriptId, url } = script;
         if (url) {
@@ -833,7 +851,6 @@ function createRepl(inspector) {
             }, script);
         }
     });
-
     /*Profiler.on('consoleProfileFinished', ({ profile }) => {
         Profile.createAndRegister({ profile });
         print([
@@ -841,17 +858,35 @@ function createRepl(inspector) {
             `Access it with profiles[${profiles.length - 1}]`
         ].join('\n'));
     });*/
-
     function initializeContext(context) {
-        inspector.domainNames.forEach((domain) => {
-            Object.defineProperty(context, domain, {
-                value: inspector[domain],
-                enumerable: true,
-                configurable: true,
-                writeable: false,
-            });
+        Object.defineProperty(context, 'Debugger', {
+            value: inspector.Debugger,
+            enumerable: true,
+            configurable: true,
+            // @ts-expect-error fix later
+            writeable: false,
+        });
+        Object.defineProperty(context, 'HeapProfiler', {
+            value: inspector.HeapProfiler,
+            enumerable: true,
+            configurable: true,
+            // @ts-expect-error fix later
+            writeable: false,
+        });
+        Object.defineProperty(context, 'Profiler', {
+            value: inspector.Profiler,
+            enumerable: true,
+            configurable: true,
+            // @ts-expect-error fix later
+            writeable: false,
+        });
+        Object.defineProperty(context, 'Runtime', {
+            value: inspector.Runtime,
+            enumerable: true,
+            configurable: true,
+            // @ts-expect-error fix later
+            writeable: false,
         });
-
         /*copyOwnProperties(context, {
             get help() {
                 print(HELP);
@@ -1059,7 +1094,6 @@ function createRepl(inspector) {
         });*/
         //aliasProperties(context, SHORTCUTS);
     }
-
     function initAfterStart() {
         const setupTasks = [
             Runtime.enable(),
@@ -1075,15 +1109,13 @@ function createRepl(inspector) {
         ];
         return Promise.all(setupTasks);
     }
-
     return function startRepl() {
-        inspector.client.on('close', () => {
-            resetOnStart();
-        });
+        inspector.client.on('close', () => resetOnStart());
         inspector.client.on('ready', () => {
-            initAfterStart();
+            initAfterStart().catch(err => {
+                print(`Error starting inspector: ${err.message}`);
+            });
         });
-
         const replOptions = {
             prompt: 'debug> ',
             input: inspector.stdin,
@@ -1092,21 +1124,18 @@ function createRepl(inspector) {
             useGlobal: false,
             ignoreUndefined: true,
         };
-
-        repl = Repl.start(replOptions); // eslint-disable-line prefer-const
+        repl = (0, repl_1.start)(replOptions);
         initializeContext(repl.context);
         repl.on('reset', initializeContext);
-
         repl.defineCommand('interrupt', () => {
             // We want this for testing purposes where sending CTRL-C can be tricky.
             repl.emit('SIGINT');
         });
-
         // Init once for the initial connection
-        initAfterStart();
-
+        initAfterStart().catch(err => {
+            print(`Error starting inspector: ${err.message}`);
+        });
         return repl;
     };
 }
-
-module.exports = createRepl;
+//# sourceMappingURL=debugger.js.map