@lvce-editor/static-server 0.85.0 → 0.85.2

package/static/{6759a60 → 400933e}/packages/debug-worker/dist/debugWorkerMain.js

@@ -231,8 +231,8 @@ const getModuleNotFoundError = stderr => {
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    code: ERR_MODULE_NOT_FOUND,
+    message
   };
 };
 const isModuleNotFoundError = stderr => {
@@ -255,14 +255,14 @@ const isUnhelpfulNativeModuleError = stderr => {
 const getNativeModuleErrorMessage = stderr => {
   const message = getMessageCodeBlock(stderr);
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    code: E_INCOMPATIBLE_NATIVE_MODULE,
+    message: `Incompatible native node module: ${message}`
   };
 };
 const getModuleSyntaxError = () => {
   return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
+    message: `ES Modules are not supported in electron`
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -281,8 +281,8 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: actualMessage,
     code: '',
+    message: actualMessage,
     stack: rest
   };
 };
@@ -292,8 +292,8 @@ class IpcError extends VError {
     if (stdout || stderr) {
       // @ts-ignore
       const {
-        message,
         code,
+        message,
         stack
       } = getHelpfulChildProcessError(stdout, stderr);
       const cause = new Error(message);
@@ -354,8 +354,8 @@ const wrap$f = global => {
 };
 const waitForFirstMessage = async port => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   port.addEventListener('message', resolve, {
     once: true
@@ -375,8 +375,8 @@ const listen$6 = async () => {
   const type = firstMessage.params[0];
   if (type === 'message-port') {
     parentIpc.send({
-      jsonrpc: '2.0',
       id: firstMessage.id,
+      jsonrpc: '2.0',
       result: null
     });
     parentIpc.dispose();
@@ -433,8 +433,8 @@ const removeListener = (emitter, type, callback) => {
 };
 const getFirstEvent = (eventEmitter, eventMap) => {
   const {
-    resolve,
-    promise
+    promise,
+    resolve
   } = Promise.withResolvers();
   const listenerMap = Object.create(null);
   const cleanup = value => {
@@ -446,8 +446,8 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   for (const [event, type] of Object.entries(eventMap)) {
     const listener = event => {
       cleanup({
-        type,
-        event
+        event,
+        type
       });
     };
     addListener(eventEmitter, event, listener);
@@ -456,9 +456,9 @@ const getFirstEvent = (eventEmitter, eventMap) => {
   return promise;
 };
 const Message$1$1 = 3;
-const create$5$1 = async ({
-  messagePort,
-  isMessagePortOpen
+const create$5 = async ({
+  isMessagePortOpen,
+  messagePort
 }) => {
   if (!isMessagePort(messagePort)) {
     throw new IpcError('port must be of type MessagePort');
@@ -471,8 +471,8 @@ const create$5$1 = async ({
   });
   messagePort.start();
   const {
-    type,
-    event
+    event,
+    type
   } = await eventPromise;
   if (type !== Message$1$1) {
     throw new IpcError('Failed to wait for ipc message');
@@ -507,61 +507,19 @@ const wrap$5 = messagePort => {
 };
 const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  create: create$5$1,
+  create: create$5,
   signal: signal$1,
   wrap: wrap$5
 };
 
-const Two = '2.0';
-const create$4$1 = (method, params) => {
-  return {
-    jsonrpc: Two,
-    method,
-    params
-  };
-};
+const Two$1 = '2.0';
 const callbacks = Object.create(null);
-const set$7 = (id, fn) => {
-  callbacks[id] = fn;
-};
 const get$2 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$1 = id => {
   delete callbacks[id];
 };
-let id = 0;
-const create$3$1 = () => {
-  return ++id;
-};
-const registerPromise = () => {
-  const id = create$3$1();
-  const {
-    resolve,
-    promise
-  } = Promise.withResolvers();
-  set$7(id, resolve);
-  return {
-    id,
-    promise
-  };
-};
-const create$2$1 = (method, params) => {
-  const {
-    id,
-    promise
-  } = registerPromise();
-  const message = {
-    jsonrpc: Two,
-    method,
-    params,
-    id
-  };
-  return {
-    message,
-    promise
-  };
-};
 class JsonRpcError extends Error {
   constructor(message) {
     super(message);
@@ -712,7 +670,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove(id);
+  remove$1(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -755,9 +713,9 @@ const getErrorProperty = (error, prettyError) => {
     }
   };
 };
-const create$1$1 = (id, error) => {
+const create$1$2 = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error
   };
@@ -766,22 +724,22 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const prettyError = preparePrettyError(error);
   logError(error, prettyError);
   const errorProperty = getErrorProperty(error, prettyError);
-  return create$1$1(id, errorProperty);
+  return create$1$2(id, errorProperty);
 };
-const create$6 = (message, result) => {
+const create$3 = (message, result) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id: message.id,
     result: result ?? null
   };
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$6(message, resultProperty);
+  return create$3(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
-    jsonrpc: Two,
+    jsonrpc: Two$1,
     id,
     error: {
       code: Custom,
@@ -868,29 +826,6 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  if (useSendAndTransfer && ipc.sendAndTransfer) {
-    ipc.sendAndTransfer(message);
-  } else {
-    ipc.send(message);
-  }
-  const responseMessage = await promise;
-  return unwrapJsonRpcResult(responseMessage);
-};
-const send = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$4 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, false);
-};
-const invokeAndTransfer$3 = (ipc, method, ...params) => {
-  return invokeHelper(ipc, method, params, true);
-};
 
 class CommandNotFoundError extends Error {
   constructor(command) {
@@ -913,24 +848,87 @@ const execute = (command, ...args) => {
   return fn(...args);
 };
 
+const Two = '2.0';
+const create$s = (method, params) => {
+  return {
+    jsonrpc: Two,
+    method,
+    params
+  };
+};
+const create$r = (id, method, params) => {
+  const message = {
+    id,
+    jsonrpc: Two,
+    method,
+    params
+  };
+  return message;
+};
+let id = 0;
+const create$q = () => {
+  return ++id;
+};
+
+/* eslint-disable n/no-unsupported-features/es-syntax */
+
+const registerPromise = map => {
+  const id = create$q();
+  const {
+    promise,
+    resolve
+  } = Promise.withResolvers();
+  map[id] = resolve;
+  return {
+    id,
+    promise
+  };
+};
+
+// @ts-ignore
+const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
+  const {
+    id,
+    promise
+  } = registerPromise(callbacks);
+  const message = create$r(id, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
 const createRpc = ipc => {
+  const callbacks = Object.create(null);
+  ipc._resolve = (id, response) => {
+    const fn = callbacks[id];
+    if (!fn) {
+      console.warn(`callback ${id} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks[id];
+  };
   const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks, ipc, method, params, true);
+    },
     // @ts-ignore
     ipc,
     /**
      * @deprecated
      */
     send(method, ...params) {
-      send(ipc, method, ...params);
-    },
-    invoke(method, ...params) {
-      return invoke$4(ipc, method, ...params);
-    },
-    invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer$3(ipc, method, ...params);
-    },
-    async dispose() {
-      await ipc?.dispose();
+      const message = create$s(method, params);
+      ipc.send(message);
     }
   };
   return rpc;
@@ -947,7 +945,7 @@ const logError = () => {
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
   const actualExecute = event?.target?.execute || execute;
-  return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
   if ('addEventListener' in ipc) {
@@ -965,15 +963,16 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
-const create$5 = async ({
+const create$4 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
   const rawIpc = await IpcParentWithMessagePort$1.create({
-    messagePort,
-    isMessagePortOpen: true
+    isMessagePortOpen,
+    messagePort
   });
   const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
@@ -981,8 +980,9 @@ const create$5 = async ({
   messagePort.start();
   return rpc;
 };
-const create$3 = async ({
+const create$2$1 = async ({
   commandMap,
+  isMessagePortOpen,
   send
 }) => {
   const {
@@ -990,16 +990,17 @@ const create$3 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$4({
     commandMap,
+    isMessagePortOpen,
     messagePort: port2
   });
 };
 const TransferMessagePortRpcParent = {
   __proto__: null,
-  create: create$3
+  create: create$2$1
 };
-const create$4 = async ({
+const create$1$1 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1011,7 +1012,7 @@ const create$4 = async ({
 };
 const WebWorkerRpcClient = {
   __proto__: null,
-  create: create$4
+  create: create$1$1
 };
 const createMockRpc = ({
   commandMap
@@ -1026,9 +1027,9 @@ const createMockRpc = ({
     return command(...params);
   };
   const mockRpc = {
+    invocations,
     invoke,
-    invokeAndTransfer: invoke,
-    invocations
+    invokeAndTransfer: invoke
   };
   return mockRpc;
 };
@@ -1538,9 +1539,17 @@ const set$6 = (id, rpc) => {
 const get$1 = id => {
   return rpcs[id];
 };
+const remove = id => {
+  delete rpcs[id];
+};
 
+/* eslint-disable  @typescript-eslint/explicit-function-return-type */
 const create$2 = rpcId => {
   return {
+    async dispose() {
+      const rpc = get$1(rpcId);
+      await rpc.dispose();
+    },
     // @ts-ignore
     invoke(method, ...params) {
       const rpc = get$1(rpcId);
@@ -1553,21 +1562,30 @@ const create$2 = rpcId => {
       // @ts-ignore
       return rpc.invokeAndTransfer(method, ...params);
     },
+    registerMockRpc(commandMap) {
+      const mockRpc = createMockRpc({
+        commandMap
+      });
+      set$6(rpcId, mockRpc);
+      // @ts-ignore
+      mockRpc[Symbol.dispose] = () => {
+        remove(rpcId);
+      };
+      // @ts-ignore
+      return mockRpc;
+    },
     set(rpc) {
       set$6(rpcId, rpc);
-    },
-    async dispose() {
-      const rpc = get$1(rpcId);
-      await rpc.dispose();
     }
   };
 };
 
 const {
+  dispose: dispose$3,
   invoke: invoke$3,
   invokeAndTransfer: invokeAndTransfer$2,
-  set: set$5,
-  dispose: dispose$3
+  registerMockRpc: registerMockRpc$1,
+  set: set$5
 } = create$2(EditorWorker$1);
 const sendMessagePortToExtensionHostWorker$2 = async port => {
   const command = 'HandleMessagePort.handleMessagePort2';
@@ -1584,6 +1602,10 @@ const applyEdit = async (editorUid, changes) => {
   // @ts-ignore
   await invoke$3('Editor.applyEdit2', editorUid, changes);
 };
+const applyDocumentEdits = async (editorUid, changes) => {
+  // @ts-ignore
+  await invoke$3('Editor.applyDocumentEdits', editorUid, changes);
+};
 const applyWorkspaceEdit = async (editorUid, changes) => {
   // @ts-ignore
   await invoke$3('Editor.applyWorkspaceEdit', editorUid, changes);
@@ -1616,6 +1638,9 @@ const getSelections = async editorUid => {
 const getWordAtOffset2 = async editorUid => {
   return invoke$3('Editor.getWordAtOffset2', editorUid);
 };
+const closeFind2 = async editorUid => {
+  return invoke$3('Editor.closeFind2', editorUid);
+};
 const getWordBefore = async (editorUid, rowIndex, columnIndex) => {
   return invoke$3('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
 };
@@ -1634,19 +1659,14 @@ const getProblems = async () => {
   // @ts-ignore
   return invoke$3('Editor.getProblems');
 };
-const registerMockRpc$1 = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$5(mockRpc);
-  return mockRpc;
-};
 
 const EditorWorker = {
   __proto__: null,
   activateByEvent: activateByEvent$2,
+  applyDocumentEdits,
   applyEdit,
   applyWorkspaceEdit,
+  closeFind2,
   closeWidget,
   dispose: dispose$3,
   getLanguageId,
@@ -1668,10 +1688,11 @@ const EditorWorker = {
 };
 
 const {
+  dispose: dispose$2,
   invoke: invoke$2,
   invokeAndTransfer: invokeAndTransfer$1,
-  set: set$4,
-  dispose: dispose$2
+  registerMockRpc,
+  set: set$4
 } = create$2(ExtensionHostWorker);
 const executeReferenceProvider = async (id, offset) => {
   // @ts-ignore
@@ -1685,12 +1706,9 @@ const getRuntimeStatus = async extensionId => {
   // @ts-ignore
   return invoke$2('ExtensionHost.getRuntimeStatus', extensionId);
 };
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$4(mockRpc);
-  return mockRpc;
+const getEnabledOutputProviderIds = async () => {
+  const channels = await invoke$2('Output.getEnabledProviders');
+  return channels;
 };
 
 const ExtensionHost = {
@@ -1698,6 +1716,7 @@ const ExtensionHost = {
   dispose: dispose$2,
   executeFileReferenceProvider,
   executeReferenceProvider,
+  getEnabledOutputProviderIds,
   getRuntimeStatus,
   invoke: invoke$2,
   invokeAndTransfer: invokeAndTransfer$1,
@@ -1708,7 +1727,11 @@ const ExtensionHost = {
 const {
   invoke: invoke$1,
   invokeAndTransfer,
-  set: set$3} = create$2(RendererWorker);
+  set: set$3
+} = create$2(RendererWorker);
+/**
+ * @deprecated
+ */
 const showContextMenu = async (x, y, id, ...args) => {
   return invoke$1('ContextMenu.show', x, y, id, ...args);
 };
@@ -1728,8 +1751,8 @@ const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
 const handleDebugResumed = async params => {
   await invoke$1('Run And Debug.handleResumed', params);
 };
-const activateByEvent$1 = event => {
-  return invoke$1('ExtensionHostManagement.activateByEvent', event);
+const activateByEvent$1 = (event, assetDir, platform) => {
+  return invoke$1('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
 };
 const handleDebugPaused = async params => {
   await invoke$1('Run And Debug.handlePaused', params);
@@ -1830,14 +1853,17 @@ const None$6 = 0;
 const Paused = 1;
 const Default = 2;
 const Unavailable = 3;
+const MissingProvider = 4;
 
 const activateByEvent = event => {
+  // @ts-ignore
   return activateByEvent$1(event);
 };
 
 const {
   invoke,
-  set: set$2} = ExtensionHost;
+  set: set$2
+} = ExtensionHost;
 
 const executeProvider = async ({
   event,
@@ -1959,19 +1985,19 @@ const getDebugUri = (key, scriptId) => {
 const openUri = async (uri, languageId, rowIndex, columnIndex) => {
   const focus = true;
   const options = {
+    columnIndex,
     languageId,
-    rowIndex,
-    columnIndex
+    rowIndex
   };
   await openUri$1(uri, focus, options);
 };
 
 const {
+  dispose: dispose$1,
   get,
+  getKeys,
   set,
-  wrapCommand,
-  dispose: dispose$1,
-  getKeys
+  wrapCommand
 } = create$1();
 
 const getKey = () => {
@@ -1995,9 +2021,9 @@ const openAtPausedLocation = async () => {
     functionLocation
   } = first;
   const {
-    scriptId,
+    columnNumber,
     lineNumber,
-    columnNumber
+    scriptId
   } = functionLocation;
   const uri = getDebugUri(key, scriptId);
   const rowIndex = lineNumber;
@@ -2100,8 +2126,8 @@ const getNewWatchExpressionsAccept = async (debugId, callFrameId, debugState, wa
   }
   const newExpression = {
     expression: editingValue,
-    value: null,
-    isEditing: false
+    isEditing: false,
+    value: null
   };
   const newWatchExpressions1 = watchExpressions.toSpliced(editingIndex, 1, newExpression);
   const newWatchExpressions2 = await getNewWatchExpressions(debugId, callFrameId, debugState, newWatchExpressions1);
@@ -2119,6 +2145,7 @@ const CheckBox$1 = 8;
 const WatchMessage = 9;
 const WatchExpression = 10;
 const InputField = 11;
+const MissingDebugProvider = 12;
 
 const emptyObject = {};
 const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
@@ -2146,6 +2173,8 @@ const Local$1 = 'Local';
 const Module$1 = 'Module';
 const NamedClosure = 'Closure ({PH1})';
 const NoScriptRunning = 'No script running. To enable debugging, start a Node.js script with debugging enabled (e.g. node --inspect your-script.js) and connect to it.';
+const NoDebugProviderFound = 'No debug provider "{PH1}" found.';
+const OpenExtensions = 'Open Extensions';
 const NotPaused = 'Not Paused';
 const Pause = 'Pause';
 const Restart = 'Restart';
@@ -2263,6 +2292,14 @@ const addWatchExpression$1 = () => {
 const noScriptRunning = () => {
   return i18nString(NoScriptRunning);
 };
+const noDebugProviderFound = debugProvider => {
+  return i18nString(NoDebugProviderFound, {
+    PH1: debugProvider
+  });
+};
+const openExtensions$1 = () => {
+  return i18nString(OpenExtensions);
+};
 
 const Scope$2 = 'Scope';
 const CallStack$1 = 'CallStack';
@@ -2294,8 +2331,8 @@ const RefreshWatchExpressions = 'RefreshWatchExpressions';
 const getRunAndDebugVisibleRowsBreakPoints = (state, startIndex, topLevelCount, topLevelIndex) => {
   const {
     breakPointsExpanded,
-    exceptionBreakPoints,
-    breakPointsVisible
+    breakPointsVisible,
+    exceptionBreakPoints
   } = state;
   if (!breakPointsVisible) {
     return [];
@@ -2303,59 +2340,59 @@ const getRunAndDebugVisibleRowsBreakPoints = (state, startIndex, topLevelCount,
   if (breakPointsExpanded) {
     const setSize = 2;
     return [{
-      type: SectionHeading,
-      text: breakPoints(),
+      description: '',
       expanded: true,
-      key: BreakPoints,
-      value: '',
       indent: 0,
-      valueType: '',
-      name: BreakPoints$1,
-      description: '',
       index: startIndex,
+      key: BreakPoints,
+      name: BreakPoints$1,
+      posInset: topLevelIndex + 1,
       setSize: topLevelCount,
-      posInset: topLevelIndex + 1
+      text: breakPoints(),
+      type: SectionHeading,
+      value: '',
+      valueType: ''
     }, {
-      type: CheckBox$1,
-      text: pauseOnExceptions(),
+      description: '',
       expanded: exceptionBreakPoints === All,
-      key: '',
-      value: '',
       indent: 0,
-      valueType: '',
-      name: PauseOnExceptions,
-      description: '',
       index: startIndex + 1,
+      key: '',
+      name: PauseOnExceptions,
+      posInset: 2,
       setSize,
-      posInset: 2
-    }, {
+      text: pauseOnExceptions(),
       type: CheckBox$1,
-      text: pauseOnUncaughtExceptions(),
-      expanded: exceptionBreakPoints === Uncaught,
-      key: '',
       value: '',
-      indent: 0,
-      valueType: '',
-      name: PauseOnUncaughtExceptions,
+      valueType: ''
+    }, {
       description: '',
+      expanded: exceptionBreakPoints === Uncaught,
+      indent: 0,
       index: startIndex + 2,
+      key: '',
+      name: PauseOnUncaughtExceptions,
+      posInset: 3,
       setSize,
-      posInset: 3
+      text: pauseOnUncaughtExceptions(),
+      type: CheckBox$1,
+      value: '',
+      valueType: ''
     }];
   }
   return [{
-    type: SectionHeading,
-    text: breakPoints(),
+    description: '',
     expanded: breakPointsExpanded,
-    key: BreakPoints,
-    value: '',
     indent: 0,
-    valueType: '',
-    name: BreakPoints$1,
-    description: '',
     index: startIndex,
+    key: BreakPoints,
+    name: BreakPoints$1,
+    posInset: topLevelIndex + 1,
     setSize: topLevelCount,
-    posInset: topLevelIndex + 1
+    text: breakPoints(),
+    type: SectionHeading,
+    value: '',
+    valueType: ''
   }];
 };
 
@@ -2376,8 +2413,8 @@ const getRunAndDebugVisibleRowsCallStack = (state, startingIndex, topLevelCount,
   const {
     callStack: callStack$1,
     callStackExpanded,
-    parsedScripts,
-    callStackVisible
+    callStackVisible,
+    parsedScripts
   } = state;
   if (!callStackVisible) {
     return [];
@@ -2385,75 +2422,76 @@ const getRunAndDebugVisibleRowsCallStack = (state, startingIndex, topLevelCount,
   const rows = [];
   if (callStackExpanded) {
     rows.push({
-      type: SectionHeading,
-      text: callStack(),
+      description: '',
       expanded: true,
-      key: CallStack,
-      value: '',
       indent: 0,
-      valueType: '',
-      name: CallStack$1,
-      description: '',
       index: startingIndex,
+      key: CallStack,
+      name: CallStack$1,
+      posInset: topLevelIndex + 1,
       setSize: topLevelCount,
-      posInset: topLevelIndex + 1
+      text: callStack(),
+      type: SectionHeading,
+      value: '',
+      valueType: ''
     });
     if (callStack$1.length === 0) {
       rows.push({
-        type: Message,
-        text: notPaused(),
+        description: '',
         expanded: false,
-        key: '',
-        value: '',
         indent: 0,
-        valueType: '',
-        name: '',
-        description: '',
         index: startingIndex + 1,
+        key: '',
+        name: '',
+        posInset: 2,
         setSize: 1,
-        posInset: 2
+        text: notPaused(),
+        type: Message,
+        value: '',
+        valueType: ''
       });
     } else {
       const setSize = callStack$1.length + 1;
       for (let i = 0; i < callStack$1.length; i++) {
         const item = callStack$1[i];
         const {
-          scriptId,
-          lineNumber} = item.location;
+          lineNumber,
+          scriptId
+        } = item.location;
         const script = parsedScripts[scriptId] || unknownScript;
         const description = formatLocation(script.url, lineNumber);
         const hasArrow = i === 0;
         rows.push({
-          type: CallStack$3,
-          text: item.functionName,
-          expanded: false,
-          key: CallStack,
-          value: '',
-          indent: 0,
-          valueType: '',
-          name: '',
           description,
+          expanded: false,
           hasArrow,
+          indent: 0,
           index: startingIndex + i + 1,
+          key: CallStack,
+          name: '',
+          posInset: i + 2,
           setSize: setSize,
-          posInset: i + 2
+          text: item.functionName,
+          type: CallStack$3,
+          value: '',
+          valueType: ''
         });
       }
     }
   } else {
     rows.push({
-      type: SectionHeading,
-      text: callStack(),
+      description: '',
       expanded: false,
-      key: CallStack,
-      value: '',
       indent: 0,
-      valueType: '',
-      name: CallStack$1,
-      description: '',
       index: startingIndex,
+      key: CallStack,
+      name: CallStack$1,
+      posInset: 1,
       setSize: 1,
-      posInset: 1
+      text: callStack(),
+      type: SectionHeading,
+      value: '',
+      valueType: ''
     });
   }
   return rows;
@@ -2649,26 +2687,26 @@ const tokenizeValue = input => {
 
 const getScopeExceptionRows = (scope, relativeIndex, index) => {
   const {
+    indent,
     key,
-    value,
-    indent
+    value
   } = scope;
   const tokens = tokenizeValue(value);
   return [{
-    type: Exception$2,
-    text: '',
-    tokens,
+    description: '',
     expanded: false,
-    key,
-    value,
     indent,
-    valueType: '',
-    name: '',
-    description: '',
     index: relativeIndex,
-    setSize: 1,
+    key,
+    name: '',
     posInset: 1,
-    scopeChainIndex: relativeIndex
+    scopeChainIndex: relativeIndex,
+    setSize: 1,
+    text: '',
+    tokens,
+    type: Exception$2,
+    value,
+    valueType: ''
   }];
 };
 
@@ -2679,50 +2717,50 @@ const Focused = 1 << 2;
 
 const getScopePropertyRows = (scope, relativeIndex, index) => {
   const {
+    flags,
     indent,
     key,
     value,
-    valueType,
-    flags
+    valueType
   } = scope;
   const tokens = tokenizeValue(value);
   return [{
-    type: Property$1,
-    text: '',
-    tokens,
+    description: '',
     expanded: Boolean(flags & Expanded),
-    key,
-    value,
     indent,
-    valueType,
-    name: '',
-    description: '',
     index,
-    setSize: 1,
+    key,
+    name: '',
     posInset: 1,
-    scopeChainIndex: relativeIndex
+    scopeChainIndex: relativeIndex,
+    setSize: 1,
+    text: '',
+    tokens,
+    type: Property$1,
+    value,
+    valueType
   }];
 };
 
 const getScopeScopeRows = (scope, relativeIndex, index) => {
   const {
-    key,
-    flags
+    flags,
+    key
   } = scope;
   return [{
-    type: Scope$4,
-    text: '',
+    description: '',
     expanded: Boolean(flags & Expanded),
-    key,
-    value: '',
     indent: 0,
-    valueType: '',
-    name: '',
-    description: '',
     index,
-    setSize: 1,
+    key,
+    name: '',
     posInset: 1,
-    scopeChainIndex: relativeIndex
+    scopeChainIndex: relativeIndex,
+    setSize: 1,
+    text: '',
+    type: Scope$4,
+    value: '',
+    valueType: ''
   }];
 };
 
@@ -2735,33 +2773,33 @@ const getScopeThisRows = (scope, relativeIndex, index) => {
   } = scope;
   const tokens = tokenizeValue(value);
   return [{
-    type: Value,
-    text: '',
-    tokens,
+    description: '',
     expanded: false,
-    key,
-    value,
     indent,
-    valueType,
-    name: '',
-    description: '',
     index,
-    setSize: 1,
+    key,
+    name: '',
     posInset: 1,
-    scopeChainIndex: relativeIndex
+    scopeChainIndex: relativeIndex,
+    setSize: 1,
+    text: '',
+    tokens,
+    type: Value,
+    value,
+    valueType
   }];
 };
 
 const getScopeRenderer = type => {
   switch (type) {
-    case This:
-      return getScopeThisRows;
     case Exception$1:
       return getScopeExceptionRows;
-    case Scope:
-      return getScopeScopeRows;
     case Property:
       return getScopePropertyRows;
+    case Scope:
+      return getScopeScopeRows;
+    case This:
+      return getScopeThisRows;
     default:
       return getNoopRows;
   }
@@ -2805,12 +2843,12 @@ const getVisibleScopeItems = (scopeChain, expandedIds, focusedIndex) => {
 
 const getRunAndDebugVisibleRowsScope = (state, startingIndex, topLevelCount, topLevelIndex) => {
   const {
+    debugState,
+    expandedIds,
     scopeChain,
     scopeExpanded,
-    expandedIds,
     scopeFocusedIndex,
-    scopeVisible,
-    debugState
+    scopeVisible
   } = state;
   if (!scopeVisible) {
     return [];
@@ -2818,18 +2856,18 @@ const getRunAndDebugVisibleRowsScope = (state, startingIndex, topLevelCount, top
   const rows = [];
   if (scopeExpanded) {
     rows.push({
-      type: SectionHeading,
-      text: scope(),
+      description: '',
       expanded: true,
-      key: Scope$1,
-      value: '',
       indent: 0,
-      valueType: '',
-      name: Scope$2,
-      description: '',
       index: startingIndex,
+      key: Scope$1,
+      name: Scope$2,
+      posInset: topLevelIndex + 1,
       setSize: topLevelCount,
-      posInset: topLevelIndex + 1
+      text: scope(),
+      type: SectionHeading,
+      value: '',
+      valueType: ''
     });
     if (debugState === Paused) {
       const visible = getVisibleScopeItems(scopeChain, expandedIds, scopeFocusedIndex);
@@ -2842,34 +2880,34 @@ const getRunAndDebugVisibleRowsScope = (state, startingIndex, topLevelCount, top
       }
     } else {
       rows.push({
-        type: Message,
-        text: notPaused(),
+        description: '',
         expanded: false,
-        key: '',
-        value: '',
         indent: 0,
-        valueType: '',
-        name: '',
-        description: '',
         index: startingIndex + 1,
+        key: '',
+        name: '',
+        posInset: 1,
         setSize: 1,
-        posInset: 1
+        text: notPaused(),
+        type: Message,
+        value: '',
+        valueType: ''
       });
     }
   } else {
     rows.push({
-      type: SectionHeading,
-      text: scope(),
+      description: '',
       expanded: false,
-      key: Scope$1,
-      value: '',
       indent: 0,
-      valueType: '',
-      name: Scope$2,
-      description: '',
       index: startingIndex,
+      key: Scope$1,
+      name: Scope$2,
+      posInset: 1,
       setSize: topLevelCount,
-      posInset: 1
+      text: scope(),
+      type: SectionHeading,
+      value: '',
+      valueType: ''
     });
   }
   return rows;
@@ -2881,51 +2919,51 @@ const formatValue = value => {
 const renderWatchExpression$1 = (expression, value, isEditing, relativeIndex, index, setSize) => {
   if (isEditing) {
     return {
-      type: InputField,
-      text: '',
+      description: '',
       expanded: false,
-      key: 'new-watch-expression',
-      value: '',
       indent: 0,
-      valueType: '',
-      name: WatchExpressionInput,
-      description: '',
       index,
+      key: 'new-watch-expression',
+      name: WatchExpressionInput,
+      posInset: relativeIndex + 1,
       setSize,
-      posInset: relativeIndex + 1
+      text: '',
+      type: InputField,
+      value: '',
+      valueType: ''
     };
   }
   return {
-    type: WatchExpression,
-    text: expression,
+    description: '',
     expanded: false,
-    key: expression,
-    value: formatValue(value),
     indent: 0,
-    valueType: '',
-    name: '',
-    description: '',
     index,
+    key: expression,
+    name: '',
+    posInset: relativeIndex + 1,
     setSize,
-    posInset: relativeIndex + 1
+    text: expression,
+    type: WatchExpression,
+    value: formatValue(value),
+    valueType: ''
   };
 };
 const getRunAndDebugVisibleRowsWatchContent = (watchExpressions, startIndex) => {
   const rows = [];
   if (watchExpressions.length === 0) {
     rows.push({
-      type: WatchMessage,
-      text: noWatchExpression(),
+      description: '',
       expanded: false,
-      key: '',
-      value: '',
       indent: 0,
-      valueType: '',
-      name: '',
-      description: '',
       index: startIndex + 1,
+      key: '',
+      name: '',
+      posInset: 1,
       setSize: 1,
-      posInset: 1
+      text: noWatchExpression(),
+      type: WatchMessage,
+      value: '',
+      valueType: ''
     });
   } else {
     const setSize = watchExpressions.length;
@@ -2943,13 +2981,13 @@ const getWatchActions = watchExpanded => {
     return [];
   }
   return [{
+    icon: '+',
     id: AddWatchExpression,
-    title: 'Add new watch expression',
-    icon: '+'
+    title: 'Add new watch expression'
   }, {
+    icon: '↻',
     id: RefreshWatchExpressions,
-    title: 'Refresh watch expressions',
-    icon: '↻'
+    title: 'Refresh watch expressions'
   }];
 };
 
@@ -2963,19 +3001,19 @@ const getRunAndDebugVisibleRowsWatch = (state, startIndex, topLevelCount, topLev
     return [];
   }
   const rows = [{
-    type: SectionHeading,
-    text: watch(),
+    actions: getWatchActions(watchExpanded),
+    description: '',
     expanded: watchExpanded,
-    key: Watch,
-    value: '',
     indent: 0,
-    valueType: '',
-    name: Watch$1,
-    description: '',
-    actions: getWatchActions(watchExpanded),
     index: 0,
+    key: Watch,
+    name: Watch$1,
+    posInset: topLevelIndex + 1,
     setSize: topLevelCount,
-    posInset: topLevelIndex + 1
+    text: watch(),
+    type: SectionHeading,
+    value: '',
+    valueType: ''
   }];
   if (watchExpanded) {
     rows.push(...getRunAndDebugVisibleRowsWatchContent(watchExpressions, startIndex));
@@ -2986,18 +3024,34 @@ const getRunAndDebugVisibleRowsWatch = (state, startIndex, topLevelCount, topLev
 const getRunAndDebugVisibleRows = state => {
   if (state.debugState === Unavailable) {
     return [{
-      type: Message,
-      text: noScriptRunning(),
+      description: '',
       expanded: false,
-      key: 'no-script-running',
-      value: '',
       indent: 0,
-      valueType: '',
+      index: 0,
+      key: 'no-script-running',
       name: '',
+      posInset: 1,
+      setSize: 1,
+      text: noScriptRunning(),
+      type: Message,
+      value: '',
+      valueType: ''
+    }];
+  }
+  if (state.debugState === MissingProvider) {
+    return [{
       description: '',
+      expanded: false,
+      indent: 0,
       index: 0,
+      key: 'missing-debug-provider',
+      name: '',
+      posInset: 1,
       setSize: 1,
-      posInset: 1
+      text: state.debugProviderMessage,
+      type: MissingDebugProvider,
+      value: '',
+      valueType: ''
     }];
   }
   const {
@@ -3023,11 +3077,11 @@ const FocusDebugRow = 1299;
 
 const acceptWatchExpressionEdit = async state => {
   const {
-    watchExpressions,
-    editingValue,
+    callFrameId,
     debugId,
     debugState,
-    callFrameId
+    editingValue,
+    watchExpressions
   } = state;
   const newWatchExpressions = await getNewWatchExpressionsAccept(debugId, callFrameId, debugState, watchExpressions, editingValue);
   if (watchExpressions === newWatchExpressions) {
@@ -3035,11 +3089,11 @@ const acceptWatchExpressionEdit = async state => {
   }
   const newState = {
     ...state,
-    watchExpressions: newWatchExpressions,
-    focus: FocusDebugRow,
-    editingValue: '',
+    editingselectionend: 0,
     editingselectionstart: 0,
-    editingselectionend: 0
+    editingValue: '',
+    focus: FocusDebugRow,
+    watchExpressions: newWatchExpressions
   };
   return updateVisibleRows(newState);
 };
@@ -3050,16 +3104,16 @@ const addWatchExpression = async (state, expression = '') => {
   } = state;
   const watchExpression = {
     expression,
-    value: null,
-    isEditing: true
+    isEditing: true,
+    value: null
   };
   const newWatchExpressions1 = [...watchExpressions, watchExpression];
   const newState = {
     ...state,
-    watchExpressions: newWatchExpressions1,
-    focus: FocusDebugWatchInput,
+    editingselectionend: expression.length,
     editingselectionstart: 0,
-    editingselectionend: expression.length
+    focus: FocusDebugWatchInput,
+    watchExpressions: newWatchExpressions1
   };
   return updateVisibleRows(newState);
 };
@@ -3082,11 +3136,11 @@ const cancelWatchExpressionEdit = state => {
   const newWatchExpressions = getNewWatchExpressionsCancel(watchExpressions);
   const newState = {
     ...state,
-    watchExpressions: newWatchExpressions,
-    focus: FocusDebugRow,
-    editingselectionstart: 0,
     editingselectionend: 0,
-    editingValue: ''
+    editingselectionstart: 0,
+    editingValue: '',
+    focus: FocusDebugRow,
+    watchExpressions: newWatchExpressions
   };
   return updateVisibleRows(newState);
 };
@@ -3099,46 +3153,47 @@ const None$2 = 'none';
 
 const create = (id, uri, x, y, width, height) => {
   const state = {
-    uid: id,
-    disposed: false,
-    processes: [],
-    debugState: None$6,
-    watchExpanded: false,
     breakPointsExpanded: false,
-    scopeExpanded: false,
-    callStackExpanded: false,
-    watchVisible: true,
     breakPointsVisible: true,
-    scopeVisible: true,
-    callStackVisible: true,
-    scopeChain: [],
+    cache: Object.create(null),
+    // TODO maybe store cache in extension host worker
+    callFrameId: '',
     callStack: [],
-    parsedScripts: Object.create(null),
-    pausedReason: None$3,
-    pausedMessage: '',
+    callStackExpanded: false,
+    callStackVisible: true,
+    debugId: 0,
     debugInputValue: '',
     debugOutputValue: '',
-    callFrameId: '',
-    expandedIds: [],
-    scopeFocusedIndex: -1,
-    focusedIndex: -1,
-    pauseOnExceptionState: None$2,
-    cache: Object.create(null),
-    // TODO maybe store cache in extension host worker
+    debugProviderMessage: '',
+    debugState: None$6,
+    disposed: false,
+    editingselectionend: 0,
+    editingselectionstart: 0,
+    editingValue: '',
     exceptionBreakPoints: None$5,
-    watchExpressions: [],
+    expandedIds: [],
     focus: 0,
-    editingValue: '',
-    debugId: 0,
+    focusedIndex: -1,
     inputSource: 0,
-    editingselectionstart: 0,
-    editingselectionend: 0,
-    openFilesOnPause: true,
     maxDescriptionLength: 100,
+    openFilesOnPause: true,
+    parsedScripts: Object.create(null),
+    pausedMessage: '',
+    pausedReason: None$3,
+    pauseOnExceptionState: None$2,
+    processes: [],
+    scopeChain: [],
+    scopeExpanded: false,
+    scopeFocusedIndex: -1,
+    scopeVisible: true,
     selectedIndex: -1,
-    visibleRows: [],
     tokenColoringEnabled: false,
-    topLevelCount: 4
+    topLevelCount: 4,
+    uid: id,
+    visibleRows: [],
+    watchExpanded: false,
+    watchExpressions: [],
+    watchVisible: true
   };
   set(id, state, state);
 };
@@ -3221,8 +3276,8 @@ const diff = (oldState, newState) => {
 
 const diff2 = uid => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   const diffResult = diff(oldState, newState);
   return diffResult;
@@ -3232,16 +3287,16 @@ const dispose = async uid => {
   dispose$1(uid);
 };
 
-const commandIds = ['acceptWatchExpressionEdit', 'addWatchExpression', 'cancelWatchExpressionEdit', 'create', 'deleteAllWatchExpressions', 'deleteWatchExpression', 'diff2', 'dispose', 'focusNext', 'focusPrevious', 'getCommandIds', 'getKeyBindings', 'handleArrowDown', 'handleArrowLeft', 'handleArrowRight', 'handleArrowUp', 'handleChange', 'handleClickCallStackItem', 'handleClickCheckBox', 'handleClickDebugButton', 'handleClickPauseOnExceptions', 'handleClickPauseOnUncaughtExceptions', 'handleClickScopeValue', 'handleClickSectionAction', 'handleClickSectionBreakPoints', 'handleClickSectionCallstack', 'handleClickSectionHeading', 'handleClickSectionScope', 'handleClickSectionWatch', 'handleClickWatchExpression', 'handleClickWatchExpressionDelete', 'handleCopy', 'handleDebugInput', 'handleDelete', 'handleEnter', 'handleEvaluate', 'handleInputBlur', 'handleInputFieldChange', 'handleNew', 'handlePaused', 'handleRename', 'handleResumed', 'handleScriptParsed', 'handleSectionHeaderContextMenu', 'handleSpace', 'handleWatchExpressionContextMenu', 'handleWatchExpressionDoubleClick', 'handleWatchValueChange', 'hideCallStack', 'hideScope', 'hideWatch', 'loadContent', 'loadContentLater', 'pause', 'refresh', 'refreshWatchExpression', 'removeWatchExpression', 'render2', 'renderActions', 'renderEventListeners', 'resize', 'restoreState', 'resume', 'selectFirstIndex', 'selectIndex', 'selectLastIndex', 'selectNextRow', 'selectPreviousRow', 'setPauseOnExceptions', 'showCallStack', 'showScope', 'showWatch', 'stepInto', 'stepOut', 'stepOver', 'terminate', 'togglePause'];
+const commandIds = ['acceptWatchExpressionEdit', 'addWatchExpression', 'cancelWatchExpressionEdit', 'create', 'deleteAllWatchExpressions', 'deleteWatchExpression', 'diff2', 'dispose', 'focusNext', 'focusPrevious', 'getCommandIds', 'getKeyBindings', 'handleArrowDown', 'handleArrowLeft', 'handleArrowRight', 'handleArrowUp', 'handleChange', 'handleClickCallStackItem', 'handleClickCheckBox', 'handleClickDebugButton', 'handleClickOpenExtensions', 'handleClickPauseOnExceptions', 'handleClickPauseOnUncaughtExceptions', 'handleClickScopeValue', 'handleClickSectionAction', 'handleClickSectionBreakPoints', 'handleClickSectionCallstack', 'handleClickSectionHeading', 'handleClickSectionScope', 'handleClickSectionWatch', 'handleClickWatchExpression', 'handleClickWatchExpressionDelete', 'handleCopy', 'handleDebugInput', 'handleDelete', 'handleEnter', 'handleEvaluate', 'handleInputBlur', 'handleInputFieldChange', 'handleNew', 'handlePaused', 'handleRename', 'handleResumed', 'handleScriptParsed', 'handleSectionHeaderContextMenu', 'handleSpace', 'handleWatchExpressionContextMenu', 'handleWatchExpressionDoubleClick', 'handleWatchValueChange', 'hideCallStack', 'hideScope', 'hideWatch', 'loadContent', 'loadContentLater', 'pause', 'refresh', 'refreshWatchExpression', 'removeWatchExpression', 'render2', 'renderActions', 'renderEventListeners', 'resize', 'restoreState', 'resume', 'selectFirstIndex', 'selectIndex', 'selectLastIndex', 'selectNextRow', 'selectPreviousRow', 'setPauseOnExceptions', 'showCallStack', 'showScope', 'showWatch', 'stepInto', 'stepOut', 'stepOver', 'terminate', 'togglePause'];
 
 const getCommandIds = () => {
   return commandIds;
 };
 
 const emptyHighlight = {
-  uri: '',
+  columnIndex: 0,
   rowIndex: 0,
-  columnIndex: 0
+  uri: ''
 };
 const getHighlight = uid => {
   const state = get(uid);
@@ -3252,8 +3307,8 @@ const getHighlight = uid => {
     newState
   } = state;
   const {
-    parsedScripts,
-    callStack
+    callStack,
+    parsedScripts
   } = newState;
   if (callStack.length === 0) {
     return emptyHighlight;
@@ -3263,18 +3318,18 @@ const getHighlight = uid => {
     location
   } = top;
   const {
-    scriptId,
+    columnNumber,
     lineNumber,
-    columnNumber
+    scriptId
   } = location;
   const script = parsedScripts[scriptId];
   if (!script) {
     return emptyHighlight;
   }
   return {
-    uri: script.url,
+    columnIndex: columnNumber,
     rowIndex: lineNumber,
-    columnIndex: columnNumber
+    uri: script.url
   };
 };
 
@@ -3284,103 +3339,103 @@ const mergeClassNames = (...classNames) => {
 
 const text = data => {
   return {
-    type: Text$1,
+    childCount: 0,
     text: data,
-    childCount: 0
+    type: Text$1
   };
 };
 
 const getKeyBindings = () => {
   return [{
-    key: Backslash | CtrlCmd,
-    command: 'Run And Debug.togglePause'
+    command: 'Run And Debug.togglePause',
+    key: Backslash | CtrlCmd
   }, {
-    key: LeftArrow,
     command: 'Run And Debug.handleArrowLeft',
+    key: LeftArrow,
     when: FocusDebugRow
   }, {
-    key: RightArrow,
     command: 'Run And Debug.handleArrowRight',
+    key: RightArrow,
     when: FocusDebugRow
   }, {
-    key: Home,
     command: 'Run And Debug.focusFirst',
+    key: Home,
     when: FocusDebugRow
   }, {
-    key: End,
     command: 'Run And Debug.focusLast',
+    key: End,
     when: FocusDebugRow
   }, {
-    key: UpArrow,
     command: 'Run And Debug.selectPreviousRow',
+    key: UpArrow,
     when: FocusDebugRow
   }, {
-    key: DownArrow,
     command: 'Run And Debug.selectNextRow',
+    key: DownArrow,
     when: FocusDebugRow
   }, {
-    key: CtrlCmd | Star,
     command: 'Run And Debug.expandAll',
+    key: CtrlCmd | Star,
     when: FocusDebugRow
   }, {
-    key: Alt | RightArrow,
     command: 'Run And Debug.expandRecursively',
+    key: Alt | RightArrow,
     when: FocusDebugRow
   }, {
-    key: CtrlCmd | LeftArrow,
     command: 'Run And Debug.collapseAll',
+    key: CtrlCmd | LeftArrow,
     when: FocusDebugRow
   }, {
-    key: CtrlCmd | KeyV,
     command: 'Run And Debug.handlePaste',
+    key: CtrlCmd | KeyV,
     when: FocusDebugRow
   }, {
-    key: CtrlCmd | KeyC,
     command: 'Run And Debug.handleCopy',
+    key: CtrlCmd | KeyC,
     when: FocusDebugRow
   }, {
-    key: CtrlCmd | KeyN,
     command: 'Run And Debug.handleNew',
+    key: CtrlCmd | KeyN,
     when: FocusDebugRow
   }, {
-    key: F2,
     command: 'Run And Debug.handleRename',
+    key: F2,
     when: FocusDebugRow
   }, {
-    key: Delete,
     command: 'Run And Debug.handleDelete',
+    key: Delete,
     when: FocusDebugRow
   }, {
-    key: Escape,
     command: 'Run And Debug.focusNone',
+    key: Escape,
     when: FocusDebugRow
   }, {
-    key: Enter,
     command: 'Run And Debug.handleClickCurrent',
+    key: Enter,
     when: FocusDebugRow
   }, {
-    key: Space$1,
     command: 'Run And Debug.handleSpace',
+    key: Space$1,
     when: FocusDebugRow
   }, {
-    key: Enter,
     command: 'Run And Debug.handleEnter',
+    key: Enter,
     when: FocusDebugRow
   }, {
-    key: Escape,
     command: 'Run And Debug.cancelWatchExpressionEdit',
+    key: Escape,
     when: FocusDebugWatchInput
   }, {
-    key: Enter,
     command: 'Run And Debug.acceptWatchExpressionEdit',
+    key: Enter,
     when: FocusDebugWatchInput
   }, {
-    key: CtrlCmd | Home,
     command: 'Run And Debug.selectFirstIndex',
+    key: CtrlCmd | Home,
     when: FocusDebugRow
   }, {
-    key: CtrlCmd | End,
     command: 'Run And Debug.selectLastIndex',
+    key: CtrlCmd | End,
     when: FocusDebugRow
   }];
 };
@@ -3389,22 +3444,22 @@ const None$1 = 0;
 
 const getMenuEntriesWatchExpression = () => {
   const addMenuEntry = {
-    id: 'addWatchExpression',
-    label: addWatchExpression$1(),
+    command: 'RunAndDebug.addWatchExpression',
     flags: None$1,
-    command: 'RunAndDebug.addWatchExpression'
+    id: 'addWatchExpression',
+    label: addWatchExpression$1()
   };
   const deleteMenuEntry = {
-    id: 'deleteWatchExpression',
-    label: deleteWatchExpression$1(),
+    command: 'RunAndDebug.deleteWatchExpression',
     flags: None$1,
-    command: 'RunAndDebug.deleteWatchExpression'
+    id: 'deleteWatchExpression',
+    label: deleteWatchExpression$1()
   };
   const deleteAllMenuEntry = {
-    id: 'deleteAllWatchExpressions',
-    label: deleteAllWatchExpressions$1(),
+    command: 'RunAndDebug.deleteAllWatchExpressions',
     flags: None$1,
-    command: 'RunAndDebug.deleteAllWatchExpressions'
+    id: 'deleteAllWatchExpressions',
+    label: deleteAllWatchExpressions$1()
   };
   return [addMenuEntry, deleteMenuEntry, deleteAllMenuEntry];
 };
@@ -3414,8 +3469,8 @@ const DebugWatchSectionHeading = 21_901;
 
 const getMenuEntries = () => {
   return [{
-    id: DebugWatchExpression,
-    entries: getMenuEntriesWatchExpression()
+    entries: getMenuEntriesWatchExpression(),
+    id: DebugWatchExpression
   }];
 };
 
@@ -3435,8 +3490,8 @@ const handleClickSectionBreakPoints = state => {
   const newState = {
     ...state,
     breakPointsExpanded: !breakPointsExpanded,
-    selectedIndex: getSectionIndex(state, BreakPoints$1),
-    focus: FocusDebugRow
+    focus: FocusDebugRow,
+    selectedIndex: getSectionIndex(state, BreakPoints$1)
   };
   return updateVisibleRows(newState);
 };
@@ -3448,8 +3503,8 @@ const handleClickSectionCallstack = state => {
   const newState = {
     ...state,
     callStackExpanded: !callStackExpanded,
-    selectedIndex: getSectionIndex(state, CallStack$1),
-    focus: FocusDebugRow
+    focus: FocusDebugRow,
+    selectedIndex: getSectionIndex(state, CallStack$1)
   };
   return updateVisibleRows(newState);
 };
@@ -3460,9 +3515,9 @@ const handleClickSectionScope = state => {
   } = state;
   const newState = {
     ...state,
+    focus: FocusDebugRow,
     scopeExpanded: !scopeExpanded,
-    selectedIndex: getSectionIndex(state, Scope$2),
-    focus: FocusDebugRow
+    selectedIndex: getSectionIndex(state, Scope$2)
   };
   return updateVisibleRows(newState);
 };
@@ -3478,23 +3533,23 @@ const handleClickSectionWatch = state => {
   } = state;
   const newState = {
     ...state,
-    watchExpanded: !watchExpanded,
+    focus: FocusDebugRow,
     selectedIndex: getSectionIndex(state, Watch$1),
-    focus: FocusDebugRow
+    watchExpanded: !watchExpanded
   };
   return updateVisibleRows(newState);
 };
 
 const getSectionClickHandler = id => {
   switch (id) {
-    case Watch:
-      return handleClickSectionWatch;
     case BreakPoints:
       return handleClickSectionBreakPoints;
-    case Scope$1:
-      return handleClickSectionScope;
     case CallStack:
       return handleClickSectionCallstack;
+    case Scope$1:
+      return handleClickSectionScope;
+    case Watch:
+      return handleClickSectionWatch;
     default:
       return handleClickSectionUnknown;
   }
@@ -3524,8 +3579,8 @@ const getCollapsedScopeChain = (cache, scopeChain, element, index) => {
   const endIndex = getCollapsedEndIndex(scopeChain, index, indent);
   if (endIndex === -1) {
     return {
-      newScopeChain: scopeChain,
-      newCache: cache
+      newCache: cache,
+      newScopeChain: scopeChain
     };
   }
   const newItems = scopeChain.slice(index + 1, endIndex);
@@ -3534,8 +3589,8 @@ const getCollapsedScopeChain = (cache, scopeChain, element, index) => {
     [scopeChain[index].objectId]: newItems
   };
   return {
-    newScopeChain: [...scopeChain.slice(0, index + 1), ...scopeChain.slice(endIndex)],
-    newCache
+    newCache,
+    newScopeChain: [...scopeChain.slice(0, index + 1), ...scopeChain.slice(endIndex)]
   };
 };
 
@@ -3550,17 +3605,17 @@ const collapseScopeChain = (state, expandedIds, scopeChain, element, scopeChainI
   } = state;
   const newExpandedIds = removeElement(expandedIds, element.objectId);
   const {
-    newScopeChain,
-    newCache
+    newCache,
+    newScopeChain
   } = getCollapsedScopeChain(cache, scopeChain, element, scopeChainIndex);
   const newState = {
     ...state,
-    expandedIds: newExpandedIds,
-    scopeChain: newScopeChain,
-    scopeFocusedIndex: scopeChainIndex,
     cache: newCache,
+    expandedIds: newExpandedIds,
     focus: FocusDebugRow,
     focusedIndex: index,
+    scopeChain: newScopeChain,
+    scopeFocusedIndex: scopeChainIndex,
     selectedIndex: index
   };
   return updateVisibleRows(newState);
@@ -3571,7 +3626,7 @@ const None = '';
 const Number$1 = 'number';
 const Object$1 = 'object';
 const String$1 = 'string';
-const Symbol = 'symbol';
+const Symbol$1 = 'symbol';
 const Function = 'function';
 const Getter = 'getter';
 const Undefined = 'undefined';
@@ -3648,18 +3703,18 @@ const getDebugPropertyValueLabel = (property, maxDescriptionLength) => {
     return 'n/a';
   }
   switch (property.type) {
-    case Number$1:
-    case Symbol:
+    case Boolean$1:
+      return getDebugPropertyValueLabelBoolean(property);
     case Function:
+    case Number$1:
+    case Symbol$1:
       return getDebugPropertyValueLabelCommon(property, maxDescriptionLength);
     case Object$1:
       return getDebugPropertyValueLabelObject(property);
-    case Undefined:
-      return getDebugPropertyValueLabelString();
     case String$1:
       return getDebugPropertyValueLabelString$1(property);
-    case Boolean$1:
-      return getDebugPropertyValueLabelBoolean(property);
+    case Undefined:
+      return getDebugPropertyValueLabelString();
     default:
       return `${JSON.stringify(property)}`;
   }
@@ -3691,14 +3746,14 @@ const getInnerChildScopeChain = async (cache, debugId, objectId, indent, maxDesc
   for (const child of childScopes.result.result) {
     const valueLabel = getDebugPropertyValueLabel(child.value || child.get || {}, maxDescriptionLength);
     childScopeChain.push({
-      type: Property,
-      key: child.name,
-      value: valueLabel,
-      valueType: getDebugValueType(child),
-      objectId: getDebugValueObjectId(child),
+      flags: None$4,
       indent: indent + 10,
+      key: child.name,
       label: '',
-      flags: None$4
+      objectId: getDebugValueObjectId(child),
+      type: Property,
+      value: valueLabel,
+      valueType: getDebugValueType(child)
     });
   }
   return childScopeChain;
@@ -3726,11 +3781,11 @@ const expandScopeChain = async (state, expandedIds, scopeChain, element, scopeCh
   const newExpandedIds = [...expandedIds, objectId];
   const newState = {
     ...state,
-    scopeChain: newScopeChain,
     expandedIds: newExpandedIds,
-    scopeFocusedIndex: scopeChainIndex,
     focus: FocusDebugRow,
     focusedIndex: index,
+    scopeChain: newScopeChain,
+    scopeFocusedIndex: scopeChainIndex,
     selectedIndex: index
   };
   return updateVisibleRows(newState);
@@ -3738,9 +3793,9 @@ const expandScopeChain = async (state, expandedIds, scopeChain, element, scopeCh
 
 const handleClickScopeChainIndex = async (state, scopeChainIndex, index) => {
   const {
+    debugId,
     expandedIds,
-    scopeChain,
-    debugId
+    scopeChain
   } = state;
   const element = scopeChain[scopeChainIndex];
   if (expandedIds.includes(element.objectId)) {
@@ -3827,8 +3882,8 @@ const getCallStack = callFrames => {
   const callStack = [];
   for (const callFrame of callFrames) {
     callStack.push({
-      functionName: callFrame.functionName || '(anonymous)',
       functionLocation: callFrame.functionLocation,
+      functionName: callFrame.functionName || '(anonymous)',
       location: callFrame.location
     });
   }
@@ -3837,10 +3892,10 @@ const getCallStack = callFrames => {
 
 const getDebugPausedMessage = reason => {
   switch (reason) {
-    case Other:
-      return debuggerPaused();
     case Exception:
       return debuggerPausedOnException();
+    case Other:
+      return debuggerPaused();
     default:
       return `Debugger paused (${reason})`;
   }
@@ -3862,29 +3917,29 @@ const WasmExpressionStack = 'wasm-expression-stack';
 
 const getScopeLabel = element => {
   switch (element.type) {
-    case Local:
-      return local();
+    case Block:
+      return block();
+    case Catch:
+      return catchScope();
     case Closure:
       if (element.name) {
         return namedClosure(element.name);
       }
       return closure();
+    case Eval:
+      return evalScope();
     case Global:
       return global();
-    case Block:
-      return block();
-    case WasmExpressionStack:
-      return expression();
+    case Local:
+      return local();
     case Module:
       return module2();
-    case Eval:
-      return evalScope();
     case Script:
       return script();
+    case WasmExpressionStack:
+      return expression();
     case With:
       return withScope();
-    case Catch:
-      return catchScope();
     default:
       return element.type;
   }
@@ -3901,35 +3956,35 @@ const getScopeChain = (params, thisObject, scopeChain, knownProperties, descript
   for (const scope of scopeChain) {
     const label = getScopeLabel(scope);
     elements.push({
-      type: Scope,
+      indent: 10,
       key: label,
-      value: '',
-      valueType: '',
       label,
       objectId: scope.object.objectId,
-      indent: 10
+      type: Scope,
+      value: '',
+      valueType: ''
     });
     // if(params.reason)
     if (scope.type === Local) {
       if (params.reason === Exception) {
         const value = getDescriptionValueLabel(params);
         elements.push({
-          type: Exception$1,
+          indent: 20,
           key: 'Exception',
-          value,
-          valueType: '',
           objectId: scope.object.objectId,
-          indent: 20
+          type: Exception$1,
+          value,
+          valueType: ''
         });
       }
       const valueLabel = getDebugPropertyValueLabel(thisObject, descriptionLength);
       elements.push({
-        type: This,
+        indent: 20,
         key: 'this',
-        value: valueLabel,
-        valueType: thisObject.type,
         objectId: '',
-        indent: 20
+        type: This,
+        value: valueLabel,
+        valueType: thisObject.type
       });
     }
     const children = knownProperties[scope.object.objectId];
@@ -3937,12 +3992,12 @@ const getScopeChain = (params, thisObject, scopeChain, knownProperties, descript
       for (const child of children.result.result) {
         const valueLabel = getDebugPropertyValueLabel(child.value, descriptionLength);
         elements.push({
-          type: Property,
+          indent: 20,
           key: child.name,
-          value: valueLabel,
-          valueType: getDebugValueType(child),
           objectId: getDebugValueObjectId(child),
-          indent: 20
+          type: Property,
+          value: valueLabel,
+          valueType: getDebugValueType(child)
         });
       }
     }
@@ -3954,8 +4009,8 @@ const getPausedInfo2 = async (debugId, maxDescriptionLength) => {
   const callFrames = await getCallStack$1(debugId);
   const callStack = getCallStack(callFrames);
   const {
-    reason,
-    data
+    data,
+    reason
   } = await getPausedStatus(debugId);
   const scripts = await getScripts(debugId);
   const scriptMap = createScriptMap(scripts);
@@ -3978,12 +4033,12 @@ const getPausedInfo2 = async (debugId, maxDescriptionLength) => {
   const pausedReason = reason;
   const pausedMessage = getDebugPausedMessage(reason);
   return {
-    scopeChain,
-    callStack,
-    pausedReason,
-    pausedMessage,
     callFrameId,
+    callStack,
     expandedIds: [objectId],
+    pausedMessage,
+    pausedReason,
+    scopeChain,
     scriptMap
   };
 };
@@ -3997,25 +4052,25 @@ const handlePaused2 = async state => {
     const {
       callFrameId,
       callStack,
-      scopeChain,
+      expandedIds,
       pausedMessage,
       pausedReason,
-      expandedIds,
+      scopeChain,
       scriptMap
     } = await getPausedInfo2(debugId, state.maxDescriptionLength);
     // TODO move this to getPausedInfo2
     const newWatchExpressions = await evaluateWatchExpressions(debugId, callFrameId, watchExpressions);
     const newState = {
       ...state,
-      debugState: Paused,
-      scopeChain,
-      scopeExpanded: true,
-      callStack,
-      pausedReason,
-      pausedMessage,
       callFrameId,
+      callStack,
+      debugState: Paused,
       expandedIds,
       parsedScripts: scriptMap,
+      pausedMessage,
+      pausedReason,
+      scopeChain,
+      scopeExpanded: true,
       watchExpressions: newWatchExpressions
     };
     return updateVisibleRows(newState);
@@ -4027,12 +4082,12 @@ const handlePaused2 = async state => {
 const handleResumed = state => {
   const newState = {
     ...state,
-    debugState: Default,
-    scopeChain: [],
+    callFrameId: '',
     callStack: [],
+    debugState: Default,
     pausedMessage: '',
     pausedReason: None$3,
-    callFrameId: ''
+    scopeChain: []
   };
   return updateVisibleRows(newState);
 };
@@ -4059,29 +4114,29 @@ const getOpenInfo = (id, parsedScripts, item) => {
     location
   } = item;
   const {
-    scriptId,
+    columnNumber,
     lineNumber,
-    columnNumber
+    scriptId
   } = location;
   const script = parsedScripts[scriptId];
   const {
-    url,
-    scriptLanguage
+    scriptLanguage,
+    url
   } = script;
   if (isSupportedOpenUri(url)) {
     return {
-      uri: url,
+      columnIndex: columnNumber,
       languageId: scriptLanguage,
       rowIndex: lineNumber,
-      columnIndex: columnNumber
+      uri: url
     };
   }
   const debugUri = getDebugUri(id, scriptId);
   return {
-    uri: debugUri,
+    columnIndex: columnNumber,
     languageId: scriptLanguage,
     rowIndex: lineNumber,
-    columnIndex: columnNumber
+    uri: debugUri
   };
 };
 
@@ -4097,10 +4152,10 @@ const handleClickCallstackItem = async (state, dataIndex) => {
     return state;
   }
   const {
-    uri,
+    columnIndex,
     languageId,
     rowIndex,
-    columnIndex
+    uri
   } = getOpenInfo(id, parsedScripts, item);
   await openUri(uri, languageId, rowIndex, columnIndex);
   return state;
@@ -4126,12 +4181,12 @@ const handleClickPauseOnExceptions = async state => {
     exceptionBreakPoints
   } = state;
   switch (exceptionBreakPoints) {
+    case All:
+      return setPauseOnExceptions(state, None$5);
     case None$5:
       return setPauseOnExceptions(state, All);
     case Uncaught:
       return setPauseOnExceptions(state, All);
-    case All:
-      return setPauseOnExceptions(state, None$5);
     default:
       return state;
   }
@@ -4139,12 +4194,12 @@ const handleClickPauseOnExceptions = async state => {
 
 const getNewExceptionState = exceptionState => {
   switch (exceptionState) {
+    case All:
+      return None$5;
     case None$5:
       return Uncaught;
     case Uncaught:
       return None$5;
-    case All:
-      return None$5;
     default:
       return exceptionState;
   }
@@ -4237,9 +4292,9 @@ const handleDebugInput = (state, value) => {
 };
 const handleEvaluate = async state => {
   const {
-    debugInputValue,
     callFrameId,
-    debugId
+    debugId,
+    debugInputValue
   } = state;
   const result = await evaluate(debugId, debugInputValue, callFrameId);
   // @ts-ignore
@@ -4285,10 +4340,10 @@ const getDebugButtonHandler = inputName => {
       return resume;
     case DebugStepInto$1:
       return stepInto;
-    case DebugStepOver$1:
-      return stepOver;
     case DebugStepOut$1:
       return stepOut;
+    case DebugStepOver$1:
+      return stepOver;
     case DebugStop$1:
       return stop;
     default:
@@ -4301,10 +4356,19 @@ const handleClickDebugButton = async (state, inputName) => {
   return fn(state);
 };
 
+const openExtensions = async () => {
+  await invoke$1('SideBar.show', 'Extensions');
+};
+
+const handleClickOpenExtensions = async state => {
+  await openExtensions();
+  return state;
+};
+
 const refreshWatchExpression = async state => {
   const {
-    debugId,
     callFrameId,
+    debugId,
     debugState,
     watchExpressions
   } = state;
@@ -4354,12 +4418,12 @@ const editWatchExpression = (state, index) => {
   const newWatchExpressions = watchExpressions.toSpliced(index, 1, newItem);
   const newState = {
     ...state,
-    watchExpressions: newWatchExpressions,
+    editingselectionend: item.expression.length,
+    editingselectionstart: 0,
+    editingValue: item.expression,
     focus: FocusDebugWatchInput,
     inputSource: Script$1,
-    editingValue: item.expression,
-    editingselectionstart: 0,
-    editingselectionend: item.expression.length
+    watchExpressions: newWatchExpressions
   };
   return updateVisibleRows(newState);
 };
@@ -4661,15 +4725,15 @@ const restoreWatchExpression = savedExpression => {
     if (value === null || value === undefined || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
       return {
         expression: savedExpression.expression,
-        value,
-        isEditing: savedExpression.isEditing
+        isEditing: savedExpression.isEditing,
+        value
       };
     }
   }
   return {
     expression: '',
-    value: null,
-    isEditing: false
+    isEditing: false,
+    value: null
   };
 };
 const restoreWatchExpressions = savedState => {
@@ -4687,12 +4751,12 @@ const restoreState = savedState => {
   const focus = restoreFocus();
   const editingValue = restoreEditingValue(savedState);
   return {
-    watchExpressions,
-    watchExpanded,
-    scopeExpanded,
     breakPointsExpanded,
+    editingValue,
     focus,
-    editingValue
+    scopeExpanded,
+    watchExpanded,
+    watchExpressions
   };
 };
 
@@ -4701,34 +4765,60 @@ const loadContent = async (state, isTest, savedState) => {
     savedState = {};
   }
   const {
-    watchExpressions,
-    watchExpanded,
     breakPointsExpanded,
-    scopeExpanded,
+    editingValue,
     focus,
-    editingValue
+    scopeExpanded,
+    watchExpanded,
+    watchExpressions
   } = restoreState(savedState);
   const debugId = getDebugId(isTest);
   const newState = {
     ...state,
+    breakPointsExpanded,
+    callStackExpanded: true,
     debugId,
     debugState: Default,
+    editingValue,
+    focus,
     scopeExpanded,
-    callStackExpanded: true,
-    breakPointsExpanded,
-    watchExpressions,
     watchExpanded,
-    focus,
-    editingValue
+    watchExpressions
   };
   return updateVisibleRows(newState);
 };
 
+const RE_NO_DEBUG_PROVIDER_FOUND = /no debug provider "([^"]+)" found/;
+const getDebugProviderName = error => {
+  const message = error?.message || '';
+  const match = RE_NO_DEBUG_PROVIDER_FOUND.exec(message);
+  if (!match) {
+    return '';
+  }
+  return match[1];
+};
+const isNoDebugProviderFound = error => {
+  return getDebugProviderName(error) !== '';
+};
+
 const loadContentLater = async state => {
   const {
     debugId
   } = state;
-  await start(debugId);
+  try {
+    await start(debugId);
+  } catch (error) {
+    if (!isNoDebugProviderFound(error)) {
+      throw error;
+    }
+    const debugProviderName = getDebugProviderName(error);
+    const newState = {
+      ...state,
+      debugProviderMessage: noDebugProviderFound(debugProviderName),
+      debugState: MissingProvider
+    };
+    return updateVisibleRows(newState);
+  }
   const status = await getPausedStatus(debugId);
   if (status && status.status === 'unavailable') {
     const newState = {
@@ -4795,8 +4885,8 @@ const getFocusSelector = focusId => {
 
 const renderFocus = (oldState, newState) => {
   const {
-    uid: id,
-    focus
+    focus,
+    uid: id
   } = newState;
   const selector = getFocusSelector(focus);
   if (!selector) {
@@ -4814,9 +4904,9 @@ const renderFocusContext = (oldState, newState) => {
 
 const renderInputValue = (oldState, newState) => {
   const {
-    uid: id,
+    editingValue,
     focus,
-    editingValue
+    uid: id
   } = newState;
   const selector = getFocusSelector(focus);
   if (!selector) {
@@ -4876,6 +4966,7 @@ const HandleClickStepOut = 'handleClickStepOut';
 const HandleClickStepOver = 'handleClickStepOver';
 const HandleDebugInput = 'handleDebugInput';
 const HandleClickSectionAction = 'handleClickSectionAction';
+const HandleClickOpenExtensions = 'handleClickOpenExtensions';
 const HandleInputFieldChange = 'handleInputFieldChange';
 const HandleInputBlur = 'handleInputBlur';
 const HandleSectionHeaderContextMenu = 'handleSectionHeaderContextMenu';
@@ -4891,17 +4982,17 @@ const Label = 66;
 
 const getActionDom = action => {
   const {
-    title,
+    icon,
     id,
-    icon
+    title
   } = action;
   return [{
-    type: Button,
+    childCount: 1,
     className: DebugSectionAction,
-    title,
-    onClick: HandleClickSectionAction,
     name: id,
-    childCount: 1
+    onClick: HandleClickSectionAction,
+    title,
+    type: Button
   }, text(icon)];
 };
 
@@ -4910,24 +5001,24 @@ const getActionsDom = actions => {
     return [];
   }
   return [{
-    type: Div,
+    childCount: actions.length,
     className: DebugSectionActions,
-    childCount: actions.length
+    type: Div
   }, ...actions.flatMap(getActionDom)];
 };
 
 const getChevronDownVirtualDom = (extraClassName = '') => {
   return {
-    type: Div,
+    childCount: 0,
     className: `${Chevron} MaskIconChevronDown ${extraClassName}`,
-    childCount: 0
+    type: Div
   };
 };
 const getChevronRightVirtualDom = (extraClassName = '') => {
   return {
-    type: Div,
+    childCount: 0,
     className: `${Chevron} MaskIconChevronRight ${extraClassName}`,
-    childCount: 0
+    type: Div
   };
 };
 
@@ -4937,30 +5028,30 @@ const getDebugRowClassName = (baseClassName, isSelected) => {
 
 const renderSectionHeading = (row, selectedIndex, rowIndex) => {
   const {
-    expanded,
-    text: text$1,
-    key,
     actions,
+    expanded,
     index,
+    key,
+    posInset,
     setSize,
-    posInset
+    text: text$1
   } = row;
   const hasActions = actions && actions.length > 0;
   const isSelected = rowIndex === selectedIndex;
   const className = getDebugRowClassName(DebugSectionHeader + ' ' + DebugRow, isSelected);
   const nodes = [{
-    type: Div,
-    className,
-    role: TreeItem,
     ariaExpanded: expanded,
     ariaLevel: 1,
+    ariaPosInSet: posInset,
+    ariaSetSize: setSize,
     childCount: hasActions ? 3 : 2,
+    className,
+    'data-index': index,
+    'data-name': key,
     onClick: HandleClickSectionHeading,
     onContextMenu: HandleSectionHeaderContextMenu,
-    'data-name': key,
-    'data-index': index,
-    ariaPosInSet: posInset,
-    ariaSetSize: setSize
+    role: TreeItem,
+    type: Div
   }, expanded ? getChevronDownVirtualDom() : getChevronRightVirtualDom(), text(text$1), ...getActionsDom(actions || [])];
   return nodes;
 };
@@ -4970,45 +5061,45 @@ const getArrowNodes = hasArrow => {
     return [];
   }
   return [{
-    type: Div,
+    childCount: 1,
     className: CallStackArrow,
-    childCount: 1
+    type: Div
   }, {
-    type: Div,
+    childCount: 0,
     className: 'MaskIcon MaskIconArrowRight',
-    childCount: 0
+    type: Div
   }];
 };
 
 const labelNode = {
-  type: Div,
+  childCount: 1,
   className: CallStackLabel,
-  childCount: 1
+  type: Div
 };
 const descriptionNode = {
-  type: Div,
+  childCount: 1,
   className: CallStackDescription,
-  childCount: 1
+  type: Div
 };
 const renderCallStack = (row, selectedIndex, rowIndex) => {
   const {
-    text: text$1,
     description,
     hasArrow,
-    index
+    index,
+    text: text$1
   } = row;
   const childCount = hasArrow ? 3 : 2;
   const arrowNodes = getArrowNodes(hasArrow);
   const isSelected = rowIndex === selectedIndex;
   const className = getDebugRowClassName('DebugRow DebugRowCallStack', isSelected);
   return [{
-    type: Div,
-    className,
-    role: TreeItem,
     ariaLevel: 2,
     childCount,
+    className,
+    'data-index': index,
     onClick: HandleClickCallStackItem,
-    'data-index': index
+    role: TreeItem,
+    type: Div
   }, ...arrowNodes, labelNode, text(text$1), descriptionNode, text(description)];
 };
 
@@ -5017,58 +5108,58 @@ const Text = 'text';
 
 const renderCheckBox = (row, selectedIndex, rowIndex) => {
   const {
-    text: text$1,
     expanded,
-    name,
     index,
+    name,
     posInset,
-    setSize
+    setSize,
+    text: text$1
   } = row;
   const isSelected = rowIndex === selectedIndex;
   const className = getDebugRowClassName(DebugRow, isSelected);
   return [{
-    type: Div,
-    className,
-    role: TreeItem,
     ariaLevel: 2,
-    childCount: 2,
     ariaPosInSet: posInset,
     ariaSetSize: setSize,
-    'data-index': index
+    childCount: 2,
+    className,
+    'data-index': index,
+    role: TreeItem,
+    type: Div
   }, {
-    type: Input,
-    inputType: CheckBox,
-    name,
     checked: expanded,
     childCount: 0,
+    id: name,
+    inputType: CheckBox,
+    name,
     onChange: HandleClickCheckBox,
-    id: name
+    type: Input
   }, {
-    type: Label,
+    childCount: 1,
     className: InputLabel,
     htmlFor: name,
-    childCount: 1
+    type: Label
   }, text(text$1)];
 };
 
 const getDebugValueClassName = valueType => {
   switch (valueType) {
-    case Undefined:
-      return DebugValueUndefined;
-    case Number$1:
-      return DebugValueNumber;
-    case Symbol:
-      return DebugValueSymbol;
     case Boolean$1:
       return DebugValueBoolean;
-    case String$1:
-      return DebugValueString;
-    case Object$1:
-      return DebugValueObject;
     case Function:
       return DebugValueFunction;
     case Getter:
       return DebugValueGetter;
+    case Number$1:
+      return DebugValueNumber;
+    case Object$1:
+      return DebugValueObject;
+    case String$1:
+      return DebugValueString;
+    case Symbol$1:
+      return DebugValueSymbol;
+    case Undefined:
+      return DebugValueUndefined;
     default:
       return '';
   }
@@ -5078,13 +5169,13 @@ const separator = text(': ');
 
 const renderValue = (row, selectedIndex, rowIndex, tokenColoringEnabled) => {
   const {
+    expanded,
     indent,
+    index,
     key,
-    value,
-    valueType,
-    expanded,
     tokens,
-    index
+    value,
+    valueType
   } = row;
   const isSelected = rowIndex === selectedIndex;
   const className = getDebugRowClassName(DebugRow, isSelected);
@@ -5094,141 +5185,161 @@ const renderValue = (row, selectedIndex, rowIndex, tokenColoringEnabled) => {
     valueChildren = [];
     for (let i = 0; i < tokens.length; i += 2) {
       valueChildren.push({
-        type: Span,
-        className: `DebugToken DebugToken${tokens[i + 1]}`,
         childCount: 1,
-        children: [text(tokens[i])]
+        children: [text(tokens[i])],
+        className: `DebugToken DebugToken${tokens[i + 1]}`,
+        type: Span
       });
     }
   } else {
     valueChildren = [text(value)];
   }
   return [{
-    type: Div,
-    className: className,
-    role: TreeItem,
     ariaExpanded: expanded,
     ariaLevel: 3,
-    paddingLeft: indent,
-    onPointerDown: HandleClickScopeValue,
     childCount: 3,
-    'data-index': index
+    className: className,
+    'data-index': index,
+    onPointerDown: HandleClickScopeValue,
+    paddingLeft: indent,
+    role: TreeItem,
+    type: Div
   }, {
-    type: Span,
+    childCount: 1,
     className: 'DebugValue DebugPropertyKey',
-    childCount: 1
+    type: Span
   }, text(key), separator, {
-    type: Span,
+    childCount: hasTokens ? valueChildren.length / 2 : 1,
     className: mergeClassNames(DebugValue, getDebugValueClassName(valueType)),
-    childCount: hasTokens ? valueChildren.length / 2 : 1
+    type: Span
   }, ...valueChildren];
 };
 
 const renderInputField = (row, selectedIndex, rowIndex) => {
   const {
-    text,
-    name
+    name,
+    text
   } = row;
   const isSelected = rowIndex === selectedIndex;
   const className = getDebugRowClassName(`${DebugRow} ${DebugRowInputField}`, isSelected);
   return [{
-    type: Div,
+    ariaLevel: 2,
+    childCount: 1,
     className,
     role: TreeItem,
-    ariaLevel: 2,
-    childCount: 1
+    type: Div
   }, {
-    type: Input,
-    inputType: Text,
-    spellcheck: false,
     autocapitalize: 'off',
     autocorrect: 'off',
+    childCount: 0,
     className: InputBox,
+    id: name,
+    inputType: Text,
     name,
-    value: text,
-    childCount: 0,
-    onInput: HandleInputFieldChange,
     onBlur: HandleInputBlur,
-    id: name
+    onInput: HandleInputFieldChange,
+    spellcheck: false,
+    type: Input,
+    value: text
   }];
 };
 
+const renderMissingDebugProvider = row => {
+  return [{
+    childCount: 2,
+    className: 'MissingDebugProvider',
+    style: 'display:flex;flex-direction:column;align-items:flex-start;gap:8px;padding:12px;white-space:normal;line-height:1.4;color:var(--TitleBarForeground);',
+    type: Div
+  }, {
+    childCount: 1,
+    className: 'MissingDebugProviderText',
+    style: 'white-space:normal;',
+    type: Div
+  }, text(row.text), {
+    childCount: 1,
+    className: 'Button ButtonSecondary MissingDebugProviderButton',
+    onClick: HandleClickOpenExtensions,
+    title: openExtensions$1(),
+    type: Button
+  }, text(openExtensions$1())];
+};
+
 const renderScope = (row, selectedIndex, rowIndex) => {
   const {
-    key,
     expanded,
-    index
+    index,
+    key
   } = row;
   const isSelected = rowIndex === selectedIndex;
   const className = getDebugRowClassName(DebugRow, isSelected);
   return [{
-    type: Div,
-    className,
-    role: TreeItem,
     ariaExpanded: expanded,
     ariaLevel: 2,
     childCount: 2,
-    onPointerDown: HandleClickScopeValue,
+    className,
+    'data-index': index,
     'data-name': key,
-    'data-index': index
+    onPointerDown: HandleClickScopeValue,
+    role: TreeItem,
+    type: Div
   }, expanded ? getChevronDownVirtualDom() : getChevronRightVirtualDom(), {
-    type: Span,
+    childCount: 1,
     className: mergeClassNames(DebugValue, DebugValueScopeName),
-    childCount: 1
+    type: Span
   }, text(key)];
 };
 
 const renderWatchExpression = (row, selectedIndex, rowIndex) => {
   const {
-    value,
+    index,
     key,
-    index
+    value
   } = row;
   const isSelected = rowIndex === selectedIndex;
   const className = getDebugRowClassName(DebugRow, isSelected);
   return [{
-    type: Div,
-    className,
-    role: TreeItem,
     childCount: 4,
+    className,
     'data-index': index,
     onClick: HandleClickWatchExpression,
     // TODO use doubleclick
-    onContextMenu: HandleWatchExpressionContextMenu
+    onContextMenu: HandleWatchExpressionContextMenu,
+    role: TreeItem,
+    type: Div
   }, {
-    type: Span,
+    childCount: 1,
     className: DebugValueScopeName,
-    childCount: 1
+    type: Span
   }, text(key), separator, {
-    type: Span,
+    childCount: 1,
     className: DebugValue,
-    childCount: 1
+    type: Span
   }, text(value), {
-    type: Button,
-    title: deleteWatchExpression$1(),
+    childCount: 1,
     className: mergeClassNames(IconButton, DebugSectionAction, DeleteWatchExpression),
     'data-index': index,
     onClick: HandleClickWatchExpressionDelete,
-    childCount: 1
+    title: deleteWatchExpression$1(),
+    type: Button
   }, text('×')];
 };
 
 const renderWatchMessage = (row, selectedIndex, rowIndex) => {
   const {
-    text: text$1,
     index,
     posInset,
-    setSize
+    setSize,
+    text: text$1
   } = row;
   const isSelected = rowIndex === selectedIndex;
   const className = getDebugRowClassName('DebugRow WatchMessage', isSelected);
   return [{
-    type: Div,
-    className,
+    ariaPosInSet: posInset,
+    ariaSetSize: setSize,
     childCount: 1,
+    className,
     'data-index': index,
-    ariaPosInSet: posInset,
-    ariaSetSize: setSize
+    type: Div
   }, text(text$1)];
 };
 
@@ -5236,43 +5347,45 @@ const renderNoop = (row, selectedIndex, rowIndex) => {
   const isSelected = rowIndex === selectedIndex;
   const className = getDebugRowClassName(DebugRow, isSelected);
   return [{
-    type: Div,
+    childCount: 1,
     className,
-    childCount: 1
+    type: Div
   }, text('unknown row type')];
 };
 const renderMessage = (row, selectedIndex, rowIndex) => {
   const isSelected = rowIndex === selectedIndex;
   const className = getDebugRowClassName('DebugPausedMessage', isSelected);
   return [{
-    type: Div,
+    childCount: 1,
     className,
-    childCount: 1
+    type: Div
   }, text(row.text)];
 };
 
 const getRowRenderer = type => {
   switch (type) {
-    case Message:
-      return renderMessage;
-    case SectionHeading:
-      return renderSectionHeading;
     case CallStack$3:
       return renderCallStack;
-    case Scope$4:
-      return renderScope;
-    case Value:
-    case Property$1:
-    case Exception$2:
-      return renderValue;
     case CheckBox$1:
       return renderCheckBox;
-    case WatchMessage:
-      return renderWatchMessage;
-    case WatchExpression:
-      return renderWatchExpression;
+    case Exception$2:
+    case Property$1:
+    case Value:
+      return renderValue;
     case InputField:
       return renderInputField;
+    case Message:
+      return renderMessage;
+    case MissingDebugProvider:
+      return renderMissingDebugProvider;
+    case Scope$4:
+      return renderScope;
+    case SectionHeading:
+      return renderSectionHeading;
+    case WatchExpression:
+      return renderWatchExpression;
+    case WatchMessage:
+      return renderWatchMessage;
     default:
       return renderNoop;
   }
@@ -5285,11 +5398,11 @@ const getRunAndDebugRowVirtualDom = (row, selectedIndex, rowIndex, tokenColoring
 
 const getRunAndDebugVirtualDom2 = (rows, selectedIndex, tokenColoringEnabled) => {
   return [{
-    type: Div,
+    childCount: rows.length,
     className: 'Viewlet RunAndDebug',
+    role: Tree,
     tabIndex: 0,
-    childCount: rows.length,
-    role: Tree
+    type: Div
   }, ...rows.flatMap((row, index) => getRunAndDebugRowVirtualDom(row, selectedIndex, index, tokenColoringEnabled))];
 };
 
@@ -5316,8 +5429,8 @@ const renderPauseOnExceptions = (oldState, newState) => {
 
 const renderSelection = (oldState, newState) => {
   const {
-    editingselectionstart,
     editingselectionend,
+    editingselectionstart,
     focus,
     uid: id
   } = newState;
@@ -5327,18 +5440,18 @@ const renderSelection = (oldState, newState) => {
 
 const getRenderer = diffType => {
   switch (diffType) {
-    case RenderItems:
-      return renderItems;
-    case RenderFocusContext:
-      return renderFocusContext;
     case RenderFocus:
       return renderFocus;
-    case RenderValue:
-      return renderInputValue;
-    case RenderSelection:
-      return renderSelection;
+    case RenderFocusContext:
+      return renderFocusContext;
+    case RenderItems:
+      return renderItems;
     case RenderPauseOnExceptions:
       return renderPauseOnExceptions;
+    case RenderSelection:
+      return renderSelection;
+    case RenderValue:
+      return renderInputValue;
     default:
       throw new Error('unknown renderer');
   }
@@ -5355,8 +5468,8 @@ const applyRender = (oldState, newState, diffResult) => {
 
 const render2 = (uid, diffResult) => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   set(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
@@ -5378,37 +5491,37 @@ const getDebugButtons = debugState => {
   const debugButtons = [];
   if (debugState === Paused) {
     debugButtons.push({
-      title: resume$1(),
+      fn: DebugResume,
       icon: DebugContinue,
-      fn: DebugResume
+      title: resume$1()
     });
   } else {
     debugButtons.push({
-      title: pause$1(),
+      fn: DebugPause$1,
       icon: DebugPause,
-      fn: DebugPause$1
+      title: pause$1()
     });
   }
   debugButtons.push({
-    title: stepOver$1(),
+    fn: DebugStepOver$1,
     icon: DebugStepOver,
-    fn: DebugStepOver$1
+    title: stepOver$1()
   }, {
-    title: stepInto$1(),
+    fn: DebugStepInto$1,
     icon: DebugStepInto,
-    fn: DebugStepInto$1
+    title: stepInto$1()
   }, {
-    title: stepOut$1(),
+    fn: DebugStepOut$1,
     icon: DebugStepOut,
-    fn: DebugStepOut$1
+    title: stepOut$1()
   }, {
-    title: restart(),
+    fn: DebugRestart$1,
     icon: DebugRestart,
-    fn: DebugRestart$1
+    title: restart()
   }, {
-    title: stop$1(),
+    fn: DebugStop$1,
     icon: DebugStop,
-    fn: DebugStop$1
+    title: stop$1()
   });
   return debugButtons;
 };
@@ -5416,31 +5529,31 @@ const getDebugButtons = debugState => {
 const DebugButtonClass = IconButton + ' ' + DebugButton;
 const getDebugButtonVirtualDom = button => {
   const {
-    title,
+    fn,
     icon,
-    fn
+    title
   } = button;
   return [{
-    type: Button,
+    childCount: 1,
     className: mergeClassNames(DebugButtonClass, icon),
+    name: fn,
     title,
-    childCount: 1,
-    name: fn
+    type: Button
   }, {
-    type: Div,
+    childCount: 0,
     className: `MaskIcon MaskIcon${icon}`,
-    childCount: 0
+    type: Div
   }];
 };
 
 const getRunAndDebugButtonsVirtualDom = debugState => {
   const debugButtons = getDebugButtons(debugState);
   const dom = [{
-    type: Div,
-    className: DebugButtons,
     childCount: debugButtons.length,
+    className: DebugButtons,
+    onClick: HandleClickDebugButton,
     role: ToolBar,
-    onClick: HandleClickDebugButton
+    type: Div
   }, ...debugButtons.flatMap(getDebugButtonVirtualDom)];
   return dom;
 };
@@ -5450,8 +5563,8 @@ const renderActions = uid => {
     newState
   } = get(uid);
   const {
-    scopeExpanded,
-    debugState
+    debugState,
+    scopeExpanded
   } = newState;
   if (debugState === Unavailable) {
     return [];
@@ -5528,6 +5641,9 @@ const renderEventListeners = () => {
   }, {
     name: HandleClickSectionAction,
     params: ['handleClickSectionAction', 'event.target.name']
+  }, {
+    name: HandleClickOpenExtensions,
+    params: ['handleClickOpenExtensions']
   }, {
     name: HandleInputBlur,
     params: ['handleInputBlur']
@@ -5549,36 +5665,36 @@ const saveState = (uid, reason) => {
     newState
   } = get(uid);
   const {
-    watchExpressions,
-    scopeExpanded,
-    watchExpanded,
     breakPointsExpanded,
-    focus,
     editingValue,
-    inputSource
+    focus,
+    inputSource,
+    scopeExpanded,
+    watchExpanded,
+    watchExpressions
   } = newState;
   if (reason === SaveStateReasonHotReload) {
     return {
-      watchExpressions,
-      scopeExpanded,
       breakPointsExpanded,
-      watchExpanded,
-      focus,
       editingValue,
-      inputSource
+      focus,
+      inputSource,
+      scopeExpanded,
+      watchExpanded,
+      watchExpressions
     };
   }
   return {
+    breakPointsExpanded,
+    editingValue: '',
+    focus: 0,
+    inputSource: 0,
+    scopeExpanded,
+    watchExpanded,
     watchExpressions: watchExpressions.map(expr => ({
       ...expr,
       isEditing: false
-    })),
-    scopeExpanded,
-    breakPointsExpanded,
-    watchExpanded,
-    focus: 0,
-    editingValue: '',
-    inputSource: 0
+    }))
   };
 };
 
@@ -5651,7 +5767,6 @@ const commandMap = {
   'Debug.scriptParsed': scriptParsed,
   'Initialize.initialize': initialize,
   'RunAndDebug.acceptWatchExpressionEdit': wrapCommand(acceptWatchExpressionEdit),
-  'RunAndDebug.getMenuIds': getMenuIds,
   'RunAndDebug.addWatchExpression': wrapCommand(addWatchExpression),
   'RunAndDebug.cancelWatchExpressionEdit': wrapCommand(cancelWatchExpressionEdit),
   'RunAndDebug.create': create,
@@ -5665,6 +5780,7 @@ const commandMap = {
   'RunAndDebug.getHighlight': getHighlight,
   'RunAndDebug.getKeyBindings': getKeyBindings,
   'RunAndDebug.getMenuEntries': getMenuEntries,
+  'RunAndDebug.getMenuIds': getMenuIds,
   'RunAndDebug.handleArrowDown': wrapCommand(handleArrowDown),
   'RunAndDebug.handleArrowLeft': wrapCommand(handleArrowLeft),
   'RunAndDebug.handleArrowRight': wrapCommand(handleArrowRight),
@@ -5673,6 +5789,7 @@ const commandMap = {
   'RunAndDebug.handleClickCallStackItem': wrapCommand(handleClickCallstackItem),
   'RunAndDebug.handleClickCheckBox': wrapCommand(handleClickCheckBox),
   'RunAndDebug.handleClickDebugButton': wrapCommand(handleClickDebugButton),
+  'RunAndDebug.handleClickOpenExtensions': wrapCommand(handleClickOpenExtensions),
   'RunAndDebug.handleClickPauseOnExceptions': wrapCommand(handleClickPauseOnExceptions),
   'RunAndDebug.handleClickPauseOnUncaughtExceptions': wrapCommand(handleClickPauseOnUncaughtExceptions),
   'RunAndDebug.handleClickScopeValue': wrapCommand(handleClickScopeValue),
@@ -5685,17 +5802,17 @@ const commandMap = {
   'RunAndDebug.handleClickWatchExpression': wrapCommand(handleClickWatchExpression),
   'RunAndDebug.handleClickWatchExpressionDelete': wrapCommand(handleClickWatchExpressionDelete),
   'RunAndDebug.handleCopy': wrapCommand(handleCopy),
-  'RunAndDebug.handleNew': wrapCommand(handleNew),
   'RunAndDebug.handleDebugInput': wrapCommand(handleDebugInput),
+  'RunAndDebug.handleDelete': wrapCommand(handleDelete),
+  'RunAndDebug.handleEnter': wrapCommand(handleEnter),
   'RunAndDebug.handleEvaluate': wrapCommand(handleEvaluate),
   'RunAndDebug.handleInputBlur': wrapCommand(handleInputBlur),
   'RunAndDebug.handleInputFieldChange': wrapCommand(handleInputFieldChange),
+  'RunAndDebug.handleNew': wrapCommand(handleNew),
   // eslint-disable-next-line  @typescript-eslint/no-deprecated
   'RunAndDebug.handlePaused': wrapCommand(handlePaused),
-  'RunAndDebug.handleResumed': wrapCommand(handleResumed),
-  'RunAndDebug.handleDelete': wrapCommand(handleDelete),
-  'RunAndDebug.handleEnter': wrapCommand(handleEnter),
   'RunAndDebug.handleRename': wrapCommand(handleRename),
+  'RunAndDebug.handleResumed': wrapCommand(handleResumed),
   'RunAndDebug.handleScriptParsed': wrapCommand(handleScriptParsed),
   'RunAndDebug.handleSectionHeaderContextMenu': wrapCommand(handleSectionHeaderContextMenu),
   'RunAndDebug.handleSpace': wrapCommand(handleSpace),