@lvce-editor/editor-worker 19.17.4 → 19.18.1

package/dist/editorWorkerMain.js

@@ -3,10 +3,67 @@ const toCommandId = key => {
   return key.slice(dotIndex + 1);
 };
 const create$j = () => {
+  const commandQueues = new Map();
+  const generations = Object.create(null);
   const states = Object.create(null);
   const commandMapRef = {};
+  const getGeneration = uid => generations[uid] || 0;
+  const isCurrentGeneration = (uid, generation) => {
+    return states[uid] !== undefined && getGeneration(uid) === generation;
+  };
+  const updateState = (uid, generation, fallbackState, updater) => {
+    if (!isCurrentGeneration(uid, generation)) {
+      return Promise.resolve(fallbackState);
+    }
+    const current = states[uid];
+    const updatedState = updater(current.newState);
+    if (updatedState !== current.newState) {
+      states[uid] = {
+        newState: updatedState,
+        oldState: current.oldState,
+        scheduledState: updatedState
+      };
+    }
+    return Promise.resolve(updatedState);
+  };
+  const createAsyncCommandContext = (uid, generation) => {
+    let latestState = states[uid].newState;
+    return {
+      getState: () => {
+        if (isCurrentGeneration(uid, generation)) {
+          latestState = states[uid].newState;
+        }
+        return latestState;
+      },
+      updateState: async updater => {
+        latestState = await updateState(uid, generation, latestState, updater);
+        return latestState;
+      }
+    };
+  };
+  const enqueueCommand = async (uid, command) => {
+    const previous = commandQueues.get(uid) || Promise.resolve();
+    const run = async () => {
+      try {
+        await previous;
+      } catch {
+        // The previous caller receives its error; later commands must still run.
+      }
+      await command();
+    };
+    const current = run();
+    commandQueues.set(uid, current);
+    try {
+      await current;
+    } finally {
+      if (commandQueues.get(uid) === current) {
+        commandQueues.delete(uid);
+      }
+    }
+  };
   return {
     clear() {
+      commandQueues.clear();
       for (const key of Object.keys(states)) {
         delete states[key];
       }
@@ -26,6 +83,7 @@ const create$j = () => {
       return diffResult;
     },
     dispose(uid) {
+      commandQueues.delete(uid);
       delete states[uid];
     },
     get(uid) {
@@ -43,14 +101,27 @@ const create$j = () => {
       Object.assign(commandMapRef, commandMap);
     },
     set(uid, oldState, newState, scheduledState) {
+      const current = states[uid];
+      if (!current || oldState === newState && newState !== current.newState) {
+        generations[uid] = getGeneration(uid) + 1;
+      }
       states[uid] = {
         newState,
         oldState,
         scheduledState: scheduledState ?? newState
       };
     },
+    wrapAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const context = createAsyncCommandContext(uid, generation);
+        await fn(context, ...args);
+      };
+      return wrapped;
+    },
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -59,6 +130,9 @@ const create$j = () => {
         if (oldState === newerState || newState === newerState) {
           return;
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return;
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -83,6 +157,7 @@ const create$j = () => {
     },
     wrapLoadContent(fn) {
       const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
         const {
           newState,
           oldState
@@ -97,6 +172,11 @@ const create$j = () => {
             error
           };
         }
+        if (!isCurrentGeneration(uid, generation)) {
+          return {
+            error
+          };
+        }
         const latestOld = states[uid];
         const latestNew = {
           ...latestOld.newState,
@@ -112,6 +192,51 @@ const create$j = () => {
         };
       };
       return wrapped;
+    },
+    wrapSerialAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const context = createAsyncCommandContext(uid, generation);
+          await fn(context, ...args);
+        });
+      };
+      return wrapped;
+    },
+    wrapSerialCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const {
+            newState,
+            oldState
+          } = states[uid];
+          const newerState = await fn(newState, ...args);
+          if (oldState === newerState || newState === newerState) {
+            return;
+          }
+          if (!isCurrentGeneration(uid, generation)) {
+            return;
+          }
+          const latestOld = states[uid];
+          const latestNew = {
+            ...latestOld.newState,
+            ...newerState
+          };
+          states[uid] = {
+            newState: latestNew,
+            oldState: latestOld.oldState,
+            scheduledState: latestNew
+          };
+        });
+      };
+      return wrapped;
     }
   };
 };
@@ -284,7 +409,6 @@ const walkValue = (value, transferrables, isTransferrable) => {
     for (const property of Object.values(value)) {
       walkValue(property, transferrables, isTransferrable);
     }
-    return;
   }
 };
 const getTransferrables = value => {
@@ -438,7 +562,14 @@ class IpcError extends VError {
       const cause = new Error(message);
       // @ts-ignore
       cause.code = code;
-      cause.stack = stack;
+      if (stack) {
+        Object.defineProperty(cause, 'stack', {
+          configurable: true,
+          enumerable: false,
+          value: stack,
+          writable: true
+        });
+      }
       super(cause, betterMessage);
     } else {
       super(betterMessage);
@@ -725,7 +856,10 @@ const constructError = (message, type, name) => {
   if (ErrorConstructor === Error) {
     const error = new Error(message);
     if (name && name !== 'VError') {
-      error.name = name;
+      Object.defineProperty(error, 'name', {
+        configurable: true,
+        value: name
+      });
     }
     return error;
   }
@@ -742,8 +876,10 @@ const getCurrentStack = () => {
   const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$1, startIndex);
+const getNewLineIndex = (string, startIndex) => {
+  {
+    return string.indexOf(NewLine$1);
+  }
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
@@ -754,55 +890,91 @@ const getParentStack = error => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
+const setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, 'stack');
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
+    }
+  }
+  Object.defineProperty(error, 'stack', {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
+};
+const restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === 'string') {
+    setStack(error, `${error.stack}${NewLine$1}${currentStack}`);
+  }
+  return error;
+};
+const restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  const parentStack = getParentStack(error);
+  setStack(restoredError, `${parentStack}${NewLine$1}${currentStack}`);
+  return restoredError;
+};
+const restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine$1}${error.data.stack}${NewLine$1}${currentStack}`);
+    return;
+  }
+  if (error.data.stack) {
+    setStack(restoredError, error.data.stack);
+  }
+};
+const applyDataProperties = (restoredError, error) => {
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (error.data.code) {
+    // @ts-ignore
+    restoredError.code = error.data.code;
+  }
+  if (error.data.type) {
+    // @ts-ignore
+    restoredError.name = error.data.type;
+  }
+};
+const applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || '';
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    // @ts-ignore
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+  }
+  if (error.codeFrame) {
+    // @ts-ignore
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+const restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type, error.name);
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
-    if (typeof error.stack === 'string') {
-      error.stack = error.stack + NewLine$1 + currentStack;
-    }
-    return error;
+    return restoreExistingError(error, currentStack);
   }
   if (error && error.code && error.code === MethodNotFound) {
-    const restoredError = new JsonRpcError(error.message);
-    const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine$1 + currentStack;
-    return restoredError;
+    return restoreMethodNotFoundError(error, currentStack);
   }
   if (error && error.message) {
-    const restoredError = constructError(error.message, error.type, error.name);
-    if (error.data) {
-      if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine$1 + error.data.stack + NewLine$1 + currentStack;
-      } else if (error.data.stack) {
-        restoredError.stack = error.data.stack;
-      }
-      if (error.data.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.data.codeFrame;
-      }
-      if (error.data.code) {
-        // @ts-ignore
-        restoredError.code = error.data.code;
-      }
-      if (error.data.type) {
-        // @ts-ignore
-        restoredError.name = error.data.type;
-      }
-    } else {
-      if (error.stack) {
-        const lowerStack = restoredError.stack || '';
-        // @ts-ignore
-        const indexNewLine = getNewLineIndex(lowerStack);
-        const parentStack = getParentStack(error);
-        // @ts-ignore
-        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
-      }
-      if (error.codeFrame) {
-        // @ts-ignore
-        restoredError.codeFrame = error.codeFrame;
-      }
-    }
-    return restoredError;
+    return restoreMessageError(error);
   }
   if (typeof error === 'string') {
     return new Error(`JsonRpc Error: ${error}`);
@@ -1225,7 +1397,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$f = (id, rpc) => {
+const set$h = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$8 = id => {
@@ -1258,7 +1430,7 @@ const create$9 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$f(rpcId, mockRpc);
+      set$h(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove$8(rpcId);
@@ -1267,20 +1439,187 @@ const create$9 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$f(rpcId, rpc);
+      set$h(rpcId, rpc);
     }
   };
 };
 
+const Audio = 0;
+const Button$1 = 1;
+const Col = 2;
+const ColGroup = 3;
+const Div$1 = 4;
+const H1 = 5;
+const Input$1 = 6;
+const Kbd = 7;
+const Span$1 = 8;
+const Table = 9;
+const TBody = 10;
+const Td = 11;
 const Text$1 = 12;
+const Th = 13;
+const THead = 14;
+const Tr = 15;
+const I = 16;
+const Img = 17;
+const Root = 0;
+const Ins = 20;
+const Del = 21;
+const H2 = 22;
+const H3 = 23;
+const H4 = 24;
+const H5 = 25;
+const H6 = 26;
+const Article = 27;
+const Aside = 28;
+const Footer = 29;
+const Header = 30;
+const Nav = 40;
+const Section = 41;
+const Search = 42;
+const Dd = 43;
+const Dl = 44;
+const Figcaption = 45;
+const Figure = 46;
+const Hr = 47;
+const Li = 48;
+const Ol = 49;
+const P = 50;
+const Pre = 51;
+const A = 53;
+const Abbr = 54;
+const Br = 55;
+const Cite = 56;
+const Data = 57;
+const Time = 58;
+const Tfoot = 59;
+const Ul = 60;
+const Video = 61;
+const TextArea$1 = 62;
+const Select = 63;
+const Option = 64;
+const Code = 65;
+const Label = 66;
+const Dt = 67;
+const Iframe = 68;
+const Main = 69;
+const Strong = 70;
+const Em = 71;
+const Style = 72;
+const Html = 73;
+const Head = 74;
+const Title = 75;
+const Meta = 76;
+const Canvas = 77;
+const Form = 78;
+const BlockQuote = 79;
+const Quote = 80;
+const Circle = 81;
+const Defs = 82;
+const Ellipse = 83;
+const G = 84;
+const Line = 85;
+const Path = 86;
+const Polygon = 87;
+const Polyline = 88;
+const Rect = 89;
+const Svg = 90;
+const Use = 91;
 const Reference = 100;
 
+const VirtualDomElements = {
+  __proto__: null,
+  A,
+  Abbr,
+  Article,
+  Aside,
+  Audio,
+  BlockQuote,
+  Br,
+  Button: Button$1,
+  Canvas,
+  Circle,
+  Cite,
+  Code,
+  Col,
+  ColGroup,
+  Data,
+  Dd,
+  Defs,
+  Del,
+  Div: Div$1,
+  Dl,
+  Dt,
+  Ellipse,
+  Em,
+  Figcaption,
+  Figure,
+  Footer,
+  Form,
+  G,
+  H1,
+  H2,
+  H3,
+  H4,
+  H5,
+  H6,
+  Head,
+  Header,
+  Hr,
+  Html,
+  I,
+  Iframe,
+  Img,
+  Input: Input$1,
+  Ins,
+  Kbd,
+  Label,
+  Li,
+  Line,
+  Main,
+  Meta,
+  Nav,
+  Ol,
+  Option,
+  P,
+  Path,
+  Polygon,
+  Polyline,
+  Pre,
+  Quote,
+  Rect,
+  Reference,
+  Root,
+  Search,
+  Section,
+  Select,
+  Span: Span$1,
+  Strong,
+  Style,
+  Svg,
+  TBody,
+  THead,
+  Table,
+  Td,
+  Text: Text$1,
+  TextArea: TextArea$1,
+  Tfoot,
+  Th,
+  Time,
+  Title,
+  Tr,
+  Ul,
+  Use,
+  Video
+};
+
 const AltKey = 'event.altKey';
 const Button = 'event.button';
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
 const DeltaMode = 'event.deltaMode';
 const DeltaY = 'event.deltaY';
+const Key = 'event.key';
 
 const Backspace = 1;
 const Tab$1 = 2;
@@ -1339,6 +1678,7 @@ const Electron = 2;
 const CompletionWorker = 301;
 const DebugWorker = 55;
 const EditorWorker = 99;
+const ErrorWorker = 3308;
 const ExtensionHostWorker = 44;
 const ExtensionManagementWorker = 9006;
 const IconThemeWorker = 7009;
@@ -1346,27 +1686,32 @@ const MarkdownWorker = 300;
 const OpenerWorker = 4561;
 const RendererWorker$1 = 1;
 
-const FocusSelector = 'Viewlet.focusSelector';
+const FocusSelector$1 = 'Viewlet.focusSelector';
 const SetCss$1 = 'Viewlet.setCss';
 const SetFocusContext$1 = 'Viewlet.setFocusContext';
 const SetPatches = 'Viewlet.setPatches';
 
 const FocusEditorText$1 = 12;
 
+const {
+  invoke: invoke$g,
+  set: set$g
+} = create$9(ErrorWorker);
+
 const {
   invoke: invoke$f,
-  set: set$e
+  set: set$f
 } = create$9(ExtensionHostWorker);
 
 const ExtensionHost = {
   __proto__: null,
   invoke: invoke$f,
-  set: set$e
+  set: set$f
 };
 
 const {
   invoke: invoke$e,
-  set: set$d
+  set: set$e
 } = create$9(ExtensionManagementWorker);
 const getLanguages$1 = (platform, assetDir) => {
   return invoke$e('Extensions.getLanguages', platform, assetDir);
@@ -1374,7 +1719,7 @@ const getLanguages$1 = (platform, assetDir) => {
 
 const {
   invoke: invoke$d,
-  set: set$c
+  set: set$d
 } = create$9(OpenerWorker);
 const openUrl = async (url, platform) => {
   return invoke$d('Open.openUrl', url, platform);
@@ -1382,13 +1727,13 @@ const openUrl = async (url, platform) => {
 
 const {
   invoke: invoke$c,
-  set: set$b
+  set: set$c
 } = create$9(IconThemeWorker);
 
 const {
   invoke: invoke$b,
   invokeAndTransfer,
-  set: set$a
+  set: set$b
 } = create$9(RendererWorker$1);
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
@@ -1401,6 +1746,10 @@ const sendMessagePortToOpenerWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
 };
+const sendMessagePortToErrorWorker = async (port, rpcId) => {
+  const command = 'Errors.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
 const readFile = async uri => {
   return invoke$b('FileSystem.readFile', uri);
 };
@@ -1448,25 +1797,26 @@ const RendererWorker = {
   openUri,
   readClipBoardText,
   readFile,
+  sendMessagePortToErrorWorker,
   sendMessagePortToExtensionHostWorker,
   sendMessagePortToExtensionManagementWorker: sendMessagePortToExtensionManagementWorker$1,
   sendMessagePortToOpenerWorker,
   sendMessagePortToSyntaxHighlightingWorker: sendMessagePortToSyntaxHighlightingWorker$1,
   sendMessagePortToTextMeasurementWorker,
-  set: set$a,
+  set: set$b,
   showContextMenu2,
   writeClipBoardText
 };
 
 const {
   invoke: invoke$a,
-  set: set$9
+  set: set$a
 } = create$9(MarkdownWorker);
 
 const SyntaxHighlightingWorker = {
   __proto__: null,
   invoke: invoke$a,
-  set: set$9
+  set: set$a
 };
 
 const createLazyRpc = rpcId => {
@@ -1474,7 +1824,7 @@ const createLazyRpc = rpcId => {
   let factory;
   const createRpc = async () => {
     const rpc = await factory();
-    set$f(rpcId, rpc);
+    set$h(rpcId, rpc);
   };
   const ensureRpc = async () => {
     if (!rpcPromise) {
@@ -1584,7 +1934,7 @@ const getKeys$2 = () => {
   const keys = editorStates.getKeys();
   return keys.map(String);
 };
-const set$8 = (id, oldEditor, newEditor) => {
+const set$9 = (id, oldEditor, newEditor) => {
   editorStates.set(id, oldEditor, newEditor);
 };
 
@@ -1685,7 +2035,7 @@ const createEditor2 = (id, uri, x, y, width, height, platform, assetDir) => {
     x,
     y
   };
-  set$8(id, editor, editor);
+  set$9(id, editor, editor);
 };
 
 // TODO use numeric enum
@@ -1708,7 +2058,7 @@ const Rename = 'rename';
 const ToggleBlockComment$1 = 'toggleBlockComment';
 
 const map$1 = Object.create(null);
-const set$7 = (id, widget) => {
+const set$8 = (id, widget) => {
   map$1[id] = widget;
 };
 const get$6 = id => {
@@ -1756,6 +2106,7 @@ const clamp = (num, min, max) => {
 };
 
 const Link$1 = 'Link';
+const EditorGoToDefinitionLink = 'EditorGoToDefinitionLink';
 const Function = 'Function';
 const Parameter = 'Parameter';
 const Type = 'Type';
@@ -1763,6 +2114,7 @@ const VariableName = 'VariableName';
 const Class = 'Class';
 
 const Link = 1;
+const DefinitionLink = 2;
 const Ts2816 = 2816;
 const Ts2817 = 2817;
 const Ts2824 = 2824;
@@ -1803,6 +2155,10 @@ const Ts272 = 272;
 
 const getDecorationClassName = type => {
   switch (type) {
+    case 3:
+      return 'R';
+    case DefinitionLink:
+      return EditorGoToDefinitionLink;
     case Link:
       return Link$1;
     case Ts1024:
@@ -1948,7 +2304,7 @@ const getEnabled$1 = () => {
 
 const {
   invoke: invoke$8,
-  set: set$6
+  set: set$7
 } = SyntaxHighlightingWorker;
 
 const state$9 = {
@@ -1959,7 +2315,7 @@ const state$9 = {
 const has = languageId => {
   return Object.hasOwn(state$9.tokenizers, languageId);
 };
-const set$5 = (languageId, tokenizer) => {
+const set$6 = (languageId, tokenizer) => {
   state$9.tokenizers[languageId] = tokenizer;
 };
 const get$5 = languageId => {
@@ -1983,7 +2339,7 @@ const isPending = languageId => {
 };
 
 const tokenMaps = Object.create(null);
-const set$4 = (languageId, tokenMap) => {
+const set$5 = (languageId, tokenMap) => {
   tokenMaps[languageId] = tokenMap;
 };
 const get$4 = languageId => {
@@ -1999,7 +2355,7 @@ const loadTokenizer = async (languageId, tokenizePath) => {
   if (getEnabled$1()) {
     // @ts-ignore
     const tokenMap = await invoke$8('Tokenizer.load', languageId, tokenizePath);
-    set$4(languageId, tokenMap);
+    set$5(languageId, tokenMap);
     return;
   }
   try {
@@ -2015,8 +2371,8 @@ const loadTokenizer = async (languageId, tokenizePath) => {
       console.warn(`tokenizer.TokenMap should be an object in "${tokenizePath}"`);
       return;
     }
-    set$4(languageId, tokenizer.TokenMap);
-    set$5(languageId, tokenizer);
+    set$5(languageId, tokenizer.TokenMap);
+    set$6(languageId, tokenizer);
   } catch (error) {
     // TODO better error handling
     console.error(error);
@@ -2033,7 +2389,7 @@ const getTokenizer = languageId => {
 };
 
 const tokenizers = Object.create(null);
-const set$3 = (id, value) => {
+const set$4 = (id, value) => {
   tokenizers[id] = value;
 };
 const get$3 = id => {
@@ -3151,9 +3507,9 @@ const splitLines = lines => {
 const {
   invoke: invoke$7} = RendererWorker;
 
-const notifyTabModifiedStatusChange = async uri => {
+const notifyTabModifiedStatusChange = async (uri, modified) => {
   try {
-    await invoke$7('Main.handleModifiedStatusChange', uri, true);
+    await invoke$7('Main.handleModifiedStatusChange', uri, modified);
   } catch {
     // ignore
   }
@@ -3557,11 +3913,11 @@ const scheduleDocumentAndCursorsSelections = async (editor, changes, selectionCh
     ...newEditor,
     decorations: linkDecorations
   };
-  set$8(editor.uid, editor, newEditorWithDecorations);
+  set$9(editor.uid, editor, newEditorWithDecorations);
 
   // Notify main-area-worker about modified status change
   if (!editor.modified) {
-    await notifyTabModifiedStatusChange(editor.uri);
+    await notifyTabModifiedStatusChange(editor.uri, true);
   }
 
   // Notify registered listeners about editor changes
@@ -3773,7 +4129,7 @@ const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
 
 const {
   invoke: invoke$6,
-  set: set$2
+  set: set$3
 } = ExtensionHost;
 
 const getFileExtensionIndex = file => {
@@ -3844,6 +4200,26 @@ const get$2 = async key => {
   return value;
 };
 
+const logError = async (error, prefix) => {
+  const prettyError = await invoke$g('Errors.prepare', error);
+  await invoke$g('Errors.print', prettyError, prefix);
+};
+const logFallback = (error, prefix) => {
+  if (prefix) {
+    console.error(prefix, error);
+    return;
+  }
+  console.error(error);
+};
+const handleError$1 = async (error, prefix = '') => {
+  try {
+    await logError(error, prefix);
+  } catch (otherError) {
+    console.warn('ErrorHandling error', otherError);
+    logFallback(error, prefix);
+  }
+};
+
 const OnDiagnostic = 'onDiagnostic';
 const OnHover = 'onHover';
 const OnTabCompletion = 'onTabCompletion';
@@ -3986,11 +4362,11 @@ const addDiagnostics = async (editor, diagnostics) => {
     visualDecorations
   };
 };
-const handleError$1 = (error, editor) => {
+const handleError = async (error, editor) => {
   if (error instanceof Error && error.message.includes('No diagnostic provider found')) {
     return editor;
   }
-  console.error(`Failed to update diagnostics: ${error}`);
+  await handleError$1(error, 'Failed to update diagnostics: ');
   return editor;
 };
 const getEditorWithDiagnostics = async editor => {
@@ -4001,7 +4377,7 @@ const getEditorWithDiagnostics = async editor => {
     }
     return addDiagnostics(editor, diagnostics);
   } catch (error) {
-    return handleError$1(error, editor);
+    return handleError(error, editor);
   }
 };
 const updateDiagnostics = async editor => {
@@ -4012,12 +4388,12 @@ const updateDiagnostics = async editor => {
       return editor;
     }
     const newEditor = await addDiagnostics(latest.newState, diagnostics);
-    set$8(editor.id, latest.oldState, newEditor);
+    set$9(editor.id, latest.oldState, newEditor);
     // @ts-ignore
     await invoke$b('Editor.rerender', editor.id);
     return newEditor;
   } catch (error) {
-    return handleError$1(error, editor);
+    return handleError(error, editor);
   }
 };
 
@@ -4170,7 +4546,7 @@ const createEditor = async ({
     focused: true,
     textInfos
   };
-  set$8(id, emptyEditor, newEditor4);
+  set$9(id, emptyEditor, newEditor4);
 
   // TODO only sync when needed
   // e.g. it might not always be necessary to send text to extension host worker
@@ -4179,7 +4555,7 @@ const createEditor = async ({
   const editorWithDiagnostics = diagnosticsEnabled ? await updateDiagnostics(newEditor4) : newEditor4;
   const completionsOnTypeRaw = await get$2('editor.completionsOnType');
   const completionsOnType = Boolean(completionsOnTypeRaw);
-  set$8(id, emptyEditor, {
+  set$9(id, emptyEditor, {
     ...editorWithDiagnostics,
     completionsOnType
   });
@@ -4190,13 +4566,16 @@ const isEqual$3 = (oldState, newState) => {
 };
 
 const isEqual$2 = (oldState, newState) => {
+  if (oldState.focus !== newState.focus) {
+    return false;
+  }
   if (!newState.focused) {
     return true;
   }
   if (!oldState.isSelecting && newState.isSelecting) {
     return false;
   }
-  return oldState.focused === newState.focused && oldState.focus === newState.focus;
+  return oldState.focused === newState.focused;
 };
 
 const isEqual$1 = (oldState, newState) => {
@@ -4474,50 +4853,20 @@ const applyWorkspaceEdit = async (editor, changes) => {
   return scheduleDocumentAndCursorsSelections(editor, textChanges);
 };
 
-const handleBlur$1 = editor => {
-  if (!editor.focused) {
-    return editor;
-  }
-  const newEditor = {
-    ...editor,
-    focused: false
+const getFormattingEdits = async editor => {
+  const textDocument = {
+    documentId: editor.id || editor.uid,
+    languageId: editor.languageId,
+    text: getText$1(editor),
+    uri: editor.uri
   };
-  return newEditor;
-};
-
-const replaceRange = (editor, ranges, replacement, origin) => {
-  const changes = [];
-  const rangesLength = ranges.length;
-  for (let i = 0; i < rangesLength; i += 4) {
-    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(ranges, i);
-    const start = {
-      columnIndex: selectionStartColumn,
-      rowIndex: selectionStartRow
-    };
-    const end = {
-      columnIndex: selectionEndColumn,
-      rowIndex: selectionEndRow
-    };
-    const selection = {
-      end,
-      start
-    };
-    changes.push({
-      deleted: getSelectionText(editor, selection),
-      end: end,
-      inserted: replacement,
-      origin,
-      start: start
-    });
-  }
-  return changes;
+  return invoke$e('Extensions.executeFormattingProvider', textDocument);
 };
 
-const editorReplaceSelections = (editor, replacement, origin) => {
-  const {
-    selections
-  } = editor;
-  return replaceRange(editor, selections, replacement, origin);
+const expectedErrorMessage$1 = 'Failed to execute formatting provider: FormattingError:';
+const isFormattingError = error => {
+  // @ts-ignore
+  return error && error instanceof Error && error.message.startsWith(expectedErrorMessage$1);
 };
 
 const create$8 = () => {
@@ -4737,77 +5086,259 @@ const showErrorMessage = (editor, rowIndex, columnIndex, message) => {
   return editorShowMessage(editor, rowIndex, columnIndex, message);
 };
 
-// @ts-ignore
-const getErrorMessage$5 = String;
+const expectedErrorMessage = 'Failed to execute formatting provider: FormattingError:';
 
-// @ts-ignore
-const getMatchingClosingBrace$1 = brace => {
-  switch (brace) {
-    case '(':
-      return ')';
-    case '[':
-      return ']';
-    case '{':
-      return '}';
-    default:
-      return '???';
-  }
-};
-const braceCompletion = async (editor, text) => {
+// TODO also format with cursor
+const format = async editor => {
   try {
-    const offset = getCursorOffset(editor);
-    // @ts-ignore
-    const result = await invoke$b('ExtensionHostBraceCompletion.executeBraceCompletionProvider', editor, offset, text);
-    if (result) {
-      const closingBrace = getMatchingClosingBrace$1(text);
-      const insertText = text + closingBrace;
-      const changes = editorReplaceSelections(editor, [insertText], EditorType);
-      return scheduleDocumentAndCursorsSelections(editor, changes);
-    }
-    const changes = editorReplaceSelections(editor, [text], EditorType);
-    return scheduleDocumentAndCursorsSelections(editor, changes);
+    const edits = await getFormattingEdits(editor);
+    return applyDocumentEdits(editor, edits);
   } catch (error) {
+    if (isFormattingError(error)) {
+      console.error('Formatting Error:',
+      // @ts-ignore
+      error.message.slice(expectedErrorMessage.length));
+      return editor;
+    }
     console.error(error);
-    // TODO cursor should always be of type object
-    const position = Array.isArray(editor.cursor) ? editor.cursor[0] : editor.cursor;
-    // @ts-ignore
-    return showErrorMessage(editor, position, getErrorMessage$5(error));
-  }
-};
-const getCursorOffset = editor => {
-  return offsetAt(editor, editor.selections[0], editor.selections[1]);
-};
 
-const cancelSelection = editor => {
-  const {
-    selections
-  } = editor;
-  if (selections.length === 4 && selections[0] === selections[2] && selections[1] === selections[3]) {
+    // TODO configure editor message as widget
+    const displayErrorMessage = String(error);
+    await editorShowMessage(editor, 0, 0, displayErrorMessage);
     return editor;
   }
-  const newSelections = alloc(4);
-  moveRangeToPosition$1(newSelections, 0, selections[0], selections[1]);
-  return scheduleSelections(editor, newSelections);
 };
 
-const getIndex = (widgets, id) => {
-  for (const [i, widget] of widgets.entries()) {
-    if (widget.id === id) {
-      return i;
-    }
-  }
-  return -1;
-};
-const removeEditorWidget = (widgets, id) => {
-  const index = getIndex(widgets, id);
-  const newWidgets = [...widgets.slice(0, index), ...widgets.slice(index + 1)];
-  return newWidgets;
+// @ts-ignore
+const getNewEditor$1 = async editor => {
+  return editor;
 };
 
-const isMatchingWidget$2 = widget => {
-  return widget.id === CodeGenerator;
+const isUntitledFile = uri => {
+  return uri.startsWith('untitled:');
 };
-const closeCodeGenerator = editor => {
+
+const saveNormalFile = async (uri, content) => {
+  await invoke$b('FileSystem.writeFile', uri, content);
+};
+
+const showFilePicker = async platform => {
+  const dialogTitle = 'Save File'; // TODO use i18n string
+  const {
+    canceled,
+    filePath
+  } = await invoke$d('Open.showSaveDialog', dialogTitle, [], platform);
+  if (canceled) {
+    return '';
+  }
+  return filePath;
+};
+
+const saveUntitledFile = async (uri, content, platform) => {
+  const filePath = await showFilePicker(platform);
+  if (!filePath) {
+    return;
+  }
+  await invoke$b('FileSystem.writeFile', filePath, content);
+  await handleWorkspaceRefresh();
+  await invoke$b('Main.handleUriChange', uri, filePath);
+  return filePath;
+};
+
+const isPermissionDeniedError = error => {
+  const errorCode = 'code' in error ? error.code : undefined;
+  return errorCode === 'EACCES' || error.message.includes('EACCES:');
+};
+const showSaveErrorDialog = async error => {
+  if (isPermissionDeniedError(error)) {
+    await invoke$b('ElectronDialog.showMessageBox', {
+      buttons: ['OK'],
+      defaultId: 0,
+      message: "You don't have permission to save changes to this file.",
+      title: 'Unable to Save File',
+      type: 'error'
+    });
+    return;
+  }
+  await invoke$b('ElectronDialog.showMessageBox', {
+    buttons: ['OK'],
+    defaultId: 0,
+    detail: error.message,
+    message: 'Saving the file failed.',
+    title: 'Failed to Save File',
+    type: 'error'
+  });
+};
+
+const save = async editor => {
+  try {
+    const {
+      platform,
+      uri
+    } = editor;
+    const newEditor = await getNewEditor$1(editor);
+    const content = getText$1(newEditor);
+    if (isUntitledFile(uri)) {
+      const pickedFilePath = await saveUntitledFile(uri, content, platform);
+      if (pickedFilePath) {
+        if (editor.modified) {
+          await notifyTabModifiedStatusChange(uri, false);
+        }
+        return {
+          ...newEditor,
+          modified: false,
+          uri: pickedFilePath
+        };
+      }
+      return newEditor;
+    }
+    await saveNormalFile(uri, content);
+    if (editor.modified) {
+      await notifyTabModifiedStatusChange(uri, false);
+    }
+    return {
+      ...newEditor,
+      modified: false
+    };
+  } catch (error) {
+    // @ts-ignore
+    const betterError = new VError(error, `Failed to save file "${editor.uri}"`);
+    await handleError$1(betterError);
+    if (editor.platform === Electron) {
+      try {
+        await showSaveErrorDialog(betterError);
+      } catch (dialogError) {
+        await handleError$1(dialogError);
+      }
+    }
+    return editor;
+  }
+};
+
+const handleBlur$1 = async editor => {
+  if (!editor.focused) {
+    return editor;
+  }
+  const newEditor = {
+    ...editor,
+    focused: false
+  };
+  if (!editor.modified) {
+    return newEditor;
+  }
+  const autoSave = await get$2('files.autoSave');
+  if (autoSave === 'off') {
+    return newEditor;
+  }
+  return save(newEditor);
+};
+
+const replaceRange = (editor, ranges, replacement, origin) => {
+  const changes = [];
+  const rangesLength = ranges.length;
+  for (let i = 0; i < rangesLength; i += 4) {
+    const [selectionStartRow, selectionStartColumn, selectionEndRow, selectionEndColumn] = getSelectionPairs(ranges, i);
+    const start = {
+      columnIndex: selectionStartColumn,
+      rowIndex: selectionStartRow
+    };
+    const end = {
+      columnIndex: selectionEndColumn,
+      rowIndex: selectionEndRow
+    };
+    const selection = {
+      end,
+      start
+    };
+    changes.push({
+      deleted: getSelectionText(editor, selection),
+      end: end,
+      inserted: replacement,
+      origin,
+      start: start
+    });
+  }
+  return changes;
+};
+
+const editorReplaceSelections = (editor, replacement, origin) => {
+  const {
+    selections
+  } = editor;
+  return replaceRange(editor, selections, replacement, origin);
+};
+
+// @ts-ignore
+const getErrorMessage$4 = String;
+
+// @ts-ignore
+const getMatchingClosingBrace$1 = brace => {
+  switch (brace) {
+    case '(':
+      return ')';
+    case '[':
+      return ']';
+    case '{':
+      return '}';
+    default:
+      return '???';
+  }
+};
+const braceCompletion = async (editor, text) => {
+  try {
+    const offset = getCursorOffset(editor);
+    // @ts-ignore
+    const result = await invoke$b('ExtensionHostBraceCompletion.executeBraceCompletionProvider', editor, offset, text);
+    if (result) {
+      const closingBrace = getMatchingClosingBrace$1(text);
+      const insertText = text + closingBrace;
+      const changes = editorReplaceSelections(editor, [insertText], EditorType);
+      return scheduleDocumentAndCursorsSelections(editor, changes);
+    }
+    const changes = editorReplaceSelections(editor, [text], EditorType);
+    return scheduleDocumentAndCursorsSelections(editor, changes);
+  } catch (error) {
+    console.error(error);
+    // TODO cursor should always be of type object
+    const position = Array.isArray(editor.cursor) ? editor.cursor[0] : editor.cursor;
+    // @ts-ignore
+    return showErrorMessage(editor, position, getErrorMessage$4(error));
+  }
+};
+const getCursorOffset = editor => {
+  return offsetAt(editor, editor.selections[0], editor.selections[1]);
+};
+
+const cancelSelection = editor => {
+  const {
+    selections
+  } = editor;
+  if (selections.length === 4 && selections[0] === selections[2] && selections[1] === selections[3]) {
+    return editor;
+  }
+  const newSelections = alloc(4);
+  moveRangeToPosition$1(newSelections, 0, selections[0], selections[1]);
+  return scheduleSelections(editor, newSelections);
+};
+
+const getIndex = (widgets, id) => {
+  for (const [i, widget] of widgets.entries()) {
+    if (widget.id === id) {
+      return i;
+    }
+  }
+  return -1;
+};
+const removeEditorWidget = (widgets, id) => {
+  const index = getIndex(widgets, id);
+  const newWidgets = [...widgets.slice(0, index), ...widgets.slice(index + 1)];
+  return newWidgets;
+};
+
+const isMatchingWidget$2 = widget => {
+  return widget.id === CodeGenerator;
+};
+const closeCodeGenerator = editor => {
   const {
     widgets
   } = editor;
@@ -4968,7 +5499,23 @@ const newStateGenerator$6 = (state, parentUid) => {
   return loadContent$3(state, parentUid);
 };
 const openColorPicker = async editor => {
-  return addWidgetToEditor(ColorPicker$1, ColorPicker, editor, create$6, newStateGenerator$6);
+  const fullFocus = true;
+  return addWidgetToEditor(ColorPicker$1, ColorPicker, editor, create$6, newStateGenerator$6, fullFocus);
+};
+const closeColorPicker = editor => {
+  const {
+    widgets
+  } = editor;
+  if (widgets.every(widget => widget.id !== ColorPicker$1)) {
+    return editor;
+  }
+  return {
+    ...editor,
+    additionalFocus: 0,
+    focus: FocusEditorText$1,
+    focused: true,
+    widgets: removeEditorWidget(widgets, ColorPicker$1)
+  };
 };
 
 const state$5 = {
@@ -5729,45 +6276,6 @@ const findAllReferences$1 = async editor => {
   return editor;
 };
 
-const getFormattingEdits = async editor => {
-  const textDocument = {
-    documentId: editor.id || editor.uid,
-    languageId: editor.languageId,
-    text: getText$1(editor),
-    uri: editor.uri
-  };
-  return invoke$e('Extensions.executeFormattingProvider', textDocument);
-};
-
-const expectedErrorMessage$1 = 'Failed to execute formatting provider: FormattingError:';
-const isFormattingError = error => {
-  // @ts-ignore
-  return error && error instanceof Error && error.message.startsWith(expectedErrorMessage$1);
-};
-
-const expectedErrorMessage = 'Failed to execute formatting provider: FormattingError:';
-
-// TODO also format with cursor
-const format = async editor => {
-  try {
-    const edits = await getFormattingEdits(editor);
-    return applyDocumentEdits(editor, edits);
-  } catch (error) {
-    if (isFormattingError(error)) {
-      console.error('Formatting Error:',
-      // @ts-ignore
-      error.message.slice(expectedErrorMessage.length));
-      return editor;
-    }
-    console.error(error);
-
-    // TODO configure editor message as widget
-    const displayErrorMessage = String(error);
-    await editorShowMessage(editor, 0, 0, displayErrorMessage);
-    return editor;
-  }
-};
-
 /* eslint-disable sonarjs/super-linear-regex */
 
 const RE_WORD_START$1 = /^[\w\-]+/;
@@ -5820,15 +6328,15 @@ const getDefinition = async (editor, offset) => {
 };
 
 const emptyObject = {};
-const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
 const i18nString = (key, placeholders = emptyObject) => {
   if (placeholders === emptyObject) {
     return key;
   }
-  const replacer = (match, rest) => {
-    return placeholders[rest];
-  };
-  return key.replaceAll(RE_PLACEHOLDER, replacer);
+  let result = key;
+  for (const [placeholder, replacement] of Object.entries(placeholders)) {
+    result = result.split(`{${placeholder}}`).join(String(replacement));
+  }
+  return result;
 };
 
 const Copy = 'Copy';
@@ -6064,7 +6572,7 @@ const getNoLocationFoundMessage$1 = info => {
   }
   return noDefinitionFound();
 };
-const getErrorMessage$4 = String;
+const getErrorMessage$3 = String;
 
 // @ts-ignore
 const isNoProviderFoundError$1 = error => {
@@ -6073,7 +6581,7 @@ const isNoProviderFoundError$1 = error => {
 const goToDefinition = async editor => {
   return goTo({
     editor,
-    getErrorMessage: getErrorMessage$4,
+    getErrorMessage: getErrorMessage$3,
     getLocation: getLocation$1,
     getNoLocationFoundMessage: getNoLocationFoundMessage$1,
     isNoProviderFoundError: isNoProviderFoundError$1
@@ -6098,14 +6606,14 @@ const getLocation = async (editor, rowIndex, columnIndex) => {
   const definition = await getTypeDefinition(editor, offset);
   return definition;
 };
-const getErrorMessage$3 = String;
+const getErrorMessage$2 = String;
 const isNoProviderFoundError = error => {
   return error?.message?.startsWith('Failed to execute type definition provider: No type definition provider found');
 };
 const goToTypeDefinition = async (editor, explicit = true) => {
   return goTo({
     editor,
-    getErrorMessage: getErrorMessage$3,
+    getErrorMessage: getErrorMessage$2,
     getLocation,
     getNoLocationFoundMessage: getNoLocationFoundMessage,
     isNoProviderFoundError
@@ -6283,6 +6791,58 @@ const handleFocus$1 = editor => {
   };
 };
 
+const stride = 4;
+const isDefinitionLink = (decorations, index) => {
+  return decorations[index + 2] === DefinitionLink;
+};
+const matches = (editor, offset, length) => {
+  const {
+    decorations
+  } = editor;
+  for (let i = 0; i < decorations.length; i += stride) {
+    if (isDefinitionLink(decorations, i)) {
+      return decorations[i] === offset && decorations[i + 1] === length;
+    }
+  }
+  return false;
+};
+const clear = editor => {
+  const {
+    decorations
+  } = editor;
+  const filtered = [];
+  for (let i = 0; i < decorations.length; i += stride) {
+    if (!isDefinitionLink(decorations, i)) {
+      filtered.push(decorations[i], decorations[i + 1], decorations[i + 2], decorations[i + 3]);
+    }
+  }
+  if (filtered.length === decorations.length) {
+    return editor;
+  }
+  return {
+    ...editor,
+    decorations: filtered
+  };
+};
+const set$2 = (editor, offset, length) => {
+  if (matches(editor, offset, length)) {
+    return editor;
+  }
+  const editorWithoutDefinitionLink = clear(editor);
+  return {
+    ...editorWithoutDefinitionLink,
+    decorations: [...editorWithoutDefinitionLink.decorations, offset, length, DefinitionLink, 0]
+  };
+};
+
+const altKey = 'Alt';
+const handleKeyUp = (editor, key) => {
+  if (key !== altKey) {
+    return editor;
+  }
+  return clear(editor);
+};
+
 const Single = 1;
 const Double = 2;
 const Triple = 3;
@@ -6376,56 +6936,44 @@ const set$1 = (editor, timeout, x, y) => {
   state$4.y = y;
 };
 
-const showHover$1 = async (editor, position) => {
-  // TODO race condition
-  // await Viewlet.closeWidget(ViewletModuleId.EditorHover)
-  // await Viewlet.openWidget(ViewletModuleId.EditorHover, position)
+const RE_ALPHA_NUMERIC = /[a-zA-Z\d]/;
+const isAlphaNumeric = char => {
+  return RE_ALPHA_NUMERIC.test(char);
 };
 
-// TODO several things can happen:
-// 1. highlight link when alt key is pressed
-// 2. show hover info
-// 3. selection moves
-// 4. highlight go to definition
-// 5. show color picker
-// 6. show error info
-
-const onHoverIdle = async () => {
-  const {
-    editor,
-    x,
-    y
-  } = get$1();
-  await at(editor, x, y);
-  await showHover$1();
+const isWordChar = char => {
+  return isAlphaNumeric(char) || char === '_';
 };
-const hoverDelay = 300;
-
-// @ts-ignore
-const handleMouseMove = (editor, x, y) => {
-  if (!editor.hoverEnabled) {
-    return editor;
-  }
-  const oldState = get$1();
-  if (oldState.timeout !== -1) {
-    clearTimeout(oldState.timeout);
+const getWordStartIndex = (line, index) => {
+  for (let i = index - 1; i >= 0; i--) {
+    if (!isWordChar(line[i])) {
+      return i + 1;
+    }
   }
-  const timeout = setTimeout(onHoverIdle, hoverDelay);
-  set$1(editor, timeout, x, y);
-  return editor;
+  return 0;
 };
-
-// @ts-ignore
-const getTokenIndex = (tokens, offset) => {
-  let currentOffset = 0;
-  for (let i = 0; i < tokens.length; i++) {
-    const token = tokens[i];
-    currentOffset += token.length;
-    if (currentOffset >= offset) {
+const getWordEndIndex = (line, index) => {
+  for (let i = index; i < line.length; i++) {
+    if (!isWordChar(line[i])) {
       return i;
     }
   }
-  return -1;
+  return line.length;
+};
+const getWordMatchAtPosition = (lines, rowIndex, columnIndex) => {
+  const line = lines[rowIndex];
+  const start = getWordStartIndex(line, columnIndex);
+  const end = getWordEndIndex(line, columnIndex);
+  const word = line.slice(start, end);
+  return {
+    end,
+    start,
+    word
+  };
+};
+
+const isNoDefinitionProviderFoundError = error => {
+  return error instanceof Error && error.message.startsWith('Failed to execute definition provider: No definition provider found');
 };
 
 // @ts-ignore
@@ -6434,45 +6982,71 @@ const handleMouseMoveWithAltKey = async (editor, x, y) => {
   number(x);
   number(y);
   const position = await at(editor, x, y);
+  const wordMatch = getWordMatchAtPosition(editor.lines, position.rowIndex, position.columnIndex);
+  if (!wordMatch.word) {
+    return clear(editor);
+  }
+  const wordOffset = offsetAt(editor, position.rowIndex, wordMatch.start);
+  const wordLength = wordMatch.end - wordMatch.start;
+  if (matches(editor, wordOffset, wordLength)) {
+    return editor;
+  }
   const documentOffset = offsetAt(editor, position.rowIndex, position.columnIndex);
   try {
     const definition = await getDefinition(editor, documentOffset);
     if (!definition) {
-      return editor;
-    }
-
-    // TODO make sure that editor is not disposed
-
-    const definitionStartPosition = positionAt(editor, definition.startOffset);
-    positionAt(editor, definition.endOffset);
-    // const definitionRelativeY = definitionStartPosition.rowIndex - editor.minLineY
-
-    const lineTokenMap = editor.lineCache[definitionStartPosition.rowIndex + 1];
-    if (!lineTokenMap) {
-      return editor;
+      return clear(editor);
     }
-    const tokenIndex = getTokenIndex(lineTokenMap.tokens, definitionStartPosition.columnIndex);
-    if (tokenIndex === -1) {
-      return editor;
-    }
-    // .tokens
-    // await RendererProcess.invoke(
-    //   /* Viewlet.invoke */ 'Viewlet.send',
-    //   /* id */ ViewletModuleId.EditorText,
-    //   /* method */ 'highlightAsLink',
-    //   /* relativeY */ definitionRelativeY,
-    //   /* tokenIndex */ tokenIndex,
-    // )
-    return editor;
+    return set$2(editor, wordOffset, wordLength);
   } catch (error) {
-    // @ts-ignore
-    if (error && error.message.startsWith('Failed to execute definition provider: No definition provider found')) {
-      return editor;
+    if (isNoDefinitionProviderFoundError(error)) {
+      return clear(editor);
     }
     throw error;
   }
 };
 
+const showHover$1 = async (editor, position) => {
+  // TODO race condition
+  // await Viewlet.closeWidget(ViewletModuleId.EditorHover)
+  // await Viewlet.openWidget(ViewletModuleId.EditorHover, position)
+};
+
+// TODO several things can happen:
+// 1. highlight link when alt key is pressed
+// 2. show hover info
+// 3. selection moves
+// 4. highlight go to definition
+// 5. show color picker
+// 6. show error info
+
+const onHoverIdle = async () => {
+  const {
+    editor,
+    x,
+    y
+  } = get$1();
+  await at(editor, x, y);
+  await showHover$1();
+};
+const hoverDelay = 300;
+const handleMouseMove = async (editor, x, y, altKey) => {
+  if (altKey) {
+    return handleMouseMoveWithAltKey(editor, x, y);
+  }
+  const editorWithoutDefinitionLink = clear(editor);
+  if (!editorWithoutDefinitionLink.hoverEnabled) {
+    return editorWithoutDefinitionLink;
+  }
+  const oldState = get$1();
+  if (oldState.timeout !== -1) {
+    clearTimeout(oldState.timeout);
+  }
+  const timeout = setTimeout(onHoverIdle, hoverDelay);
+  set$1(editorWithoutDefinitionLink, timeout, x, y);
+  return editorWithoutDefinitionLink;
+};
+
 // TODO adjust relative position
 // @ts-ignore
 const getSelectionFromNativeRange = (editor, range) => {
@@ -6665,7 +7239,7 @@ const editorMoveSelection = (editor, position) => {
 };
 
 // @ts-ignore
-const getNewEditor$1 = (editor, position) => {
+const getNewEditor = (editor, position) => {
   const {
     maxLineY,
     minLineY,
@@ -6713,7 +7287,7 @@ const continueScrollingAndMovingSelection = async editorUid => {
   if (position.rowIndex === 0) {
     return;
   }
-  const newEditor = getNewEditor$1(editor, position);
+  const newEditor = getNewEditor(editor, position);
   if (editor === newEditor) {
     return;
   }
@@ -6727,7 +7301,7 @@ const continueScrollingAndMovingSelection = async editorUid => {
     }
   };
   const newEditorWithDerivedState = await updateDerivedState(editor, nextEditor);
-  set$8(editor.uid, editor, newEditorWithDerivedState);
+  set$9(editor.uid, editor, newEditorWithDerivedState);
   requestAnimationFrame(() => continueScrollingAndMovingSelection(editorUid));
 };
 
@@ -7315,7 +7889,7 @@ const launch = async () => {
     return;
   }
   const rpc = await launchFindWidgetWorker();
-  set$f(rpcId, rpc);
+  set$h(rpcId, rpc);
 };
 const invoke$3 = async (method, ...params) => {
   const rpc = get$8(rpcId);
@@ -7378,6 +7952,16 @@ const openFind = async state => {
   return openFind2(state);
 };
 
+const getOffsetAtCursor$1 = editor => {
+  const {
+    selections
+  } = editor;
+  const rowIndex = selections[0];
+  const columnIndex = selections[1];
+  const offset = offsetAt(editor, rowIndex, columnIndex);
+  return offset;
+};
+
 const getPositionAtCursor$1 = editor => {
   const {
     selections
@@ -7453,7 +8037,16 @@ const openRename = async editor => {
     return editor;
   }
   const fullFocus = true;
-  return addWidgetToEditor(Rename$1, FocusEditorRename$1, editor, create$2, newStateGenerator$2, fullFocus);
+  const editorWithRenameWidget = await addWidgetToEditor(Rename$1, FocusEditorRename$1, editor, create$2, newStateGenerator$2, fullFocus);
+  if (editorWithRenameWidget === editor) {
+    return editor;
+  }
+  const wordBefore = getWordBefore(editor, rowIndex, columnIndex);
+  const offset = getOffsetAtCursor$1(editor) - wordBefore.length;
+  return {
+    ...editorWithRenameWidget,
+    decorations: [...editorWithRenameWidget.decorations, offset, word.length, 3, 0]
+  };
 };
 
 const getOrganizeImportEdits = async editor => {
@@ -7502,233 +8095,6 @@ const redo = state => {
   return scheduleDocumentAndCursorsSelectionIsUndo(newState, last);
 };
 
-const getErrorMessage$2 = error => {
-  if (!error) {
-    return `Error: ${error}`;
-  }
-  let {
-    message
-  } = error;
-  while (error.cause) {
-    error = error.cause;
-    message += `: ${error}`;
-  }
-  return message;
-};
-const prepareErrorMessageWithCodeFrame = error => {
-  if (!error) {
-    return {
-      codeFrame: undefined,
-      message: error,
-      stack: undefined,
-      type: 'Error'
-    };
-  }
-  const message = getErrorMessage$2(error);
-  if (error.codeFrame) {
-    return {
-      codeFrame: error.codeFrame,
-      message,
-      stack: error.stack,
-      type: error.constructor.name
-    };
-  }
-  return {
-    category: error.category,
-    codeFrame: error.originalCodeFrame,
-    message,
-    stack: error.originalStack,
-    stderr: error.stderr
-  };
-};
-
-/* eslint-disable sonarjs/super-linear-regex */
-
-const RE_PATH_1 = /\((.*):(\d+):(\d+)\)$/;
-const RE_PATH_2 = /at (.*):(\d+):(\d+)$/;
-
-/**
- *
- * @param {readonly string[]} lines
- * @returns
- */
-const getFile = lines => {
-  for (const line of lines) {
-    if (RE_PATH_1.test(line) || RE_PATH_2.test(line)) {
-      return line;
-    }
-  }
-  return '';
-};
-const prepareErrorMessageWithoutCodeFrame = async error => {
-  try {
-    const lines = splitLines(error.stack);
-    const file = getFile(lines);
-    let match = file.match(RE_PATH_1);
-    if (!match) {
-      match = file.match(RE_PATH_2);
-    }
-    if (!match) {
-      return error;
-    }
-    const relevantStack = joinLines(lines.slice(1));
-    const message = getErrorMessage$2(error);
-    return {
-      message,
-      stack: relevantStack,
-      type: error.constructor.name
-    };
-  } catch (otherError) {
-    console.warn('ErrorHandling Error');
-    console.warn(otherError);
-    return error;
-  }
-};
-const prepare = async error => {
-  if (error && error.message && error.codeFrame) {
-    return prepareErrorMessageWithCodeFrame(error);
-  }
-  if (error && error.stack) {
-    return prepareErrorMessageWithoutCodeFrame(error);
-  }
-  return error;
-};
-const print = error => {
-  if (error && error.type && error.message && error.codeFrame) {
-    return `${error.type}: ${error.message}\n\n${error.codeFrame}\n\n${error.stack}`;
-  }
-  if (error && error.message && error.codeFrame) {
-    return `${error.message}\n\n${error.codeFrame}\n\n${error.stack}`;
-  }
-  if (error && error.type && error.message) {
-    return `${error.type}: ${error.message}\n${error.stack}`;
-  }
-  if (error && error.stack) {
-    return error.stack;
-  }
-  if (error === null) {
-    return null;
-  }
-  return String(error);
-};
-
-// @ts-nocheck
-const logError = async error => {
-  const prettyError = await prepare(error);
-  const prettyErrorString = print(prettyError);
-  console.error(prettyErrorString);
-  return prettyError;
-};
-const handleError = async error => {
-  try {
-    await logError(error);
-  } catch (otherError) {
-    console.warn('ErrorHandling error');
-    console.warn(otherError);
-    console.error(error);
-  }
-};
-
-// @ts-ignore
-const getNewEditor = async editor => {
-  return editor;
-};
-
-const isUntitledFile = uri => {
-  return uri.startsWith('untitled:');
-};
-
-const saveNormalFile = async (uri, content) => {
-  await invoke$b('FileSystem.writeFile', uri, content);
-};
-
-const showFilePicker = async platform => {
-  const dialogTitle = 'Save File'; // TODO use i18n string
-  const {
-    canceled,
-    filePath
-  } = await invoke$d('Open.showSaveDialog', dialogTitle, [], platform);
-  if (canceled) {
-    return '';
-  }
-  return filePath;
-};
-
-const saveUntitledFile = async (uri, content, platform) => {
-  const filePath = await showFilePicker(platform);
-  if (!filePath) {
-    return;
-  }
-  await invoke$b('FileSystem.writeFile', filePath, content);
-  await handleWorkspaceRefresh();
-  await invoke$b('Main.handleUriChange', uri, filePath);
-  return filePath;
-};
-
-const isPermissionDeniedError = error => {
-  const errorCode = 'code' in error ? error.code : undefined;
-  return errorCode === 'EACCES' || error.message.includes('EACCES:');
-};
-const showSaveErrorDialog = async error => {
-  if (isPermissionDeniedError(error)) {
-    await invoke$b('ElectronDialog.showMessageBox', {
-      buttons: ['OK'],
-      defaultId: 0,
-      message: "You don't have permission to save changes to this file.",
-      title: 'Unable to Save File',
-      type: 'error'
-    });
-    return;
-  }
-  await invoke$b('ElectronDialog.showMessageBox', {
-    buttons: ['OK'],
-    defaultId: 0,
-    detail: error.message,
-    message: 'Saving the file failed.',
-    title: 'Failed to Save File',
-    type: 'error'
-  });
-};
-
-const save = async editor => {
-  try {
-    const {
-      platform,
-      uri
-    } = editor;
-    const newEditor = await getNewEditor(editor);
-    const content = getText$1(newEditor);
-    if (isUntitledFile(uri)) {
-      const pickedFilePath = await saveUntitledFile(uri, content, platform);
-      if (pickedFilePath) {
-        return {
-          ...newEditor,
-          modified: false,
-          uri: pickedFilePath
-        };
-      }
-      return newEditor;
-    }
-    await saveNormalFile(uri, content);
-    return {
-      ...newEditor,
-      modified: false
-    };
-  } catch (error) {
-    // @ts-ignore
-    const betterError = new VError(error, `Failed to save file "${editor.uri}"`);
-    await handleError(betterError);
-    if (editor.platform === Electron) {
-      try {
-        await showSaveErrorDialog(betterError);
-      } catch (dialogError) {
-        await handleError(dialogError);
-      }
-    }
-    return editor;
-  }
-};
-
 // @ts-ignore
 
 // @ts-ignore
@@ -7780,42 +8146,6 @@ const editorSelectAllLeft = editor => {
   editorSelectHorizontalLeft(editor, lineCharacterStart);
 };
 
-const RE_ALPHA_NUMERIC = /[a-zA-Z\d]/;
-const isAlphaNumeric = char => {
-  return RE_ALPHA_NUMERIC.test(char);
-};
-
-const isWordChar = char => {
-  return isAlphaNumeric(char) || char === '_';
-};
-const getWordStartIndex = (line, index) => {
-  for (let i = index - 1; i >= 0; i--) {
-    if (!isWordChar(line[i])) {
-      return i + 1;
-    }
-  }
-  return 0;
-};
-const getWordEndIndex = (line, index) => {
-  for (let i = index; i < line.length; i++) {
-    if (!isWordChar(line[i])) {
-      return i;
-    }
-  }
-  return line.length;
-};
-const getWordMatchAtPosition = (lines, rowIndex, columnIndex) => {
-  const line = lines[rowIndex];
-  const start = getWordStartIndex(line, columnIndex);
-  const end = getWordEndIndex(line, columnIndex);
-  const word = line.slice(start, end);
-  return {
-    end,
-    start,
-    word
-  };
-};
-
 const isMultiLineMatch = (lines, rowIndex, wordParts) => {
   let j = 0;
   if (!lines[rowIndex + j].endsWith(wordParts[j])) {
@@ -8283,7 +8613,7 @@ const setLanguageId = async (editor, languageId, tokenizePath) => {
   await loadTokenizer(languageId, tokenizePath);
   const tokenizer = getTokenizer(languageId);
   const newTokenizerId = tokenizerId + 1;
-  set$3(newTokenizerId, tokenizer);
+  set$4(newTokenizerId, tokenizer);
   const latest = getEditor$1(editor.uid);
   if (!latest) {
     return editor;
@@ -8609,16 +8939,6 @@ const executeTabCompletionProvider = async (editor, offset) => {
   });
 };
 
-const getOffsetAtCursor$1 = editor => {
-  const {
-    selections
-  } = editor;
-  const rowIndex = selections[0];
-  const columnIndex = selections[1];
-  const offset = offsetAt(editor, rowIndex, columnIndex);
-  return offset;
-};
-
 const getTabCompletion = async editor => {
   const offset = getOffsetAtCursor$1(editor);
   const completions = await executeTabCompletionProvider(editor, offset);
@@ -8732,7 +9052,7 @@ const tabCompletion = async editor => {
     }
     return editorSnippet(editor, tabCompletion);
   } catch (error) {
-    await handleError(error);
+    await handleError$1(error);
     // TODO cursor should always be of type object
     const rowIndex = editor.selections[0];
     const columnIndex = editor.selections[1];
@@ -9469,7 +9789,7 @@ const createFn = (key, name, widgetId) => {
         focused: true,
         widgets: removeEditorWidget(latest.widgets, widgetId)
       };
-      set$8(editor.uid, latest, newEditor);
+      set$9(editor.uid, latest, newEditor);
       return newEditor;
     }
     const newState = {
@@ -9477,7 +9797,7 @@ const createFn = (key, name, widgetId) => {
       commands
     };
     const newEditor = updateWidget(latest, widgetId, newState);
-    set$8(editor.uid, latest, newEditor);
+    set$9(editor.uid, latest, newEditor);
     return newEditor;
   };
   return fn;
@@ -9492,6 +9812,7 @@ const createFns = (keys, name, widgetId) => {
 
 const AppendToBody = 'Viewlet.appendToBody';
 const Focus = 'focus';
+const FocusSelector = 'Viewlet.focusSelector';
 const RegisterEventListeners = 'Viewlet.registerEventListeners';
 const SetSelectionByName = 'Viewlet.setSelectionByName';
 const SetValueByName = 'Viewlet.setValueByName';
@@ -9916,6 +10237,7 @@ const HandleScrollBarVerticalPointerDown = 30;
 const HandleScrollBarVerticalPointerMove = 31;
 const HandleScrollBarVerticalPointerUp = 32;
 const HandleWheel = 33;
+const HandleKeyUp = 34;
 
 const Div = 4;
 const Input = 6;
@@ -10247,6 +10569,7 @@ const FocusFindWidgetCloseButton = 48;
 const FocusFindWidgetNextMatchButton = 49;
 const FocusFindWidgetPreviousMatchButton = 50;
 const FocusEditorCodeGenerator = 52;
+const FocusColorPicker = 41;
 
 const getPositionAtCursor = editorUid => {
   const editor = getEditor$1(editorUid);
@@ -10302,7 +10625,7 @@ const setSelections2 = async (editorUid, selections) => {
     selections
   };
   const newEditorWithDerivedState = await updateDerivedState(editor, newEditor);
-  set$8(editorUid, editor, newEditorWithDerivedState);
+  set$9(editorUid, editor, newEditorWithDerivedState);
 };
 const closeWidget2 = async (editorUid, widgetId, widgetName, unsetAdditionalFocus$1) => {
   const editor = getEditor$1(editorUid);
@@ -10318,11 +10641,12 @@ const closeWidget2 = async (editorUid, widgetId, widgetName, unsetAdditionalFocu
   const newWidgets = [...widgets.slice(0, index), ...widgets.slice(index + 1)];
   const newEditor = {
     ...editor,
+    decorations: widgetId === Rename$1 ? editor.decorations.slice(0, -4) : editor.decorations,
     focused: true,
     widgets: newWidgets
   };
   const newEditorWithDerivedState = await updateDerivedState(editor, newEditor);
-  set$8(editorUid, editor, newEditorWithDerivedState);
+  set$9(editorUid, editor, newEditorWithDerivedState);
   await setFocus(FocusEditorText);
   if (unsetAdditionalFocus$1) {
     await unsetAdditionalFocus(unsetAdditionalFocus$1);
@@ -10335,7 +10659,7 @@ const applyEdits2 = async (editorUid, edits) => {
   const editor = getEditor$1(editorUid);
   const newEditor = await applyEdit(editor, edits);
   const newEditorWithDerivedState = await updateDerivedState(editor, newEditor);
-  set$8(editorUid, editor, newEditorWithDerivedState);
+  set$9(editorUid, editor, newEditorWithDerivedState);
 };
 const getSourceActions = async editorUid => {
   const actions = await getEditorSourceActions(editorUid);
@@ -10355,6 +10679,10 @@ const ensure = async (fontName, fontUrl) => {
 
 const getKeyBindings = () => {
   return [{
+    command: 'Editor.closeColorPicker',
+    key: Escape,
+    when: FocusColorPicker
+  }, {
     command: 'Editor.closeSourceAction',
     key: Escape,
     when: FocusSourceActions
@@ -10913,7 +11241,7 @@ const handleMessagePort = async (port, rpcId) => {
     messagePort: port
   });
   if (rpcId) {
-    set$f(rpcId, rpc);
+    set$h(rpcId, rpc);
   }
 };
 
@@ -11064,7 +11392,7 @@ const hotReload = async () => {
     await relaunchWorkers();
     const newEditors = await restoreWidgetState(keys, savedStates);
     for (const editor of newEditors) {
-      set$8(editor.newState.uid, editor.oldState, editor.newState);
+      set$9(editor.newState.uid, editor.oldState, editor.newState);
     }
 
     // TODO ask renderer worker to rerender all editors
@@ -11102,7 +11430,7 @@ const initializeSyntaxHighlighting = async (syntaxHighlightingEnabled, syncIncre
   if (syntaxHighlightingEnabled) {
     setEnabled$1(true);
     const syntaxRpc = await createSyntaxHighlightingWorkerRpc();
-    set$6(syntaxRpc);
+    set$7(syntaxRpc);
   }
   if (syncIncremental) {
     setEnabled(true);
@@ -11244,7 +11572,7 @@ const loadContent = async (state, savedState) => {
   await loadTokenizer(computedLanguageId, tokenizePath);
   const tokenizer = getTokenizer(computedLanguageId);
   const newTokenizerId = state.tokenizerId + 1;
-  set$3(newTokenizerId, tokenizer);
+  set$4(newTokenizerId, tokenizer);
   const newEditor0 = {
     ...state,
     charWidth,
@@ -11399,6 +11727,7 @@ ${editorSelector} .EditorRow {
   height: var(--EditorRowHeight);
   line-height: var(--EditorRowHeight);
 }
+${editorSelector} .R{background-color:#add6ff40}
 ${editorSelector} .ScrollBarThumbVertical {
   height: var(--ScrollBarHeight);
   translate: 0px var(--ScrollBarTop);
@@ -11439,13 +11768,15 @@ const renderCss$1 = (oldState, newState) => {
 
 const renderFocus$2 = (oldState, newState) => {
   const selector = '.EditorInput textarea';
-  return [FocusSelector, newState.uid, selector];
+  return [FocusSelector$1, newState.uid, selector];
 };
 
 const renderFocusContext$1 = (oldState, newState) => {
-  return [SetFocusContext$1, newState.uid, FocusEditorText$1];
+  return [SetFocusContext$1, newState.uid, newState.focus];
 };
 
+new Set(Object.values(VirtualDomElements));
+
 const SetText = 1;
 const Replace = 2;
 const SetAttribute = 3;
@@ -11929,6 +12260,7 @@ const getEditorContentVirtualDom = ({
   return [{
     childCount: 5,
     className: 'EditorContent',
+    onKeyUp: HandleKeyUp,
     onMouseMove: HandleMouseMove,
     type: Div
   }, ...getEditorInputVirtualDom(), ...getEditorLayersVirtualDom(selectionInfos, textInfos, differences, lineNumbers, highlightedLine, cursorInfos, diagnostics), ...getEditorScrollBarDiagnosticsVirtualDom(scrollBarDiagnostics), ...getScrollBarVirtualDom()];
@@ -12072,7 +12404,7 @@ const render2 = (uid, diffResult) => {
     newState,
     oldState
   } = get$7(uid);
-  set$8(uid, newState, newState);
+  set$9(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
@@ -12175,7 +12507,7 @@ const renderEditor = async id => {
     oldState
   } = instance;
   const commands = [];
-  set$8(id, newState, newState);
+  set$9(id, newState, newState);
   for (const item of render$7) {
     if (item.isEqual(oldState, newState)) {
       continue;
@@ -12198,6 +12530,9 @@ const renderEventListeners = () => {
   }, {
     name: HandleMouseMove,
     params: ['handleMouseMove', ClientX, ClientY, AltKey]
+  }, {
+    name: HandleKeyUp,
+    params: ['handleKeyUp', Key]
   }, {
     name: HandleBlur,
     params: ['handleBlur']
@@ -12328,7 +12663,7 @@ const updateDebugInfo = async debugId => {
     ...newState,
     highlightedLine: newInfo.rowIndex
   };
-  set$8(key, oldState, newEditor);
+  set$9(key, oldState, newEditor);
   // @ts-ignore
   await invoke$b('Editor.rerender', key);
 };
@@ -12349,7 +12684,7 @@ const wrapCommand = fn => async (editorUid, ...args) => {
 
   // TODO combine neweditor with latest editor?
 
-  set$8(editorUid, state, newEditorWithDerivedState);
+  set$9(editorUid, state, newEditorWithDerivedState);
   return newEditorWithDerivedState;
 };
 
@@ -12366,6 +12701,7 @@ const commandMap = {
   'Editor.braceCompletion': wrapCommand(braceCompletion),
   'Editor.cancelSelection': wrapCommand(cancelSelection),
   'Editor.closeCodeGenerator': wrapCommand(closeCodeGenerator),
+  'Editor.closeColorPicker': wrapCommand(closeColorPicker),
   'Editor.closeFind': wrapCommand(closeFind),
   'Editor.closeFind2': closeFind2,
   'Editor.closeRename': wrapCommand(closeRename),
@@ -12443,6 +12779,7 @@ const commandMap = {
   'Editor.handleContextMenu': wrapCommand(handleContextMenu),
   'Editor.handleDoubleClick': wrapCommand(handleDoubleClick),
   'Editor.handleFocus': wrapCommand(handleFocus$1),
+  'Editor.handleKeyUp': wrapCommand(handleKeyUp),
   'Editor.handleMouseDown': wrapCommand(handleMouseDown),
   'Editor.handleMouseMove': wrapCommand(handleMouseMove),
   'Editor.handleMouseMoveWithAltKey': wrapCommand(handleMouseMoveWithAltKey),
@@ -12619,6 +12956,16 @@ for (const [key, value] of Object.entries(commandMap)) {
   }
 }
 
+const initializeErrorWorker = async () => {
+  const rpc = await create$c({
+    commandMap: {},
+    send(port) {
+      return sendMessagePortToErrorWorker(port, EditorWorker);
+    }
+  });
+  set$g(rpc);
+};
+
 const createExtensionHostRpc = async () => {
   const initialCommand = 'HandleMessagePort.handleMessagePort2';
   const rpc = await create$c({
@@ -12632,7 +12979,7 @@ const createExtensionHostRpc = async () => {
 
 const initializeExtensionHost = async () => {
   const extensionHostRpc = await createExtensionHostRpc();
-  set$2(extensionHostRpc);
+  set$3(extensionHostRpc);
 };
 
 const createExtensionManagementWorkerRpc = async () => {
@@ -12648,7 +12995,7 @@ const createExtensionManagementWorkerRpc = async () => {
 const initializeExtensionManagementWorker = async () => {
   try {
     const rpc = await createExtensionManagementWorkerRpc();
-    set$d(rpc);
+    set$e(rpc);
   } catch {
     // ignore
   }
@@ -12663,14 +13010,14 @@ const initializeOpenerWorker = async () => {
     commandMap: {},
     send: send$1
   });
-  set$c(rpc);
+  set$d(rpc);
 };
 
 const initializeRendererWorker = async () => {
   const rpc = await create$a({
     commandMap: commandMap
   });
-  set$a(rpc);
+  set$b(rpc);
 };
 
 const send = port => {
@@ -12681,12 +13028,12 @@ const initializeTextMeasurementWorker = async () => {
     commandMap: {},
     send
   });
-  set$b(rpc);
+  set$c(rpc);
 };
 
 const listen = async () => {
   registerCommands(commandMap);
-  await Promise.all([initializeRendererWorker(), initializeExtensionHost(), initializeExtensionManagementWorker(), initializeTextMeasurementWorker(), initializeOpenerWorker()]);
+  await Promise.all([initializeRendererWorker(), initializeErrorWorker(), initializeExtensionHost(), initializeExtensionManagementWorker(), initializeTextMeasurementWorker(), initializeOpenerWorker()]);
 };
 
 const CodeGeneratorInput = 'CodeGeneratorInput';
@@ -12780,7 +13127,7 @@ const renderFull$1 = (oldState, newState) => {
   return commands;
 };
 
-const commandsToForward$1 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetUid];
+const commandsToForward$1 = [SetDom2, SetCss, AppendToBody, FocusSelector, SetBounds2, RegisterEventListeners, SetUid];
 const render$4 = widget => {
   const commands = renderFull$1(widget.oldState, widget.newState);
   const wrappedCommands = [];
@@ -12992,15 +13339,15 @@ const EditorMessageWidget = {
 };
 
 const registerWidgets = () => {
-  set$7(ColorPicker$1, EditorColorPickerWidget);
-  set$7(Completion, EditorCompletionWidget);
-  set$7(CompletionDetail, EditorCompletionDetailWidget);
-  set$7(Find, EditorFindWidget);
-  set$7(Hover, EditorHoverWidget);
-  set$7(Message, EditorMessageWidget);
-  set$7(Rename$1, EditorRenameWidget);
-  set$7(SourceAction$1, EditorSourceActionWidget);
-  set$7(CodeGenerator, EditorCodeGeneratorWidget);
+  set$8(ColorPicker$1, EditorColorPickerWidget);
+  set$8(Completion, EditorCompletionWidget);
+  set$8(CompletionDetail, EditorCompletionDetailWidget);
+  set$8(Find, EditorFindWidget);
+  set$8(Hover, EditorHoverWidget);
+  set$8(Message, EditorMessageWidget);
+  set$8(Rename$1, EditorRenameWidget);
+  set$8(SourceAction$1, EditorSourceActionWidget);
+  set$8(CodeGenerator, EditorCodeGeneratorWidget);
 };
 
 const handleUnhandledRejection = event => {