@lvce-editor/static-server 0.83.1 → 0.84.1

package/static/{7c12bd7 → 50d6c96}/packages/editor-worker/dist/editorWorkerMain.js

@@ -1,58 +1,122 @@
-const normalizeLine = line => {
-  if (line.startsWith('Error: ')) {
-    return line.slice('Error: '.length);
-  }
-  if (line.startsWith('VError: ')) {
-    return line.slice('VError: '.length);
-  }
-  return line;
-};
-const getCombinedMessage = (error, message) => {
-  const stringifiedError = normalizeLine(`${error}`);
-  if (message) {
-    return `${message}: ${stringifiedError}`;
-  }
-  return stringifiedError;
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
 };
-const NewLine$3 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$3, startIndex);
+const create$j = () => {
+  const states = Object.create(null);
+  const commandMapRef = {};
+  return {
+    clear() {
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    diff(uid, modules, numbers) {
+      const {
+        newState,
+        oldState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, newState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    dispose(uid) {
+      delete states[uid];
+    },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    getKeys() {
+      return Object.keys(states).map(key => {
+        return Number.parseFloat(key);
+      });
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    },
+    set(uid, oldState, newState) {
+      states[uid] = {
+        newState,
+        oldState
+      };
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (oldState === newerState || newState === newerState) {
+          return;
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    wrapLoadContent(fn) {
+      const wrapped = async (uid, ...args) => {
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const result = await fn(newState, ...args);
+        const {
+          error,
+          state
+        } = result;
+        if (oldState === state || newState === state) {
+          return {
+            error
+          };
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...state
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState
+        };
+        return {
+          error
+        };
+      };
+      return wrapped;
+    }
+  };
 };
-const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent;
-  }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
-  if (childNewLineIndex === -1) {
-    return parent;
-  }
-  const parentFirstLine = parent.slice(0, parentNewLineIndex);
-  const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
-  if (parentFirstLine.includes(childFirstLine)) {
-    return parentFirstLine + childRest;
-  }
-  return child;
+const terminate = () => {
+  globalThis.close();
 };
-class VError extends Error {
-  constructor(error, message) {
-    const combinedMessage = getCombinedMessage(error, message);
-    super(combinedMessage);
-    this.name = 'VError';
-    if (error instanceof Error) {
-      this.stack = mergeStacks(this.stack, error.stack);
-    }
-    if (error.codeFrame) {
-      // @ts-ignore
-      this.codeFrame = error.codeFrame;
-    }
-    if (error.code) {
-      // @ts-ignore
-      this.code = error.code;
-    }
-  }
-}
 
 class AssertionError extends Error {
   constructor(message) {
@@ -121,6 +185,62 @@ const boolean = value => {
   }
 };
 
+const normalizeLine = line => {
+  if (line.startsWith('Error: ')) {
+    return line.slice('Error: '.length);
+  }
+  if (line.startsWith('VError: ')) {
+    return line.slice('VError: '.length);
+  }
+  return line;
+};
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
+  if (message) {
+    return `${message}: ${stringifiedError}`;
+  }
+  return stringifiedError;
+};
+const NewLine$3 = '\n';
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$3, startIndex);
+};
+const mergeStacks = (parent, child) => {
+  if (!child) {
+    return parent;
+  }
+  const parentNewLineIndex = getNewLineIndex$1(parent);
+  const childNewLineIndex = getNewLineIndex$1(child);
+  if (childNewLineIndex === -1) {
+    return parent;
+  }
+  const parentFirstLine = parent.slice(0, parentNewLineIndex);
+  const childRest = child.slice(childNewLineIndex);
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
+  if (parentFirstLine.includes(childFirstLine)) {
+    return parentFirstLine + childRest;
+  }
+  return child;
+};
+class VError extends Error {
+  constructor(error, message) {
+    const combinedMessage = getCombinedMessage(error, message);
+    super(combinedMessage);
+    this.name = 'VError';
+    if (error instanceof Error) {
+      this.stack = mergeStacks(this.stack, error.stack);
+    }
+    if (error.codeFrame) {
+      // @ts-ignore
+      this.codeFrame = error.codeFrame;
+    }
+    if (error.code) {
+      // @ts-ignore
+      this.code = error.code;
+    }
+  }
+}
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -765,7 +885,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$j = (message, result) => {
+const create$i = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -774,7 +894,7 @@ const create$j = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$j(message, resultProperty);
+  return create$i(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -868,7 +988,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$i = (method, params) => {
+const create$h = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -876,7 +996,7 @@ const create$i = (method, params) => {
   };
 };
 
-const create$h = (id, method, params) => {
+const create$g = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -887,12 +1007,12 @@ const create$h = (id, method, params) => {
 };
 
 let id = 0;
-const create$g = () => {
+const create$f = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$g();
+  const id = create$f();
   const {
     promise,
     resolve
@@ -909,7 +1029,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$h(id, method, params);
+  const message = create$g(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -945,7 +1065,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$i(method, params);
+      const message = create$h(method, params);
       ipc.send(message);
     }
   };
@@ -985,7 +1105,7 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$f = async ({
+const create$e = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -1003,7 +1123,7 @@ const create$f = async ({
   return rpc;
 };
 
-const create$e = async ({
+const create$d = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -1013,7 +1133,7 @@ const create$e = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$f({
+  return create$e({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
@@ -1048,13 +1168,13 @@ const createSharedLazyRpc = factory => {
   };
 };
 
-const create$d = async ({
+const create$c = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$e({
+    return create$d({
       commandMap,
       isMessagePortOpen,
       send
@@ -1062,17 +1182,17 @@ const create$d = async ({
   });
 };
 
-const create$c = async ({
+const create$b = async ({
   commandMap,
   messagePort
 }) => {
-  return create$f({
+  return create$e({
     commandMap,
     messagePort
   });
 };
 
-const create$b = async ({
+const create$a = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1115,7 +1235,7 @@ const remove$8 = id => {
 };
 
 /* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create$a = rpcId => {
+const create$9 = rpcId => {
   return {
     async dispose() {
       const rpc = get$7(rpcId);
@@ -1233,7 +1353,7 @@ const FocusEditorText$1 = 12;
 const {
   invoke: invoke$f,
   set: set$d
-} = create$a(ExtensionHostWorker);
+} = create$9(ExtensionHostWorker);
 
 const ExtensionHost = {
   __proto__: null,
@@ -1244,7 +1364,7 @@ const ExtensionHost = {
 const {
   invoke: invoke$e,
   set: set$c
-} = create$a(ExtensionManagementWorker);
+} = create$9(ExtensionManagementWorker);
 const getLanguages$1 = (platform, assetDir) => {
   return invoke$e('Extensions.getLanguages', platform, assetDir);
 };
@@ -1252,59 +1372,64 @@ const getLanguages$1 = (platform, assetDir) => {
 const {
   invoke: invoke$d,
   set: set$b
-} = create$a(OpenerWorker);
+} = create$9(OpenerWorker);
 const openUrl = async (url, platform) => {
   return invoke$d('Open.openUrl', url, platform);
 };
 
 const {
   invoke: invoke$c,
-  invokeAndTransfer,
   set: set$a
-} = create$a(RendererWorker$1);
+} = create$9(IconThemeWorker);
+
+const {
+  invoke: invoke$b,
+  invokeAndTransfer,
+  set: set$9
+} = create$9(RendererWorker$1);
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
   number(menuId);
   number(x);
   number(y);
-  await invoke$c('ContextMenu.show2', uid, menuId, x, y, args);
+  await invoke$b('ContextMenu.show2', uid, menuId, x, y, args);
 };
 const sendMessagePortToOpenerWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToOpenerWorker', port, command, rpcId);
 };
 const readFile = async uri => {
-  return invoke$c('FileSystem.readFile', uri);
+  return invoke$b('FileSystem.readFile', uri);
 };
 const handleWorkspaceRefresh = async () => {
-  return invoke$c('Layout.handleWorkspaceRefresh');
+  return invoke$b('Layout.handleWorkspaceRefresh');
 };
 const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
 const writeClipBoardText = async text => {
-  await invoke$c('ClipBoard.writeText', /* text */text);
+  await invoke$b('ClipBoard.writeText', /* text */text);
 };
 const readClipBoardText = async () => {
-  return invoke$c('ClipBoard.readText');
+  return invoke$b('ClipBoard.readText');
 };
 const activateByEvent$1 = (event, assetDir, platform) => {
-  return invoke$c('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
+  return invoke$b('ExtensionHostManagement.activateByEvent', event, assetDir, platform);
 };
 const sendMessagePortToTextMeasurementWorker = async port => {
   const command = 'TextMeasurement.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToTextMeasurementWorker', port, command, 0);
 };
-const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+const sendMessagePortToExtensionManagementWorker$1 = async (port, rpcId) => {
   const command = 'Extensions.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionManagementWorker', port, command, rpcId);
 };
 const getPreference = async key => {
-  return await invoke$c('Preferences.get', key);
+  return await invoke$b('Preferences.get', key);
 };
 const openUri = async (uri, focus, options) => {
-  await invoke$c('Main.openUri', uri, focus, options);
+  await invoke$b('Main.openUri', uri, focus, options);
 };
 const sendMessagePortToSyntaxHighlightingWorker$1 = async port => {
   await invokeAndTransfer('SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
@@ -1315,30 +1440,25 @@ const RendererWorker = {
   activateByEvent: activateByEvent$1,
   getPreference,
   handleWorkspaceRefresh,
-  invoke: invoke$c,
+  invoke: invoke$b,
   invokeAndTransfer,
   openUri,
   readClipBoardText,
   readFile,
   sendMessagePortToExtensionHostWorker,
-  sendMessagePortToExtensionManagementWorker,
+  sendMessagePortToExtensionManagementWorker: sendMessagePortToExtensionManagementWorker$1,
   sendMessagePortToOpenerWorker,
   sendMessagePortToSyntaxHighlightingWorker: sendMessagePortToSyntaxHighlightingWorker$1,
   sendMessagePortToTextMeasurementWorker,
-  set: set$a,
+  set: set$9,
   showContextMenu2,
   writeClipBoardText
 };
 
-const {
-  invoke: invoke$b,
-  set: set$9
-} = create$a(IconThemeWorker);
-
 const {
   invoke: invoke$a,
   set: set$8
-} = create$a(MarkdownWorker);
+} = create$9(MarkdownWorker);
 
 const SyntaxHighlightingWorker = {
   __proto__: null,
@@ -1376,126 +1496,6 @@ const createLazyRpc = rpcId => {
   };
 };
 
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const create$9 = () => {
-  const states = Object.create(null);
-  const commandMapRef = {};
-  return {
-    clear() {
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
-    },
-    diff(uid, modules, numbers) {
-      const {
-        newState,
-        oldState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, newState)) {
-          diffResult.push(numbers[i]);
-        }
-      }
-      return diffResult;
-    },
-    dispose(uid) {
-      delete states[uid];
-    },
-    get(uid) {
-      return states[uid];
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    getKeys() {
-      return Object.keys(states).map(key => {
-        return Number.parseFloat(key);
-      });
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
-    },
-    set(uid, oldState, newState) {
-      states[uid] = {
-        newState,
-        oldState
-      };
-    },
-    wrapCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        const {
-          newState,
-          oldState
-        } = states[uid];
-        const newerState = await fn(newState, ...args);
-        if (oldState === newerState || newState === newerState) {
-          return;
-        }
-        const latestOld = states[uid];
-        const latestNew = {
-          ...latestOld.newState,
-          ...newerState
-        };
-        states[uid] = {
-          newState: latestNew,
-          oldState: latestOld.oldState
-        };
-      };
-      return wrapped;
-    },
-    wrapGetter(fn) {
-      const wrapped = (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        return fn(newState, ...args);
-      };
-      return wrapped;
-    },
-    wrapLoadContent(fn) {
-      const wrapped = async (uid, ...args) => {
-        const {
-          newState,
-          oldState
-        } = states[uid];
-        const result = await fn(newState, ...args);
-        const {
-          error,
-          state
-        } = result;
-        if (oldState === state || newState === state) {
-          return {
-            error
-          };
-        }
-        const latestOld = states[uid];
-        const latestNew = {
-          ...latestOld.newState,
-          ...state
-        };
-        states[uid] = {
-          newState: latestNew,
-          oldState: latestOld.oldState
-        };
-        return {
-          error
-        };
-      };
-      return wrapped;
-    }
-  };
-};
-const terminate = () => {
-  globalThis.close();
-};
-
 // TODO add tests for this
 const activateByEvent = async (event, assetDir, platform) => {
   string(event);
@@ -1512,7 +1512,7 @@ const codeGeneratorAccept = state => {
 const ModuleWorkerAndWorkaroundForChromeDevtoolsBug = 6;
 
 const launchWorker = async (name, url, intializeCommand) => {
-  const rpc = await create$e({
+  const rpc = await create$d({
     commandMap: {},
     isMessagePortOpen: true,
     async send(port) {
@@ -1537,12 +1537,12 @@ const launchColorPickerWorker = async () => {
   return launchWorker(name, url);
 };
 
-let workerPromise$3;
+const state$f = {};
 const getOrCreate$3 = () => {
-  if (!workerPromise$3) {
-    workerPromise$3 = launchColorPickerWorker();
+  if (!state$f.workerPromise) {
+    state$f.workerPromise = launchColorPickerWorker();
   }
-  return workerPromise$3;
+  return state$f.workerPromise;
 };
 const invoke$9 = async (method, ...params) => {
   const worker = await getOrCreate$3();
@@ -1567,7 +1567,7 @@ const loadContent$3 = async (state, parentUid) => {
   };
 };
 
-const editorStates = create$9();
+const editorStates = create$j();
 const {
   getCommandIds,
   registerCommands,
@@ -1623,6 +1623,7 @@ const createEditor2 = (id, uri, x, y, width, height, platform, assetDir) => {
     fontFamily: '',
     fontSize: 0,
     fontWeight: 0,
+    handleOffset: 0,
     handleOffsetX: 0,
     height,
     highlightedLine: -1,
@@ -1844,7 +1845,7 @@ const getInitialLineState = initialLineState => {
   return deepCopy(initialLineState);
 };
 
-const state$8 = {
+const state$e = {
   warned: []
 };
 const flattenTokensArray = tokens => {
@@ -1856,10 +1857,10 @@ const flattenTokensArray = tokens => {
   return flattened;
 };
 const warnDeprecatedArrayReturn = (languageId, fn) => {
-  if (state$8.warned.includes(fn)) {
+  if (state$e.warned.includes(fn)) {
     return;
   }
-  state$8.warned.push(fn);
+  state$e.warned.push(fn);
   console.warn(`tokenizers without hasArrayReturn=false are deprecated (language ${languageId})`);
 };
 const safeTokenizeLine = (languageId, tokenizeLine, line, lineStateAtStart, hasArrayReturn) => {
@@ -1920,12 +1921,14 @@ const TokenizePlainText = {
   tokenizeLine
 };
 
-let enabled$1 = false;
+const state$d = {
+  enabled: false
+};
 const setEnabled$1 = value => {
-  enabled$1 = value;
+  state$d.enabled = value;
 };
 const getEnabled$1 = () => {
-  return enabled$1;
+  return state$d.enabled;
 };
 
 const {
@@ -1933,21 +1936,35 @@ const {
   set: set$5
 } = SyntaxHighlightingWorker;
 
-const state$7 = {
+const state$c = {
   pending: Object.create(null),
+  tokenizePaths: Object.create(null),
   tokenizers: Object.create(null)
 };
 const has = languageId => {
-  return languageId in state$7.tokenizers;
+  return Object.hasOwn(state$c.tokenizers, languageId);
 };
 const set$4 = (languageId, tokenizer) => {
-  state$7.tokenizers[languageId] = tokenizer;
+  state$c.tokenizers[languageId] = tokenizer;
 };
 const get$4 = languageId => {
-  return state$7.tokenizers[languageId];
+  return state$c.tokenizers[languageId];
+};
+const setTokenizePath = (languageId, tokenizePath) => {
+  state$c.tokenizePaths[languageId] = tokenizePath;
+};
+const getTokenizePath$1 = languageId => {
+  return state$c.tokenizePaths[languageId] || '';
+};
+const setTokenizePaths = languages => {
+  for (const language of languages) {
+    if (language && language.id && language.tokenize) {
+      setTokenizePath(language.id, language.tokenize);
+    }
+  }
 };
 const isPending = languageId => {
-  return languageId in state$7.pending;
+  return Object.hasOwn(state$c.pending, languageId);
 };
 
 const tokenMaps = Object.create(null);
@@ -1963,6 +1980,7 @@ const loadTokenizer = async (languageId, tokenizePath) => {
   if (!tokenizePath) {
     return;
   }
+  setTokenizePath(languageId, tokenizePath);
   if (getEnabled$1()) {
     // @ts-ignore
     const tokenMap = await invoke$8('Tokenizer.load', languageId, tokenizePath);
@@ -2007,10 +2025,37 @@ const get$2 = id => {
   return tokenizers[id] || TokenizePlainText;
 };
 
+const getEmbeddedTokenization = (langageId, line, embeddedLanguage, embeddedLanguageStart, embeddedLanguageEnd, topContexts, tokenizersToLoad) => {
+  const embeddedTokenizer = getTokenizer(embeddedLanguage);
+  if (embeddedLanguageStart !== line.length && embeddedTokenizer && embeddedTokenizer !== TokenizePlainText) {
+    const isFull = embeddedLanguageStart === 0 && embeddedLanguageEnd === line.length;
+    const partialLine = line.slice(embeddedLanguageStart, embeddedLanguageEnd);
+    const embedResult = safeTokenizeLine(langageId, embeddedTokenizer.tokenizeLine, partialLine, topContexts[embeddedLanguage] || getInitialLineState(embeddedTokenizer.initialLineState), embeddedTokenizer.hasArrayReturn);
+    topContexts[embeddedLanguage] = embedResult;
+    if (embedResult.embeddedLanguage) {
+      const nested = getEmbeddedTokenization(langageId, partialLine, embedResult.embeddedLanguage, embedResult.embeddedLanguageStart, embedResult.embeddedLanguageEnd, topContexts, tokenizersToLoad);
+      if (nested?.isFull) {
+        return nested;
+      }
+    }
+    return {
+      isFull,
+      result: embedResult,
+      TokenMap: embeddedTokenizer.TokenMap
+    };
+  }
+  tokenizersToLoad.push(embeddedLanguage);
+  topContexts[embeddedLanguage] = undefined;
+  return {
+    isFull: false,
+    result: {},
+    TokenMap: []
+  };
+};
 const getTokensViewportEmbedded = (langageId, lines, lineCache, linesWithEmbed) => {
   const tokenizersToLoad = [];
   const embeddedResults = [];
-  let topContext;
+  const topContexts = Object.create(null);
   for (const index of linesWithEmbed) {
     const result = lineCache[index + 1];
     const line = lines[index];
@@ -2020,19 +2065,7 @@ const getTokensViewportEmbedded = (langageId, lines, lineCache, linesWithEmbed)
         embeddedLanguageEnd,
         embeddedLanguageStart
       } = result;
-      const embeddedTokenizer = getTokenizer(embeddedLanguage);
-      if (embeddedLanguageStart !== line.length && embeddedTokenizer && embeddedTokenizer !== TokenizePlainText) {
-        const isFull = embeddedLanguageStart === 0 && embeddedLanguageEnd === line.length;
-        const partialLine = line.slice(embeddedLanguageStart, embeddedLanguageEnd);
-        const embedResult = safeTokenizeLine(langageId, embeddedTokenizer.tokenizeLine, partialLine, topContext || getInitialLineState(embeddedTokenizer.initialLineState), embeddedTokenizer.hasArrayReturn);
-        topContext = embedResult;
-        result.embeddedResultIndex = embeddedResults.length;
-        embeddedResults.push({
-          isFull,
-          result: embedResult,
-          TokenMap: embeddedTokenizer.TokenMap
-        });
-      } else if (line.length === 0) {
+      if (line.length === 0) {
         const embedResult = {
           tokens: []
         };
@@ -2043,16 +2076,13 @@ const getTokensViewportEmbedded = (langageId, lines, lineCache, linesWithEmbed)
           TokenMap: []
         });
       } else {
-        tokenizersToLoad.push(embeddedLanguage);
-        embeddedResults.push({
-          isFull: false,
-          result: {},
-          TokenMap: []
-        });
-        topContext = undefined;
+        result.embeddedResultIndex = embeddedResults.length;
+        embeddedResults.push(getEmbeddedTokenization(langageId, line, embeddedLanguage, embeddedLanguageStart, embeddedLanguageEnd, topContexts, tokenizersToLoad));
       }
     } else {
-      topContext = undefined;
+      for (const embeddedLanguage of Object.keys(topContexts)) {
+        topContexts[embeddedLanguage] = undefined;
+      }
     }
   }
   return {
@@ -2154,8 +2184,8 @@ const getTokensViewport2 = async (editor, startLineIndex, endLineIndex, syncIncr
 
 const loadTokenizers = async languageIds => {
   for (const languageId of languageIds) {
-    // @ts-ignore
-    await loadTokenizer(languageId);
+    const tokenizePath = getTokenizePath$1(languageId);
+    await loadTokenizer(languageId, tokenizePath);
   }
 };
 
@@ -2168,7 +2198,7 @@ const Tab = '\t';
 
 const normalizeText = (text, normalize, tabSize) => {
   if (normalize) {
-    return text.replaceAll(Tab, Space.repeat(tabSize));
+    return text.replaceAll(Tab, () => Space.repeat(tabSize));
   }
   return text;
 };
@@ -2231,11 +2261,9 @@ const applyEdits = (textDocument, changes) => {
     const startColumnIndex = change.start.columnIndex;
     const endColumnIndex = change.end.columnIndex;
     const {
+      deleted,
       inserted
     } = change;
-    const {
-      deleted
-    } = change;
     number(startRowIndex);
     number(endRowIndex);
     number(startColumnIndex);
@@ -2361,6 +2389,8 @@ const positionAt = (textDocument, offset) => {
   };
 };
 
+const maxTokenizerLoadPasses = 10;
+
 // const getTokensIncremental = (editor, min, max) => {
 //   const currentLength = editor.lineStateCache.length
 //   const tokens = []
@@ -2417,6 +2447,24 @@ const getStartDefaults = (tokens, minOffset) => {
     startIndex
   };
 };
+const hasDecorationOverlap = (decorationMap, tokenStart, tokenEnd) => {
+  for (const [decorationStart, {
+    end: decorationEnd
+  }] of decorationMap) {
+    if (decorationStart < tokenEnd && decorationEnd > tokenStart) {
+      return true;
+    }
+  }
+  return false;
+};
+const getActiveDecoration = (decorationMap, currentPos) => {
+  for (const [decorationStart, decoration] of decorationMap) {
+    if (decorationStart <= currentPos && decoration.end > currentPos) {
+      return decoration;
+    }
+  }
+  return undefined;
+};
 const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, decorations, lineOffset, normalize, tabSize, width, deltaX, averageCharWidth, minOffset, maxOffset) => {
   const lineInfo = [];
 
@@ -2454,29 +2502,13 @@ const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, decoration
     const tokenType = embeddedTokens[i];
     const tokenLength = embeddedTokens[i + 1];
     const tokenEnd = start + tokenLength;
-
-    // Check if any decorations overlap with this token
-    let hasOverlap = false;
-    for (const [decorationStart, {
-      end: decorationEnd
-    }] of decorationMap) {
-      if (decorationStart < tokenEnd && decorationEnd > start) {
-        hasOverlap = true;
-        break;
-      }
-    }
+    const hasOverlap = hasDecorationOverlap(decorationMap, start, tokenEnd);
     if (hasOverlap) {
       // Token has decoration overlap - split into parts
       let currentPos = start;
       while (currentPos < tokenEnd) {
         // Find if current position is inside a decoration
-        let activeDecoration = null;
-        for (const [decorationStart, decoration] of decorationMap) {
-          if (decorationStart <= currentPos && decoration.end > currentPos) {
-            activeDecoration = decoration;
-            break;
-          }
-        }
+        const activeDecoration = getActiveDecoration(decorationMap, currentPos);
         if (activeDecoration) {
           // Render decorated part
           const partEnd = Math.min(tokenEnd, activeDecoration.end);
@@ -2524,7 +2556,7 @@ const getLineInfoEmbeddedFull = (embeddedResults, tokenResults, line, decoration
 };
 const getOffsets = (deltaX, width, averageCharWidth) => {
   // TODO accurately measure char widths using offscreen canvas
-  // and use fast measurements for monospace ascii text
+  // and use fast measurements for monospace ASCII text
   if (deltaX === 0) {
     return {
       maxOffset: Math.ceil(width / averageCharWidth),
@@ -2580,29 +2612,13 @@ const getLineInfoDefault = (line, tokenResults, embeddedResults, decorations, To
     const tokenType = tokens[i];
     const tokenLength = tokens[i + 1];
     const tokenEnd = start + tokenLength;
-
-    // Check if any decorations overlap with this token
-    let hasOverlap = false;
-    for (const [decorationStart, {
-      end: decorationEnd
-    }] of decorationMap) {
-      if (decorationStart < tokenEnd && decorationEnd > start) {
-        hasOverlap = true;
-        break;
-      }
-    }
+    const hasOverlap = hasDecorationOverlap(decorationMap, start, tokenEnd);
     if (hasOverlap) {
       // Token has decoration overlap - split into parts
       let currentPos = start;
       while (currentPos < tokenEnd) {
         // Find if current position is inside a decoration
-        let activeDecoration = null;
-        for (const [decorationStart, decoration] of decorationMap) {
-          if (decorationStart <= currentPos && decoration.end > currentPos) {
-            activeDecoration = decoration;
-            break;
-          }
-        }
+        const activeDecoration = getActiveDecoration(decorationMap, currentPos);
         if (activeDecoration) {
           // Render decorated part
           const partEnd = Math.min(tokenEnd, activeDecoration.end);
@@ -2721,20 +2737,27 @@ const getVisible$1 = async (editor, syncIncremental) => {
   } = editor;
   const maxLineY = Math.min(minLineY + numberOfVisibleLines, lines.length);
   // @ts-ignore
-  const {
+  let {
     embeddedResults,
     tokenizersToLoad,
     tokens
   } = await getTokensViewport2(editor, minLineY, maxLineY, syncIncremental);
+  for (let i = 0; tokenizersToLoad.length > 0 && i < maxTokenizerLoadPasses; i++) {
+    await loadTokenizers(tokenizersToLoad);
+    // @ts-ignore
+    const refreshed = await getTokensViewport2(editor, minLineY, maxLineY, syncIncremental);
+    ({
+      embeddedResults,
+      tokenizersToLoad,
+      tokens
+    } = refreshed);
+  }
   const minLineOffset = await offsetAtSync(editor, minLineY, 0);
   const averageCharWidth = charWidth;
   const {
     differences,
     result
   } = getLineInfosViewport(editor, tokens, embeddedResults, minLineY, maxLineY, minLineOffset, width, deltaX, averageCharWidth);
-  if (tokenizersToLoad.length > 0) {
-    loadTokenizers(tokenizersToLoad);
-  }
   return {
     differences,
     textInfos: result
@@ -2743,6 +2766,9 @@ const getVisible$1 = async (editor, syncIncremental) => {
 
 const getScrollBarOffset = (delta, finalDelta, size, scrollBarSize) => {
   const scrollBarOffset = delta / finalDelta * (size - scrollBarSize);
+  if (!Number.isFinite(scrollBarOffset)) {
+    return 0;
+  }
   return scrollBarOffset;
 };
 const getScrollBarY = getScrollBarOffset;
@@ -2784,12 +2810,14 @@ const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
   };
 };
 
-let enabled = false;
+const state$b = {
+  enabled: false
+};
 const setEnabled = value => {
-  enabled = value;
+  state$b.enabled = value;
 };
 const getEnabled = () => {
-  return enabled;
+  return state$b.enabled;
 };
 
 // TODO this should be in a separate scrolling module
@@ -2871,7 +2899,7 @@ const getIncrementalEdits = async (oldState, newState) => {
  * @returns Array of regex matches
  */
 const getRegexMatches = (text, regex) => {
-  return [...text.matchAll(regex)];
+  return text.matchAll(regex).toArray();
 };
 
 // URL matching regex pattern - matches common URL schemes
@@ -2969,7 +2997,7 @@ const getUrlAtOffset = (editor, offset) => {
 
 const EditorChange = 1;
 
-const state$6 = Object.create(null);
+const state$a = Object.create(null);
 
 /**
  * Register a listener for a specific event type
@@ -2979,13 +3007,13 @@ const state$6 = Object.create(null);
 const registerListener$1 = (listenerType, rpcId) => {
   number(listenerType);
   number(rpcId);
-  if (!state$6[listenerType]) {
-    state$6[listenerType] = [];
+  if (!Object.hasOwn(state$a, listenerType)) {
+    state$a[listenerType] = [];
   }
 
   // Avoid duplicate registrations
-  if (!state$6[listenerType].includes(rpcId)) {
-    state$6[listenerType].push(rpcId);
+  if (!state$a[listenerType].includes(rpcId)) {
+    state$a[listenerType].push(rpcId);
   }
 };
 
@@ -2997,10 +3025,10 @@ const registerListener$1 = (listenerType, rpcId) => {
 const unregisterListener$1 = (listenerType, rpcId) => {
   number(listenerType);
   number(rpcId);
-  if (state$6[listenerType]) {
-    const index = state$6[listenerType].indexOf(rpcId);
+  if (Object.hasOwn(state$a, listenerType)) {
+    const index = state$a[listenerType].indexOf(rpcId);
     if (index !== -1) {
-      state$6[listenerType].splice(index, 1);
+      state$a[listenerType].splice(index, 1);
     }
   }
 };
@@ -3012,7 +3040,7 @@ const unregisterListener$1 = (listenerType, rpcId) => {
  */
 const getListeners = listenerType => {
   number(listenerType);
-  return state$6[listenerType] || [];
+  return state$a[listenerType] || [];
 };
 
 /**
@@ -3122,13 +3150,13 @@ const measureTextWidthFast = async (text, charWidth) => {
 };
 
 const measureTextWidthSlow = async (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
-  const width = await invoke$b('TextMeasurement.measureTextWidth', text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth);
+  const width = await invoke$c('TextMeasurement.measureTextWidth', text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth);
   return width;
 };
 
 const measureTextWidth = async (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
   // TODO maybe have a property for the whole text document
-  // whether the document is ascii or not
+  // whether the document is ASCII or not
   // so that it doesn't need to be checked on every cursor change
   // or scroll position change
   if (isMonoSpaceFont && isAscii(text)) {
@@ -3240,16 +3268,6 @@ const from = (array, getSelection) => {
   }
   return newSelections;
 };
-const push = (selections, startRowIndex, startColumnIndex, endRowIndex, endColumnIndex) => {
-  const oldLength = selections.length;
-  const newSelections = alloc(oldLength + 4);
-  newSelections.set(selections);
-  newSelections[oldLength + 1] = startRowIndex;
-  newSelections[oldLength + 2] = startColumnIndex;
-  newSelections[oldLength + 3] = endRowIndex;
-  newSelections[oldLength + 4] = endColumnIndex;
-  return newSelections;
-};
 
 // TODO maybe only accept sorted selection edits in the first place
 
@@ -3482,7 +3500,7 @@ const scheduleDocumentAndCursorsSelections = async (editor, changes, selectionCh
   // invalidStartIndex, lineCache, etc. just for testing editorType
   const invalidStartIndex = Math.min(editor.invalidStartIndex, changes[0].start.rowIndex);
 
-  // TODO maybe put undostack into indexeddb so that there is no memory leak in application
+  // TODO maybe put undostack into indexeddb so that there is no memory leak in app
   // then clear old undostack from indexeddb after 3 days
   // TODO should push to undostack after rendering
   const autoClosingRanges = applyAutoClosingRangesEdit(editor, changes);
@@ -3509,10 +3527,12 @@ const scheduleDocumentAndCursorsSelections = async (editor, changes, selectionCh
   }
 
   // Notify registered listeners about editor changes
-  notifyListeners(EditorChange, 'handleEditorChanged', editor.uid, editor.uri, changes).catch(error => {
+  try {
+    await notifyListeners(EditorChange, 'handleEditorChanged', editor.uid, editor.uri, changes);
+  } catch (error) {
     // Silently ignore notification errors to not interrupt the edit flow
     console.warn('Failed to notify editor change listeners:', error);
-  });
+  }
   const incrementalEdits = await getIncrementalEdits(editor, newEditorWithDecorations);
   const editorWithNewWidgets = await applyWidgetChanges(newEditorWithDecorations, changes);
   const newEditor2 = {
@@ -3794,7 +3814,23 @@ const execute = async ({
   return result;
 };
 
-const executeDiagnosticProvider = editor => {
+const getTextDocument$1 = editor => {
+  return {
+    documentId: editor.id || editor.uid,
+    languageId: editor.languageId,
+    text: getText$1(editor),
+    uri: editor.uri
+  };
+};
+const executeIsolatedDiagnosticProvider = async editor => {
+  const textDocument = getTextDocument$1(editor);
+  return invoke$e('Extensions.executeDiagnosticProvider', textDocument);
+};
+const executeDiagnosticProvider = async editor => {
+  const isolatedDiagnostics = await executeIsolatedDiagnosticProvider(editor);
+  if (isolatedDiagnostics.length > 0) {
+    return isolatedDiagnostics;
+  }
   const {
     assetDir,
     platform
@@ -3916,7 +3952,7 @@ const updateDiagnostics = async newState => {
     };
     set$7(newState.id, latest.oldState, newEditor);
     // @ts-ignore
-    await invoke$c('Editor.rerender', newState.id);
+    await invoke$b('Editor.rerender', newState.id);
     return newEditor;
   } catch (error) {
     // @ts-ignore
@@ -3990,6 +4026,7 @@ const createEditor = async ({
     fontFamily,
     fontSize,
     fontWeight,
+    handleOffset: 0,
     handleOffsetX: 0,
     height,
     id,
@@ -4085,7 +4122,7 @@ const createEditor = async ({
 };
 
 const isEqual$2 = (oldState, newState) => {
-  return oldState.itemHeight === newState.itemHeight;
+  return oldState.rowHeight === newState.rowHeight && oldState.deltaY === newState.deltaY && oldState.finalDeltaY === newState.finalDeltaY && oldState.height === newState.height && oldState.scrollBarHeight === newState.scrollBarHeight;
 };
 
 const isEqual$1 = (oldState, newState) => {
@@ -4264,7 +4301,7 @@ const applyWorkspaceEdit = async (editor, changes) => {
     return editor;
   }
   // TODO
-  // for now only apply edits to single file, if it matches the uri
+  // for now only apply edits to single file, if it matches the URI
   //
   // in the future:
   // 1. if a change targets the current editor, apply an edit to this editor
@@ -4339,9 +4376,7 @@ const create$8 = () => {
       const segments = segmenter.segment(line);
       return segments.containing(index);
     },
-    getSegments(line) {
-      return segmenter.segment(line);
-    },
+    getSegments: line => segmenter.segment(line),
     modelIndex(line, visualIndex) {
       const segments = segmenter.segment(line);
       let currentVisualIndex = 0;
@@ -4441,13 +4476,13 @@ const at = async (editor, eventX, eventY) => {
     y
   } = editor;
   const rowIndex = Math.floor((eventY - y + deltaY) / rowHeight);
-  const relativeX = eventX - x + deltaX;
   if (rowIndex < 0) {
     return {
       columnIndex: 0,
       rowIndex: 0
     };
   }
+  const relativeX = eventX - x + deltaX;
   const clampedRowIndex = clamp(rowIndex, 0, lines.length - 1);
   const line = lines[clampedRowIndex];
   const columnIndex = await getAccurateColumnIndex(line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, relativeX);
@@ -4458,7 +4493,7 @@ const at = async (editor, eventX, eventY) => {
 };
 
 /**
- * @deprecated this doesn't work for variable width characters (unicode/emoji).
+ * @deprecated this doesn't work for variable width characters (Unicode/emoji).
  * Use position computation in renderer process instead
  *
  * @param {object} editor
@@ -4483,7 +4518,7 @@ const y = (editor, rowIndex) => {
   return offsetY;
 };
 
-const state$5 = {
+const state$9 = {
   timeout: -1
 };
 
@@ -4506,7 +4541,7 @@ const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError
   const y$1 = y(editor, rowIndex);
   const displayErrorMessage = message;
   // @ts-ignore
-  await invoke$c('Editor.showOverlayMessage', editor, 'Viewlet.send', editor.uid, 'showOverlayMessage', x$1, y$1, displayErrorMessage);
+  await invoke$b('Editor.showOverlayMessage', editor, 'Viewlet.send', editor.uid, 'showOverlayMessage', x$1, y$1, displayErrorMessage);
   if (!isError) {
     const handleTimeout = () => {
       editorHideMessage(editor);
@@ -4514,7 +4549,7 @@ const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError
 
     // TODO use wrapper timing module instead of this
     // @ts-ignore
-    state$5.timeout = setTimeout(handleTimeout, 3000);
+    state$9.timeout = setTimeout(handleTimeout, 3000);
   }
   return editor;
 };
@@ -4534,16 +4569,14 @@ const showErrorMessage = async (editor, rowIndex, columnIndex, message) => {
 
 // @ts-ignore
 const editorHideMessage = async editor => {
-  clearTimeout(state$5.timeout);
-  state$5.timeout = -1;
+  clearTimeout(state$9.timeout);
+  state$9.timeout = -1;
   // await RendererProcess.invoke(/* Viewlet.send */ 'Viewlet.send', /* id */ editor.uid, /* method */ 'hideOverlayMessage')
   return editor;
 };
 
 // @ts-ignore
-const getErrorMessage$4 = error => {
-  return `${error}`;
-};
+const getErrorMessage$4 = String;
 
 // @ts-ignore
 const getMatchingClosingBrace$1 = brace => {
@@ -4563,7 +4596,7 @@ const braceCompletion = async (editor, text) => {
     // @ts-ignore
     const offset = offsetAt(editor, editor.cursor);
     // @ts-ignore
-    const result = await invoke$c('ExtensionHostBraceCompletion.executeBraceCompletionProvider', editor, offset, text);
+    const result = await invoke$b('ExtensionHostBraceCompletion.executeBraceCompletionProvider', editor, offset, text);
     if (result) {
       const closingBrace = getMatchingClosingBrace$1(text);
       const insertText = text + closingBrace;
@@ -4653,12 +4686,12 @@ const launchRenameWorker = async () => {
   return rpc;
 };
 
-let workerPromise$2;
+const state$8 = {};
 const getOrCreate$2 = () => {
-  if (!workerPromise$2) {
-    workerPromise$2 = launchRenameWorker();
+  if (!state$8.workerPromise) {
+    state$8.workerPromise = launchRenameWorker();
   }
-  return workerPromise$2;
+  return state$8.workerPromise;
 };
 const invoke$5 = async (method, ...params) => {
   const worker = await getOrCreate$2();
@@ -4778,12 +4811,12 @@ const openColorPicker = async editor => {
   return addWidgetToEditor(ColorPicker$1, ColorPicker, editor, create$6, newStateGenerator$6);
 };
 
-const state$4 = {
+const state$7 = {
   compositionText: '',
   isComposing: false
 };
 const compositionStart = (editor, event) => {
-  state$4.isComposing = true;
+  state$7.isComposing = true;
   return editor;
 };
 const getCompositionChanges = (selections, data) => {
@@ -4793,9 +4826,9 @@ const getCompositionChanges = (selections, data) => {
     const selectionStartColumn = selections[i + 1];
     const selectionEndRow = selections[i + 2];
     const selectionEndColumn = selections[i + 3];
-    const startColumnIndex = selectionStartColumn - state$4.compositionText.length;
+    const startColumnIndex = selectionStartColumn - state$7.compositionText.length;
     changes.push({
-      deleted: [state$4.compositionText],
+      deleted: [state$7.compositionText],
       end: {
         columnIndex: selectionEndColumn,
         rowIndex: selectionEndRow
@@ -4815,7 +4848,7 @@ const compositionUpdate = (editor, data) => {
     selections
   } = editor;
   const changes = getCompositionChanges(selections, data);
-  state$4.compositionText = data;
+  state$7.compositionText = data;
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 const compositionEnd = (editor, data) => {
@@ -4823,8 +4856,8 @@ const compositionEnd = (editor, data) => {
     selections
   } = editor;
   const changes = getCompositionChanges(selections, data);
-  state$4.isComposing = false;
-  state$4.compositionText = '';
+  state$7.isComposing = false;
+  state$7.compositionText = '';
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
@@ -5064,7 +5097,7 @@ const tryRegexArray = (partialLine, regexArray) => {
   return 1;
 };
 const RE_WORD_LEFT_1 = /(?<![A-Z])[A-Z]+\s*$/;
-const RE_WORD_LEFT_2 = /[\u00C0-\u017F\w\-]+>?\s*$/;
+const RE_WORD_LEFT_2 = /[\u{C0}-\u{17F}\w\-]+>?\s*$/u;
 const RE_WORD_LEFT_3 = /[a-zA-Z]+[^a-zA-Z\d]+\s*$/;
 const RE_WORD_LEFT_4 = /\s+$/;
 const RE_WORD_LEFT_5 = /[^a-zA-Z\d]+\s*$/;
@@ -5075,7 +5108,7 @@ const wordLeft = (line, columnIndex) => {
   const partialLine = line.slice(0, columnIndex);
   return tryRegexArray(partialLine, RE_WORD_LEFT);
 };
-const RE_WORD_RIGHT_1 = /^\s*[\u00C0-\u017F\w]+/i;
+const RE_WORD_RIGHT_1 = /^\s*[\u{C0}-\u{17F}\w]+/iu;
 const RE_WORD_RIGHT_2 = /^[^a-zA-Z\d]+\w*/;
 const RE_WORD_RIGHT = [RE_WORD_RIGHT_1, RE_WORD_RIGHT_2];
 const wordRight = (line, columnIndex) => {
@@ -5496,7 +5529,7 @@ const deleteWordRight = editor => {
 
 const findAllReferences$1 = async editor => {
   // @ts-ignore
-  await invoke$c('SideBar.show', 'References', /* focus */true);
+  await invoke$b('SideBar.show', 'References', /* focus */true);
   return editor;
 };
 
@@ -5533,7 +5566,7 @@ const format = async editor => {
     console.error(error);
 
     // TODO configure editor message as widget
-    const displayErrorMessage = `${error}`;
+    const displayErrorMessage = String(error);
     await editorShowMessage(editor, 0, 0, displayErrorMessage, true);
     return editor;
   }
@@ -5584,7 +5617,7 @@ const getWordBefore = (editor, rowIndex, columnIndex) => {
 // @ts-ignore
 const getDefinition = async (editor, offset) => {
   // @ts-ignore
-  const definition = await invoke$c('ExtensionHostDefinition.executeDefinitionProvider', editor, offset);
+  const definition = await invoke$b('ExtensionHostDefinition.executeDefinitionProvider', editor, offset);
   return definition;
 };
 
@@ -5817,7 +5850,7 @@ const goTo = async ({
 // TODO possible to do this with events/state machine instead of promises -> enables canceling operations / concurrent calls
 
 // TODO there are still race conditions in this function:
-// - when open is called twice, previous dom nodes can either be reused or the previous dom nodes must be disposed
+// - when open is called twice, previous DOM nodes can either be reused or the previous DOM nodes must be disposed
 
 // @ts-ignore
 const getLocation$1 = async (editor, rowIndex, columnIndex) => {
@@ -5833,18 +5866,7 @@ const getNoLocationFoundMessage$1 = info => {
   }
   return noDefinitionFound();
 };
-
-// @ts-ignore
-const getErrorMessage$3 = error => {
-  // if (
-  //   error &&
-  //   error.message &&
-  //   error.message.startsWith('Failed to execute definition provider: ')
-  // ) {
-  //   return error.message.replace('Failed to execute definition provider: ', '')
-  // }
-  return `${error}`;
-};
+const getErrorMessage$3 = String;
 
 // @ts-ignore
 const isNoProviderFoundError$1 = error => {
@@ -5869,7 +5891,7 @@ const getNoLocationFoundMessage = info => {
 
 const getTypeDefinition = async (editor, offset) => {
   // @ts-ignore
-  const definition = await invoke$c('ExtensionHostTypeDefinition.executeTypeDefinitionProvider', editor, offset);
+  const definition = await invoke$b('ExtensionHostTypeDefinition.executeTypeDefinitionProvider', editor, offset);
   return definition;
 };
 
@@ -5878,21 +5900,7 @@ const getLocation = async (editor, rowIndex, columnIndex) => {
   const definition = await getTypeDefinition(editor, offset);
   return definition;
 };
-
-// @ts-ignore
-const getErrorMessage$2 = error => {
-  // if (
-  //   error &&
-  //   error.message &&
-  //   error.message.startsWith('Failed to execute type definition provider: ')
-  // ) {
-  //   return error.message.replace(
-  //     'Failed to execute type definition provider: ',
-  //     ''
-  //   )
-  // }
-  return `${error}`;
-};
+const getErrorMessage$2 = String;
 const isNoProviderFoundError = error => {
   return error?.message?.startsWith('Failed to execute type definition provider: No type definition provider found');
 };
@@ -5925,19 +5933,19 @@ const closeWidgetsMaybe = widgets => {
   return widgets.filter(isPersistentWidget);
 };
 
-const state$3 = {
+const state$6 = {
   position: {
     columnIndex: 0,
     rowIndex: 0
   }
 };
 const getPosition$1 = () => {
-  return state$3.position;
+  return state$6.position;
 };
 
 // @ts-ignore
 const setPosition$1 = position => {
-  state$3.position = position;
+  state$6.position = position;
 };
 
 const openExternal = async (url, platform) => {
@@ -6052,8 +6060,8 @@ const handleContextMenu = async (editor, button, x, y) => {
 // @ts-ignore
 
 // match all words, including umlauts, see https://stackoverflow.com/questions/5436824/matching-accented-characters-with-javascript-regexes/#answer-11550799
-const RE_WORD_START = /^[a-z\u00C0-\u017F\d]+/i;
-const RE_WORD_END = /[a-z\u00C0-\u017F\d]+$/i;
+const RE_WORD_START = /^[a-zA-Z\u{C0}-\u{17F}\d]+/u;
+const RE_WORD_END = /[a-zA-Z\u{C0}-\u{17F}\d]+$/u;
 
 // @ts-ignore
 const getNewSelections$7 = (line, rowIndex, columnIndex) => {
@@ -6155,20 +6163,20 @@ const handleMouseDown = (state, button, altKey, ctrlKey, x, y, detail) => {
   }
 };
 
-const state$2 = {
+const state$5 = {
   editor: undefined,
   timeout: -1,
   x: 0,
   y: 0
 };
 const get = () => {
-  return state$2;
+  return state$5;
 };
 const set = (editor, timeout, x, y) => {
-  state$2.editor = editor;
-  state$2.timeout = timeout;
-  state$2.x = x;
-  state$2.y = y;
+  state$5.editor = editor;
+  state$5.timeout = timeout;
+  state$5.x = x;
+  state$5.y = y;
 };
 
 const showHover$1 = async (editor, position) => {
@@ -6309,12 +6317,13 @@ const editorHandleNativeSelectionChange = (editor, range) => {
   return scheduleSelections(editor, selections);
 };
 
-const state$1 = {
+const state$4 = {
   /**
    * @type {any}
    */
   currentEditor: undefined,
   hasListener: false,
+  isSelecting: false,
   position: {
     columnIndex: 0,
     rowIndex: 0
@@ -6323,26 +6332,33 @@ const state$1 = {
 
 // @ts-ignore
 const setEditor = editor => {
-  state$1.currentEditor = editor;
-  state$1.hasListener = true;
+  state$4.currentEditor = editor;
+  state$4.hasListener = true;
 };
 const clearEditor = () => {
-  state$1.currentEditor = undefined;
-  state$1.hasListener = false;
+  state$4.currentEditor = undefined;
+  state$4.hasListener = false;
+  state$4.isSelecting = false;
+};
+const startSelecting = () => {
+  state$4.isSelecting = true;
+};
+const isSelecting = () => {
+  return state$4.isSelecting;
 };
 
 // @ts-ignore
 const setPosition = position => {
-  state$1.position = position;
+  state$4.position = position;
 };
 const getEditor$1 = () => {
-  return state$1.currentEditor;
+  return state$4.currentEditor;
 };
 const getPosition = () => {
-  return state$1.position;
+  return state$4.position;
 };
 const hasListener = () => {
-  return state$1.hasListener;
+  return state$4.hasListener;
 };
 
 // @ts-ignore
@@ -6352,6 +6368,7 @@ const handlePointerCaptureLost = editor => {
 };
 
 const handlePointerDown$1 = (state, button, altKey, ctrlKey, x, y, detail) => {
+  startSelecting();
   return handleMouseDown(state, button, altKey, ctrlKey, x, y, detail);
 };
 
@@ -6533,6 +6550,9 @@ const moveSelectionPx = async (editor, x, y) => {
 };
 
 const handlePointerMove = async (editor, x, y, altKey) => {
+  if (!isSelecting()) {
+    return editor;
+  }
   if (altKey) {
     return moveRectangleSelectionPx(editor, x, y);
   }
@@ -6571,8 +6591,6 @@ const handleScrollBarHorizontalMove = (state, eventX) => {
     width,
     x
   } = state;
-  const spaceRight = 20; // TODO make this configurable
-  const normalizedEventX = clamp(eventX, x, x + width);
   if (width > longestLineWidth) {
     return {
       ...state,
@@ -6580,6 +6598,8 @@ const handleScrollBarHorizontalMove = (state, eventX) => {
       scrollBarWidth: 0
     };
   }
+  const spaceRight = 20; // TODO make this configurable
+  const normalizedEventX = clamp(eventX, x, x + width);
   const relativeX = normalizedEventX - x - handleOffsetX;
   const scrollBarWidth = getScrollBarWidth(width, longestLineWidth);
   const finalDeltaX = longestLineWidth - width + spaceRight;
@@ -6647,18 +6667,17 @@ const getNewPercent = (state, relativeY) => {
   // clicked at bottom
   return 1;
 };
-
-// @ts-ignore
-const handleScrollBarMove = (state, eventY) => {
+const handleScrollBarMove = async (state, eventY) => {
   const {
     finalDeltaY,
-    handleOffset,
+    handleOffset = 0,
     y
   } = state;
   const relativeY = eventY - y - handleOffset;
   const newPercent = getNewPercent(state, relativeY);
   const newDeltaY = newPercent * finalDeltaY;
-  return setDeltaYFixedValue$1(state, newDeltaY);
+  const newState = await setDeltaYFixedValue$1(state, newDeltaY);
+  return newState;
 };
 const handleScrollBarVerticalPointerMove = handleScrollBarMove;
 
@@ -6668,7 +6687,7 @@ const handleScrollBarVerticalPointerMove = handleScrollBarMove;
 // when clicked at y > editor.height - editor.scrollBarHeight/2, position scrollbar at (y - scrollbarHeight/2)
 // additionally, when clicked on scrollbar, scrollbar position shouldn't move
 
-const handleScrollBarPointerDown = (state, eventY) => {
+const handleScrollBarPointerDown = async (state, eventY) => {
   const {
     deltaY,
     finalDeltaY,
@@ -6690,8 +6709,9 @@ const handleScrollBarPointerDown = (state, eventY) => {
     percent
   } = getNewDeltaPercent(height, scrollBarHeight, relativeY);
   const newDeltaY = percent * finalDeltaY;
+  const newState = await setDeltaYFixedValue$1(state, newDeltaY);
   return {
-    ...setDeltaYFixedValue$1(state, newDeltaY),
+    ...newState,
     handleOffset
   };
 };
@@ -6718,7 +6738,7 @@ const handleTouchEnd = (editor, touchEvent) => {
   // }
 };
 
-const state = {
+const state$3 = {
   deltaY: 0,
   touchOffsetY: 0
 };
@@ -6729,8 +6749,8 @@ const handleTouchStart = (editor, touchEvent) => {
     return;
   }
   const firstTouch = touchEvent.touches[0];
-  state.touchOffsetY = firstTouch.y;
-  state.deltaY = editor.deltaY;
+  state$3.touchOffsetY = firstTouch.y;
+  state$3.deltaY = editor.deltaY;
   // const position = EditorPosition.at(editor, firstTouch.x, firstTouch.y)
   // EditorMoveSelection.state.position = position
   // state.date = Date.now()
@@ -6758,7 +6778,7 @@ const setDelta = (editor, deltaMode, eventDeltaX, eventDeltaY) => {
   if (eventDeltaX === 0) {
     return setDeltaY(editor, eventDeltaY);
   }
-  const newDeltaX = clamp(deltaX + eventDeltaX, 0, Number.POSITIVE_INFINITY);
+  const newDeltaX = clamp(deltaX + eventDeltaX, 0, Infinity);
   return {
     ...setDeltaY(editor, eventDeltaY),
     deltaX: newDeltaX
@@ -6771,7 +6791,7 @@ const handleTouchMove = (editor, touchEvent) => {
     return;
   }
   const firstTouch = touchEvent.touches[0];
-  const offsetY = state.deltaY + (state.touchOffsetY - firstTouch.y);
+  const offsetY = state$3.deltaY + (state$3.touchOffsetY - firstTouch.y);
   setDeltaYFixedValue(editor, offsetY);
 };
 
@@ -6829,22 +6849,19 @@ const getChanges$1 = selections => {
       rowsToIndent.push(i);
     }
   }
-  const changes = [];
-  for (const rowToIndent of rowsToIndent) {
-    changes.push({
-      deleted: [''],
-      end: {
-        columnIndex: 0,
-        rowIndex: rowToIndent
-      },
-      inserted: ['  '],
-      origin: IndentMore,
-      start: {
-        columnIndex: 0,
-        rowIndex: rowToIndent
-      }
-    });
-  }
+  const changes = Array.from(rowsToIndent, rowToIndent => ({
+    deleted: [''],
+    end: {
+      columnIndex: 0,
+      rowIndex: rowToIndent
+    },
+    inserted: ['  '],
+    origin: IndentMore,
+    start: {
+      columnIndex: 0,
+      rowIndex: rowToIndent
+    }
+  }));
   return changes;
 };
 const indentMore = editor => {
@@ -6857,7 +6874,7 @@ const indentMore = editor => {
 
 const getLanguageConfiguration = async editor => {
   // @ts-ignore
-  return invoke$c('Languages.getLanguageConfiguration', {
+  return invoke$b('Languages.getLanguageConfiguration', {
     languageId: editor.languageId,
     uri: editor.uri
   });
@@ -7364,12 +7381,12 @@ const print = error => {
     return `${error.type}: ${error.message}\n${error.stack}`;
   }
   if (error && error.stack) {
-    return `${error.stack}`;
+    return error.stack;
   }
   if (error === null) {
     return null;
   }
-  return `${error}`;
+  return String(error);
 };
 
 // @ts-nocheck
@@ -7399,7 +7416,7 @@ const isUntitledFile = uri => {
 };
 
 const saveNormalFile = async (uri, content) => {
-  await invoke$c('FileSystem.writeFile', uri, content);
+  await invoke$b('FileSystem.writeFile', uri, content);
 };
 
 const showFilePicker = async platform => {
@@ -7419,9 +7436,9 @@ const saveUntitledFile = async (uri, content, platform) => {
   if (!filePath) {
     return;
   }
-  await invoke$c('FileSystem.writeFile', filePath, content);
+  await invoke$b('FileSystem.writeFile', filePath, content);
   await handleWorkspaceRefresh();
-  await invoke$c('Main.handleUriChange', uri, filePath);
+  await invoke$b('Main.handleUriChange', uri, filePath);
   return filePath;
 };
 
@@ -7443,9 +7460,8 @@ const save = async editor => {
         };
       }
       return newEditor;
-    } else {
-      await saveNormalFile(uri, content);
     }
+    await saveNormalFile(uri, content);
     return {
       ...newEditor,
       modified: false
@@ -7753,7 +7769,7 @@ const selectInsideString = editor => {
 
 const getNewSelections = async (editor, selections) => {
   // @ts-ignore
-  const newSelections = await invoke$c('ExtensionHostSelection.executeGrowSelection', editor, selections);
+  const newSelections = await invoke$b('ExtensionHostSelection.executeGrowSelection', editor, selections);
   if (newSelections.length === 0) {
     return selections;
   }
@@ -7781,7 +7797,7 @@ const selectionGrow = async editor => {
 // ccc
 
 // when clicking first at position 4 and then position 2,
-// - vscode selects next position 3 and refuses to select position 1
+// - VS Code selects next position 3 and refuses to select position 1
 // - atom also selects next position 3 and refuses to select position 1
 // - WebStorm also selects next position 3 and refuses to select position 1
 // - brackets (codemirror) selects position 3 and then selects position 1
@@ -7797,7 +7813,13 @@ const getSelectionEditsSingleLineWord = (lines, selections) => {
   const columnIndexAfter = line.indexOf(word, lastSelectionEndColumnIndex);
   if (columnIndexAfter !== -1) {
     const columnIndexAfterEnd = columnIndexAfter + word.length;
-    const newSelections = push(selections, rowIndex, columnIndexAfter, rowIndex, columnIndexAfterEnd);
+    const newSelections = new Uint32Array(selections.length + 4);
+    newSelections.set(selections, 0);
+    const insertIndex = selections.length;
+    newSelections[insertIndex] = rowIndex;
+    newSelections[insertIndex + 1] = columnIndexAfter;
+    newSelections[insertIndex + 2] = rowIndex;
+    newSelections[insertIndex + 3] = columnIndexAfterEnd;
     return {
       revealRange: newSelections.length - 4,
       selectionEdits: newSelections
@@ -7842,25 +7864,25 @@ const getSelectionEditsSingleLineWord = (lines, selections) => {
       startRowIndex = selections[selectionIndex];
       const startColumnIndex = selections[selectionIndex + 1];
       const endColumnIndex = selections[selectionIndex + 3];
-      if (startRowIndex === i && startColumnIndex <= columnIndex && columnIndex <= endColumnIndex) {
-        continue;
-      }
-      if (startRowIndex > i) {
-        selectionIndex -= 4;
+      const isSelected = startRowIndex === i && startColumnIndex <= columnIndex && columnIndex <= endColumnIndex;
+      if (!isSelected) {
+        if (startRowIndex > i) {
+          selectionIndex -= 4;
+        }
+        const columnEndIndex = columnIndex + word.length;
+        selectionIndex += 4;
+        const newSelections = new Uint32Array(selections.length + 4);
+        newSelections.set(selections.subarray(0, selectionIndex), 0);
+        newSelections[selectionIndex] = i;
+        newSelections[selectionIndex + 1] = columnIndex;
+        newSelections[selectionIndex + 2] = i;
+        newSelections[selectionIndex + 3] = columnEndIndex;
+        newSelections.set(selections.subarray(selectionIndex), selectionIndex + 4);
+        return {
+          revealRange: newSelections.length - 4,
+          selectionEdits: newSelections
+        };
       }
-      const columnEndIndex = columnIndex + word.length;
-      selectionIndex += 4;
-      const newSelections = new Uint32Array(selections.length + 4);
-      newSelections.set(selections.subarray(0, selectionIndex), 0);
-      newSelections[selectionIndex] = i;
-      newSelections[selectionIndex + 1] = columnIndex;
-      newSelections[selectionIndex + 2] = i;
-      newSelections[selectionIndex + 3] = columnEndIndex;
-      newSelections.set(selections.subarray(selectionIndex), selectionIndex + 4);
-      return {
-        revealRange: newSelections.length - 4,
-        selectionEdits: newSelections
-      };
     }
   }
   return undefined;
@@ -7915,13 +7937,13 @@ const getSelectNextOccurrenceResult = editor => {
 // ccc
 
 // when clicking first at position 4 and then position 2,
-// - vscode selects next position 3 and refuses to select position 1
+// - VS Code selects next position 3 and refuses to select position 1
 // - atom also selects next position 3 and refuses to select position 1
 // - WebStorm also selects next position 3 and refuses to select position 1
 // - brackets (codemirror) selects position 3 and then selects position 1
 // - sublime selects next position 1, then next position 3
 
-const isRangeInViewPort = (minLineY, maxLineY, startRowIndex, endRowIndex) => {
+const isRangeInViewport = (minLineY, maxLineY, startRowIndex, endRowIndex) => {
   return startRowIndex >= minLineY && endRowIndex <= maxLineY;
 };
 
@@ -7932,14 +7954,12 @@ const selectNextOccurrence = editor => {
     return editor;
   }
   const {
-    revealRange
-  } = result;
-  const {
+    revealRange,
     selectionEdits
   } = result;
   const revealRangeStartRowIndex = selectionEdits[revealRange];
   const revealRangeEndRowIndex = selectionEdits[revealRange + 2];
-  if (isRangeInViewPort(editor.minLineY, editor.maxLineY, revealRangeStartRowIndex, revealRangeEndRowIndex)) {
+  if (isRangeInViewport(editor.minLineY, editor.maxLineY, revealRangeStartRowIndex, revealRangeEndRowIndex)) {
     return scheduleSelections(editor, selectionEdits);
   }
   // TODO what is this magic number 5?
@@ -8004,6 +8024,7 @@ const setLanguageId = async (editor, languageId, tokenizePath) => {
   const {
     tokenizerId
   } = editor;
+  setTokenizePath(languageId, tokenizePath);
   // TODO move tokenizer to syntax highlighting worker
   // TODO only load tokenizer if not already loaded
   // if already loaded just set tokenizer and rerender text
@@ -8144,12 +8165,12 @@ const launchHoverWorker = async () => {
   return rpc;
 };
 
-let workerPromise$1;
+const state$2 = {};
 const getOrCreate$1 = () => {
-  if (!workerPromise$1) {
-    workerPromise$1 = launchHoverWorker();
+  if (!state$2.workerPromise) {
+    state$2.workerPromise = launchHoverWorker();
   }
-  return workerPromise$1;
+  return state$2.workerPromise;
 };
 const invoke$2 = async (method, ...params) => {
   const worker = await getOrCreate$1();
@@ -8186,7 +8207,7 @@ const showHover3 = async editor => {
 
 const EditorHover = 'EditorHover';
 const showHover = async state => {
-  await invoke$c('Viewlet.openWidget', EditorHover);
+  await invoke$b('Viewlet.openWidget', EditorHover);
   return state;
 };
 
@@ -8228,12 +8249,12 @@ const launchSourceActionWorker = async () => {
   return rpc;
 };
 
-let workerPromise;
+const state$1 = {};
 const getOrCreate = () => {
-  if (!workerPromise) {
-    workerPromise = launchSourceActionWorker();
+  if (!state$1.workerPromise) {
+    state$1.workerPromise = launchSourceActionWorker();
   }
-  return workerPromise;
+  return state$1.workerPromise;
 };
 const invoke$1 = async (method, ...params) => {
   const worker = await getOrCreate();
@@ -8449,9 +8470,7 @@ const editorSnippet = (editor, snippet) => {
   return scheduleDocumentAndCursorsSelections(editor, changes, selectionChanges);
 };
 
-const getErrorMessage = error => {
-  return `${error}`;
-};
+const getErrorMessage = String;
 const tabCompletion = async editor => {
   try {
     // TODO race condition
@@ -8477,7 +8496,7 @@ const getBlockComment = async (editor, offset) => {
   } = editor;
   // TODO ask extension host worker,
   // execute block comment provider with
-  // uri, language id, offset
+  // URI, language id, offset
   // and the extension returns a matching block comment or undefined
   try {
     await activateByEvent(`onLanguage:${editor.languageId}`, assetDir, platform);
@@ -8739,7 +8758,7 @@ const toggleComment = async editor => {
   } catch (error$1) {
     error(error$1);
     // TODO use correct position
-    await editorShowMessage(/* editor */editor, /* rowIndex */0, /* columnIndex */0, /* message */`${error$1}`, /* isError */true);
+    await editorShowMessage(/* editor */editor, /* rowIndex */0, /* columnIndex */0, /* message */String(error$1), /* isError */true);
     return editor;
   }
 };
@@ -8832,7 +8851,7 @@ const typeWithAutoClosingQuote = (editor, text) => {
 const typeWithAutoClosingTag = async (editor, text) => {
   const offset = offsetAt(editor, editor.selections[0], editor.selections[1]);
   // @ts-ignore
-  const result = await invoke$c('ExtensionHostClosingTagCompletion.executeClosingTagProvider', editor, offset, text);
+  const result = await invoke$b('ExtensionHostClosingTagCompletion.executeClosingTagProvider', editor, offset, text);
   if (!result) {
     const changes = editorReplaceSelections(editor, [text], EditorType);
     return scheduleDocumentAndCursorsSelections(editor, changes);
@@ -9084,7 +9103,7 @@ const addWidget$1 = (widget, id, render) => {
   // 1. renderDom
   // 2. renderAriaAnnouncement
   // 3. renderFocus
-  // to ensure that focus is always after the element is added to the dom
+  // to ensure that focus is always after the element is added to the DOM
   if (focusCommandIndex !== -1) {
     const command = allCommands[focusCommandIndex];
     allCommands.splice(focusCommandIndex, 1);
@@ -9191,6 +9210,7 @@ const renderFull$4 = (oldState, newState) => {
   return commands;
 };
 
+const commandsToForward$5 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
 const render$b = widget => {
   const commands = renderFull$4(widget.oldState, widget.newState);
   const wrappedCommands = [];
@@ -9198,7 +9218,7 @@ const render$b = widget => {
     uid
   } = widget.newState;
   for (const command of commands) {
-    if (command[0] === SetDom2 || command[0] === SetCss || command[0] === AppendToBody || command[0] === SetBounds2 || command[0] === RegisterEventListeners || command[0] === SetSelectionByName || command[0] === SetValueByName || command[0] === SetFocusContext || command[0] === SetUid || command[0] === 'Viewlet.focusSelector') {
+    if (commandsToForward$5.includes(command[0])) {
       wrappedCommands.push(command);
     } else {
       wrappedCommands.push(['Viewlet.send', uid, ...command]);
@@ -9263,6 +9283,7 @@ const renderFull$3 = (oldState, newState) => {
   return commands;
 };
 
+const commandsToForward$4 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
 const render$a = widget => {
   const commands = renderFull$3(widget.oldState, widget.newState);
   const wrappedCommands = [];
@@ -9270,7 +9291,7 @@ const render$a = widget => {
     uid
   } = widget.newState;
   for (const command of commands) {
-    if (command[0] === SetDom2 || command[0] === SetCss || command[0] === AppendToBody || command[0] === SetBounds2 || command[0] === RegisterEventListeners || command[0] === SetSelectionByName || command[0] === SetValueByName || command[0] === SetFocusContext || command[0] === SetUid || command[0] === 'Viewlet.focusSelector') {
+    if (commandsToForward$4.includes(command[0])) {
       wrappedCommands.push(command);
     } else {
       wrappedCommands.push(['Viewlet.send', uid, ...command]);
@@ -9694,9 +9715,7 @@ const renderHoverDom = {
     const dom = getHoverVirtualDom(newState.lineInfos, newState.documentation, newState.diagnostics);
     return [/* method */SetDom2, dom];
   },
-  isEqual(oldState, newState) {
-    return oldState.lineInfos === newState.lineInfos && oldState.documentation === newState.documentation && oldState.diagnostics === newState.diagnostics;
-  }
+  isEqual: (oldState, newState) => oldState.lineInfos === newState.lineInfos && oldState.documentation === newState.documentation && oldState.diagnostics === newState.diagnostics
 };
 const renderBounds$2 = {
   apply(oldState, newState) {
@@ -9708,9 +9727,7 @@ const renderBounds$2 = {
     } = newState;
     return [SetBounds, x, y, width, height];
   },
-  isEqual(oldState, newState) {
-    return oldState.x === newState.x && oldState.y === newState.y;
-  }
+  isEqual: (oldState, newState) => oldState.x === newState.x && oldState.y === newState.y
 };
 const render$9 = [renderHoverDom, renderBounds$2];
 const renderHover = (oldState, newState) => {
@@ -9723,6 +9740,7 @@ const renderHover = (oldState, newState) => {
   return commands;
 };
 
+const commandsToForward$3 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
 const render$8 = widget => {
   const commands = renderFull$4(widget.oldState, widget.newState);
   const wrappedCommands = [];
@@ -9730,7 +9748,7 @@ const render$8 = widget => {
     uid
   } = widget.newState;
   for (const command of commands) {
-    if (command[0] === SetDom2 || command[0] === SetCss || command[0] === AppendToBody || command[0] === SetBounds2 || command[0] === RegisterEventListeners || command[0] === SetSelectionByName || command[0] === SetValueByName || command[0] === SetFocusContext || command[0] === SetUid || command[0] === 'Viewlet.focusSelector') {
+    if (commandsToForward$3.includes(command[0])) {
       wrappedCommands.push(command);
     } else {
       wrappedCommands.push(['Viewlet.send', uid, ...command]);
@@ -9783,6 +9801,7 @@ const removeWidget$1 = widget => {
   return [['Viewlet.send', widget.newState.uid, 'dispose']];
 };
 
+const commandsToForward$2 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
 const render$7 = widget => {
   const commands = renderFull$4(widget.oldState, widget.newState);
   const wrappedCommands = [];
@@ -9790,7 +9809,7 @@ const render$7 = widget => {
     uid
   } = widget.newState;
   for (const command of commands) {
-    if (command[0] === SetDom2 || command[0] === SetCss || command[0] === AppendToBody || command[0] === SetBounds2 || command[0] === RegisterEventListeners || command[0] === SetSelectionByName || command[0] === SetValueByName || command[0] === SetFocusContext || command[0] === SetUid || command[0] === 'Viewlet.focusSelector') {
+    if (commandsToForward$2.includes(command[0])) {
       wrappedCommands.push(command);
     } else {
       wrappedCommands.push(['Viewlet.send', uid, ...command]);
@@ -9887,7 +9906,7 @@ const getEditorSourceActions = async editorId => {
     languageId
   } = newState;
   // @ts-ignore
-  const allActions = await invoke$c('GetEditorSourceActions.getEditorSourceActions');
+  const allActions = await invoke$b('GetEditorSourceActions.getEditorSourceActions');
   const filtered = filterActions(allActions, languageId);
   return filtered;
 };
@@ -9910,14 +9929,14 @@ const getWordAtOffset = editor => {
 };
 
 const setFocus = async focusKey => {
-  await invoke$c('Focus.setFocus', focusKey);
+  await invoke$b('Focus.setFocus', focusKey);
 };
 const unsetAdditionalFocus = async focusKey => {
   if (!focusKey) {
     return;
   }
   // @ts-ignore
-  await invoke$c('Focus.removeAdditionalFocus', focusKey);
+  await invoke$b('Focus.removeAdditionalFocus', focusKey);
 };
 
 const shouldUpdateSelectionData = (oldState, newState) => {
@@ -10073,7 +10092,7 @@ const getDiagnostics$1 = async editorUid => {
 };
 
 const ensure = async (fontName, fontUrl) => {
-  await invoke$b('TextMeasurement.ensureFont', fontName, fontUrl);
+  await invoke$c('TextMeasurement.ensureFont', fontName, fontUrl);
 };
 
 const getKeyBindings = () => {
@@ -10631,7 +10650,7 @@ const handleBeforeInput = (editor, inputType, data) => {
 };
 
 const handleMessagePort = async (port, rpcId) => {
-  const rpc = await create$c({
+  const rpc = await create$b({
     commandMap: {},
     messagePort: port
   });
@@ -10722,12 +10741,14 @@ const restoreWidgetState = async (keys, savedStates) => {
   return newEditors;
 };
 
-let isReloading = false;
+const state = {
+  isReloading: false
+};
 const hotReload = async () => {
-  if (isReloading) {
+  if (state.isReloading) {
     return;
   }
-  isReloading = true;
+  state.isReloading = true;
 
   // TODO use getEditors
   const keys = getKeys$2();
@@ -10740,71 +10761,8 @@ const hotReload = async () => {
 
   // TODO ask renderer worker to rerender all editors
   // @ts-ignore
-  await invoke$c(`Editor.rerender`);
-  isReloading = false;
-};
-
-const sendMessagePortToExtensionHostWorker2 = async (port, initialCommand, rpcId) => {
-  await sendMessagePortToExtensionHostWorker(port, rpcId);
-};
-
-const createExtensionHostRpc = async () => {
-  try {
-    const initialCommand = 'HandleMessagePort.handleMessagePort2';
-    const rpc = await create$e({
-      commandMap: {},
-      async send(port) {
-        await sendMessagePortToExtensionHostWorker2(port, initialCommand, EditorWorker);
-      }
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create extension host rpc`);
-  }
-};
-
-const initializeExtensionHost = async () => {
-  const extensionHostRpc = await createExtensionHostRpc();
-  set$1(extensionHostRpc);
-};
-
-const createExtensionManagementWorkerRpc = async () => {
-  try {
-    const rpc = await create$e({
-      commandMap: {},
-      async send(port) {
-        await sendMessagePortToExtensionManagementWorker(port, EditorWorker);
-      }
-    });
-    return rpc;
-  } catch (error) {
-    throw new VError(error, `Failed to create extension management worker rpc`);
-  }
-};
-
-const initializeExtensionManagementWorker = async () => {
-  try {
-    const rpc = await createExtensionManagementWorkerRpc();
-    set$c(rpc);
-  } catch {
-    // ignore
-  }
-};
-
-const send$1 = port => {
-  // @ts-ignore
-  return sendMessagePortToOpenerWorker(port);
-};
-const initializeOpenerWorker = async () => {
-  try {
-    const rpc = await create$d({
-      commandMap: {},
-      send: send$1
-    });
-    set$b(rpc);
-  } catch {
-    // ignore
-  }
+  await invoke$b(`Editor.rerender`);
+  state.isReloading = false;
 };
 
 const sendMessagePortToSyntaxHighlightingWorker = async port => {
@@ -10820,7 +10778,7 @@ const sendMessagePortToSyntaxHighlightingWorker = async port => {
 
 const createSyntaxHighlightingWorkerRpc = async () => {
   try {
-    const rpc = await create$e({
+    const rpc = await create$d({
       commandMap: {},
       send: sendMessagePortToSyntaxHighlightingWorker
     });
@@ -10841,17 +10799,6 @@ const initializeSyntaxHighlighting = async (syntaxHighlightingEnabled, syncIncre
   }
 };
 
-const send = port => {
-  return sendMessagePortToTextMeasurementWorker(port);
-};
-const initializeTextMeasurementWorker = async () => {
-  const rpc = await create$d({
-    commandMap: {},
-    send
-  });
-  set$9(rpc);
-};
-
 const launchCompletionWorker = async () => {
   const name = 'Completion Worker';
   const url = 'completionWorkerMain.js';
@@ -10862,7 +10809,7 @@ const launchCompletionWorker = async () => {
 
 const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
   setFactory(launchCompletionWorker);
-  await Promise.all([initializeSyntaxHighlighting(syntaxHighlightingEnabled, syncIncremental), initializeExtensionHost(), initializeExtensionManagementWorker(), initializeTextMeasurementWorker(), initializeOpenerWorker()]);
+  await initializeSyntaxHighlighting(syntaxHighlightingEnabled, syncIncremental);
 };
 
 const kLineHeight = 'editor.lineHeight';
@@ -10975,6 +10922,7 @@ const loadContent = async (state, savedState) => {
   // TODO support overwriting language id by setting it explicitly or via settings
   const charWidth = await measureCharacterWidth(fontWeight, fontSize, fontFamily, letterSpacing);
   const languages = await getLanguages(platform, assetDir);
+  setTokenizePaths(languages);
   const computedLanguageId = getLanguageId$1(uri, languages);
   const tokenizePath = getTokenizePath(languages, computedLanguageId);
   await loadTokenizer(computedLanguageId, tokenizePath);
@@ -11046,8 +10994,8 @@ const loadContent = async (state, savedState) => {
 };
 
 // TODO move cursor
-// TODO multiple cursors -> vscode removes multiple cursors
-// TODO with selection -> vscode moves whole selection
+// TODO multiple cursors -> VS Code removes multiple cursors
+// TODO with selection -> VS Code moves whole selection
 const moveLineDown = editor => {
   // const rowIndex = editor.cursor.rowIndex
   // if (rowIndex === editor.lines.length - 1) {
@@ -11111,19 +11059,34 @@ const registerListener = (listenerType, rpcId) => {
   registerListener$1(listenerType, rpcId);
 };
 
-const getCss = itemHeight => {
-  return `:root {
-  --ActivityBarItemHeight: var(--${itemHeight}px);
+const getCss = (rowHeight, scrollBarHeight, scrollBarTop) => {
+  return `.Editor {
+  --EditorRowHeight: ${rowHeight}px;
+  --ScrollBarHeight: ${scrollBarHeight}px;
+  --ScrollBarTop: ${scrollBarTop}px;
+}
+.Editor .EditorRow {
+  height: var(--EditorRowHeight);
+  line-height: var(--EditorRowHeight);
+}
+.Editor .ScrollBarThumbVertical {
+  height: var(--ScrollBarHeight);
+  translate: 0px var(--ScrollBarTop);
 }
 `;
 };
 
 const renderCss = (oldState, newState) => {
   const {
-    itemHeight,
+    deltaY,
+    finalDeltaY,
+    height,
+    rowHeight,
+    scrollBarHeight,
     uid
   } = newState;
-  const css = getCss(itemHeight);
+  const scrollBarTop = getScrollBarY(deltaY, finalDeltaY, height, scrollBarHeight);
+  const css = getCss(rowHeight, scrollBarHeight, scrollBarTop);
   return [SetCss$1, uid, css];
 };
 
@@ -11207,12 +11170,12 @@ const getChildrenWithCount = (nodes, startIndex, childCount) => {
 };
 
 const compareNodes = (oldNode, newNode) => {
-  const patches = [];
   // Check if node type changed - return null to signal incompatible nodes
   // (caller should handle this with a Replace operation)
   if (oldNode.type !== newNode.type) {
     return null;
   }
+  const patches = [];
   // Handle reference nodes - special handling for uid changes
   if (oldNode.type === Reference) {
     if (oldNode.uid !== newNode.uid) {
@@ -11248,7 +11211,7 @@ const compareNodes = (oldNode, newNode) => {
   }
   // Check for removed attributes
   for (const key of oldKeys) {
-    if (!(key in newNode)) {
+    if (!Object.hasOwn(newNode, key)) {
       patches.push({
         type: RemoveAttribute,
         key
@@ -11424,15 +11387,12 @@ const getEditorInputVirtualDom = () => {
 };
 
 const getCursorsVirtualDom = cursors => {
-  const dom = [];
-  for (const translate of cursors) {
-    dom.push({
-      childCount: 0,
-      className: EditorCursor,
-      translate,
-      type: Div
-    });
-  }
+  const dom = Array.from(cursors, translate => ({
+    childCount: 0,
+    className: EditorCursor,
+    translate,
+    type: Div
+  }));
   return dom;
 };
 
@@ -11786,9 +11746,7 @@ const renderLines = {
     const dom = getEditorRowsVirtualDom$1(textInfos, differences, true, relativeLine);
     return [/* method */'setText', dom];
   },
-  isEqual(oldState, newState) {
-    return oldState.lines === newState.lines && oldState.tokenizerId === newState.tokenizerId && oldState.minLineY === newState.minLineY && oldState.decorations === newState.decorations && oldState.embeds === newState.embeds && oldState.deltaX === newState.deltaX && oldState.width === newState.width && oldState.highlightedLine === newState.highlightedLine && oldState.debugEnabled === newState.debugEnabled;
-  }
+  isEqual: (oldState, newState) => oldState.lines === newState.lines && oldState.tokenizerId === newState.tokenizerId && oldState.minLineY === newState.minLineY && oldState.decorations === newState.decorations && oldState.embeds === newState.embeds && oldState.deltaX === newState.deltaX && oldState.width === newState.width && oldState.highlightedLine === newState.highlightedLine && oldState.debugEnabled === newState.debugEnabled
 };
 const renderSelections = {
   apply: (oldState, newState) => {
@@ -11800,9 +11758,7 @@ const renderSelections = {
     const selectionsDom = getSelectionsVirtualDom(selectionInfos);
     return [/* method */'setSelections', cursorsDom, selectionsDom];
   },
-  isEqual(oldState, newState) {
-    return oldState.cursorInfos === newState.cursorInfos && oldState.selectionInfos === newState.selectionInfos;
-  }
+  isEqual: (oldState, newState) => oldState.cursorInfos === newState.cursorInfos && oldState.selectionInfos === newState.selectionInfos
 };
 const renderScrollBarY = {
   apply(oldState, newState) {
@@ -11811,9 +11767,7 @@ const renderScrollBarY = {
     const heightPx = `${newState.scrollBarHeight}px`;
     return [/* method */'setScrollBar', translate, heightPx];
   },
-  isEqual(oldState, newState) {
-    return oldState.deltaY === newState.deltaY && oldState.scrollBarHeight === newState.scrollBarHeight;
-  }
+  isEqual: (oldState, newState) => oldState.deltaY === newState.deltaY && oldState.scrollBarHeight === newState.scrollBarHeight
 };
 const renderScrollBarX = {
   apply(oldState, newState) {
@@ -11821,25 +11775,15 @@ const renderScrollBarX = {
     const scrollBarX = newState.deltaX / newState.longestLineWidth * newState.width;
     return [/* method */'setScrollBarHorizontal', /* scrollBarX */scrollBarX, /* scrollBarWidth */scrollBarWidth, /* deltaX */newState.deltaX];
   },
-  isEqual(oldState, newState) {
-    return oldState.longestLineWidth === newState.longestLineWidth && oldState.deltaX === newState.deltaX;
-  }
+  isEqual: (oldState, newState) => oldState.longestLineWidth === newState.longestLineWidth && oldState.deltaX === newState.deltaX
 };
 const renderFocus$1 = {
-  apply(oldState, newState) {
-    return [/* method */'setFocused', newState.focused];
-  },
-  isEqual(oldState, newState) {
-    return oldState.focused === newState.focused;
-  }
+  apply: (oldState, newState) => [/* method */'setFocused', newState.focused],
+  isEqual: (oldState, newState) => oldState.focused === newState.focused
 };
 const renderFocusContext = {
-  apply(oldState, newState) {
-    return [SetFocusContext$1, newState.uid, newState.focus, 0, newState.uid, 'Editor'];
-  },
-  isEqual(oldState, newState) {
-    return oldState.focus === newState.focus;
-  }
+  apply: (oldState, newState) => [SetFocusContext$1, newState.uid, newState.focus, 0, newState.uid, 'Editor'],
+  isEqual: (oldState, newState) => oldState.focus === newState.focus
 };
 const renderAdditionalFocusContext = {
   apply(oldState, newState) {
@@ -11848,18 +11792,14 @@ const renderAdditionalFocusContext = {
     }
     return ['viewlet.unsetAdditionalFocus', newState.uid, newState.additionalFocus];
   },
-  isEqual(oldState, newState) {
-    return oldState.additionalFocus === newState.additionalFocus;
-  }
+  isEqual: (oldState, newState) => oldState.additionalFocus === newState.additionalFocus
 };
 const renderDecorations = {
   apply(oldState, newState) {
     const dom = getDiagnosticsVirtualDom(newState.visualDecorations || []);
     return ['setDecorationsDom', dom];
   },
-  isEqual(oldState, newState) {
-    return oldState.visualDecorations === newState.visualDecorations;
-  }
+  isEqual: (oldState, newState) => oldState.visualDecorations === newState.visualDecorations
 };
 const renderGutterInfo = {
   apply(oldState, newState) {
@@ -11877,9 +11817,7 @@ const renderGutterInfo = {
     const dom = getEditorGutterVirtualDom$1(gutterInfos);
     return ['renderGutter', dom];
   },
-  isEqual(oldState, newState) {
-    return oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY;
-  }
+  isEqual: (oldState, newState) => oldState.minLineY === newState.minLineY && oldState.maxLineY === newState.maxLineY
 };
 const renderWidgets = {
   apply(oldState, newState) {
@@ -11897,14 +11835,14 @@ const renderWidgets = {
       newWidgetMap[newWidget.id] = newWidget;
     }
     for (const oldWidget of oldWidgets) {
-      if (oldWidget.id in newWidgetMap) {
+      if (Object.hasOwn(newWidgetMap, oldWidget.id)) {
         changedWidgets.push(newWidgetMap[oldWidget.id]);
       } else {
         removedWidgets.push(oldWidget);
       }
     }
     for (const newWidget of newWidgets) {
-      if (newWidget.id in oldWidgetMap) ; else {
+      if (Object.hasOwn(oldWidgetMap, newWidget.id)) ; else {
         addedWidgets.push(newWidget);
       }
     }
@@ -11933,9 +11871,7 @@ const renderWidgets = {
     const filteredCommands = allCommands.filter(item => item[0] !== 'Viewlet.setFocusContext');
     return filteredCommands;
   },
-  isEqual(oldState, newState) {
-    return oldState.widgets === newState.widgets;
-  },
+  isEqual: (oldState, newState) => oldState.widgets === newState.widgets,
   multiple: true
 };
 const render$6 = [renderLines, renderSelections, renderScrollBarX, renderScrollBarY, renderFocus$1, renderDecorations, renderGutterInfo, renderWidgets, renderFocusContext, renderAdditionalFocusContext];
@@ -12019,6 +11955,7 @@ const renderEventListeners = () => {
   }, {
     name: HandleScrollBarVerticalPointerDown,
     params: ['handleScrollBarVerticalPointerDown', ClientY],
+    preventDefault: true,
     trackPointerEvents: [HandleScrollBarVerticalPointerMove, HandleScrollBarVerticalPointerUp]
   }, {
     name: HandleScrollBarVerticalPointerMove,
@@ -12048,6 +11985,14 @@ const saveState = (state, savedState) => {
   };
 };
 
+const sendMessagePortToExtensionHostWorker2 = async (port, initialCommand, rpcId) => {
+  await sendMessagePortToExtensionHostWorker(port, rpcId);
+};
+
+const sendMessagePortToExtensionManagementWorker = async (port, rpcId) => {
+  await sendMessagePortToExtensionManagementWorker$1(port, rpcId);
+};
+
 const setDebugEnabled = (state, enabled) => {
   return state;
 };
@@ -12094,7 +12039,7 @@ const updateDebugInfo = async debugId => {
   };
   set$7(key, oldState, newEditor);
   // @ts-ignore
-  await invoke$c('Editor.rerender', key);
+  await invoke$b('Editor.rerender', key);
 };
 
 // TODO wrap commands globally, not per editor
@@ -12371,7 +12316,8 @@ const commandMap = {
   'Listener.register': registerListener,
   'Listener.registerListener': registerListener$1,
   'Listener.unregister': unregisterListener,
-  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker': sendMessagePortToExtensionHostWorker2
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker': sendMessagePortToExtensionHostWorker2,
+  'SendMessagePortToExtensionManagementWorker.sendMessagePortToExtensionManagementWorker': sendMessagePortToExtensionManagementWorker
 };
 for (const [key, value] of Object.entries(commandMap)) {
   if (key.startsWith('Editor.')) {
@@ -12380,14 +12326,76 @@ for (const [key, value] of Object.entries(commandMap)) {
   }
 }
 
-const listen = async () => {
-  registerCommands(commandMap);
-  const rpc = await create$b({
+const createExtensionHostRpc = async () => {
+  const initialCommand = 'HandleMessagePort.handleMessagePort2';
+  const rpc = await create$c({
+    commandMap: {},
+    async send(port) {
+      await sendMessagePortToExtensionHostWorker2(port, initialCommand, EditorWorker);
+    }
+  });
+  return rpc;
+};
+
+const initializeExtensionHost = async () => {
+  const extensionHostRpc = await createExtensionHostRpc();
+  set$1(extensionHostRpc);
+};
+
+const createExtensionManagementWorkerRpc = async () => {
+  const rpc = await create$c({
+    commandMap: {},
+    async send(port) {
+      await sendMessagePortToExtensionManagementWorker$1(port, EditorWorker);
+    }
+  });
+  return rpc;
+};
+
+const initializeExtensionManagementWorker = async () => {
+  try {
+    const rpc = await createExtensionManagementWorkerRpc();
+    set$c(rpc);
+  } catch {
+    // ignore
+  }
+};
+
+const send$1 = port => {
+  // @ts-ignore
+  return sendMessagePortToOpenerWorker(port);
+};
+const initializeOpenerWorker = async () => {
+  const rpc = await create$c({
+    commandMap: {},
+    send: send$1
+  });
+  set$b(rpc);
+};
+
+const initializeRendererWorker = async () => {
+  const rpc = await create$a({
     commandMap: commandMap
   });
+  set$9(rpc);
+};
+
+const send = port => {
+  return sendMessagePortToTextMeasurementWorker(port);
+};
+const initializeTextMeasurementWorker = async () => {
+  const rpc = await create$c({
+    commandMap: {},
+    send
+  });
   set$a(rpc);
 };
 
+const listen = async () => {
+  registerCommands(commandMap);
+  await Promise.all([initializeRendererWorker(), initializeExtensionHost(), initializeExtensionManagementWorker(), initializeTextMeasurementWorker(), initializeOpenerWorker()]);
+};
+
 const CodeGeneratorInput = 'CodeGeneratorInput';
 
 const getCodeGeneratorVirtualDom = state => {
@@ -12415,9 +12423,7 @@ const renderContent$1 = {
     const dom = getCodeGeneratorVirtualDom();
     return [SetDom2, newState.uid, dom];
   },
-  isEqual(oldState, newState) {
-    return oldState.questions === newState.questions;
-  }
+  isEqual: (oldState, newState) => oldState.questions === newState.questions
 };
 const renderBounds$1 = {
   apply(oldState, newState) {
@@ -12429,17 +12435,11 @@ const renderBounds$1 = {
     } = newState;
     return [/* method */SetBounds, /* x */x, /* y */y, /* width */width, /* height */height];
   },
-  isEqual(oldState, newState) {
-    return oldState.x === newState.x && oldState.y === newState.y && oldState.width === newState.width && oldState.height === newState.height;
-  }
+  isEqual: (oldState, newState) => oldState.x === newState.x && oldState.y === newState.y && oldState.width === newState.width && oldState.height === newState.height
 };
 const renderFocus = {
-  apply(oldState, newState) {
-    return [Focus, '.CodeGeneratorInput', newState.focusSource];
-  },
-  isEqual(oldState, newState) {
-    return oldState.focused === newState.focused && oldState.focusSource === newState.focusSource;
-  }
+  apply: (oldState, newState) => [Focus, '.CodeGeneratorInput', newState.focusSource],
+  isEqual: (oldState, newState) => oldState.focused === newState.focused && oldState.focusSource === newState.focusSource
 };
 const render$5 = [renderContent$1, renderBounds$1, renderFocus];
 const renderFull$2 = (oldState, newState) => {
@@ -12487,6 +12487,7 @@ const renderFull$1 = (oldState, newState) => {
   return commands;
 };
 
+const commandsToForward$1 = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetUid];
 const render$3 = widget => {
   const commands = renderFull$1(widget.oldState, widget.newState);
   const wrappedCommands = [];
@@ -12494,7 +12495,7 @@ const render$3 = widget => {
     uid
   } = widget.newState;
   for (const command of commands) {
-    if (command[0] === SetDom2 || command[0] === SetCss || command[0] === AppendToBody || command[0] === SetBounds2 || command[0] === RegisterEventListeners || command[0] === SetUid) {
+    if (commandsToForward$1.includes(command[0])) {
       wrappedCommands.push(command);
     } else {
       wrappedCommands.push(['Viewlet.send', uid, ...command]);
@@ -12553,9 +12554,7 @@ const renderContent = {
     const dom = getCompletionDetailVirtualDom(newState.content);
     return [SetDom2, newState.uid, dom];
   },
-  isEqual(oldState, newState) {
-    return oldState.content === newState.content;
-  }
+  isEqual: (oldState, newState) => oldState.content === newState.content
 };
 const renderBounds = {
   apply(oldState, newState) {
@@ -12567,9 +12566,7 @@ const renderBounds = {
     } = newState;
     return [/* method */SetBounds, /* x */x, /* y */y, /* width */width, /* height */height];
   },
-  isEqual(oldState, newState) {
-    return oldState.x === newState.x && oldState.y === newState.y && oldState.width === newState.width && oldState.height === newState.height;
-  }
+  isEqual: (oldState, newState) => oldState.x === newState.x && oldState.y === newState.y && oldState.width === newState.width && oldState.height === newState.height
 };
 const render$2 = [renderContent, renderBounds];
 const renderFull = (oldState, newState) => {
@@ -12641,6 +12638,7 @@ const EditorCompletionDetailWidget = {
   render: render$1
 };
 
+const commandsToForward = [SetDom2, SetCss, AppendToBody, SetBounds2, RegisterEventListeners, SetSelectionByName, SetValueByName, SetFocusContext, SetUid, 'Viewlet.focusSelector'];
 const render = widget => {
   const commands = renderFull$4(widget.oldState, widget.newState);
   const wrappedCommands = [];
@@ -12648,7 +12646,7 @@ const render = widget => {
     uid
   } = widget.newState;
   for (const command of commands) {
-    if (command[0] === SetDom2 || command[0] === SetCss || command[0] === AppendToBody || command[0] === SetBounds2 || command[0] === RegisterEventListeners || command[0] === SetSelectionByName || command[0] === SetValueByName || command[0] === SetFocusContext || command[0] === SetUid || command[0] === 'Viewlet.focusSelector') {
+    if (commandsToForward.includes(command[0])) {
       wrappedCommands.push(command);
     } else {
       wrappedCommands.push(['Viewlet.send', uid, ...command]);