@lvce-editor/editor-worker 5.6.0 → 5.8.0

package/dist/editorWorkerMain.js

@@ -1,11 +1,6 @@
 const commands = Object.create(null);
-const registerCommand = (key, fn) => {
-  commands[key] = fn;
-};
 const register = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
+  Object.assign(commands, commandMap);
 };
 const getCommand = key => {
   return commands[key];
@@ -23,13 +18,13 @@ const codeGeneratorAccept = state => {
   return state;
 };
 
-let AssertionError$1 = class AssertionError extends Error {
+class AssertionError extends Error {
   constructor(message) {
     super(message);
     this.name = 'AssertionError';
   }
-};
-const getType$1 = value => {
+}
+const getType = value => {
   switch (typeof value) {
     case 'number':
       return 'number';
@@ -52,40 +47,40 @@ const getType$1 = value => {
   }
 };
 const object = value => {
-  const type = getType$1(value);
+  const type = getType(value);
   if (type !== 'object') {
-    throw new AssertionError$1('expected value to be of type object');
+    throw new AssertionError('expected value to be of type object');
   }
 };
-const number$1 = value => {
-  const type = getType$1(value);
+const number = value => {
+  const type = getType(value);
   if (type !== 'number') {
-    throw new AssertionError$1('expected value to be of type number');
+    throw new AssertionError('expected value to be of type number');
   }
 };
 const array = value => {
-  const type = getType$1(value);
+  const type = getType(value);
   if (type !== 'array') {
-    throw new AssertionError$1('expected value to be of type array');
+    throw new AssertionError('expected value to be of type array');
   }
 };
 const string = value => {
-  const type = getType$1(value);
+  const type = getType(value);
   if (type !== 'string') {
-    throw new AssertionError$1('expected value to be of type string');
+    throw new AssertionError('expected value to be of type string');
   }
 };
 const boolean = value => {
-  const type = getType$1(value);
+  const type = getType(value);
   if (type !== 'boolean') {
-    throw new AssertionError$1('expected value to be of type boolean');
+    throw new AssertionError('expected value to be of type boolean');
   }
 };
 
 const clamp = (num, min, max) => {
-  number$1(num);
-  number$1(min);
-  number$1(max);
+  number(num);
+  number(min);
+  number(max);
   return Math.min(Math.max(num, min), max);
 };
 
@@ -304,10 +299,10 @@ const applyEdits = (textDocument, changes) => {
     const endColumnIndex = change.end.columnIndex;
     const inserted = change.inserted;
     const deleted = change.deleted;
-    number$1(startRowIndex);
-    number$1(endRowIndex);
-    number$1(startColumnIndex);
-    number$1(endColumnIndex);
+    number(startRowIndex);
+    number(endRowIndex);
+    number(startColumnIndex);
+    number(endColumnIndex);
     array(inserted);
     array(deleted);
     if (startRowIndex === endRowIndex) {
@@ -377,8 +372,8 @@ const getSelectionText = (textDocument, range) => {
 };
 const offsetAtSync = async (textDocument, positionRowIndex, positionColumnIndex) => {
   object(textDocument);
-  number$1(positionRowIndex);
-  number$1(positionColumnIndex);
+  number(positionRowIndex);
+  number(positionColumnIndex);
   let offset = 0;
   let rowIndex = 0;
   const lines = textDocument.lines;
@@ -392,8 +387,8 @@ const offsetAtSync = async (textDocument, positionRowIndex, positionColumnIndex)
 };
 const offsetAt = (textDocument, positionRowIndex, positionColumnIndex) => {
   object(textDocument);
-  number$1(positionRowIndex);
-  number$1(positionColumnIndex);
+  number(positionRowIndex);
+  number(positionColumnIndex);
   let offset = 0;
   let rowIndex = 0;
   const lines = textDocument.lines;
@@ -432,7 +427,7 @@ const positionAt = (textDocument, offset) => {
 // TODO this should be in a separate scrolling module
 const setDeltaY$3 = (state, value) => {
   object(state);
-  number$1(value);
+  number(value);
   const {
     finalDeltaY,
     deltaY,
@@ -525,11 +520,11 @@ const getContext = () => {
 
 const measureTextWidthSlow = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
   string(text);
-  number$1(fontWeight);
-  number$1(fontSize);
+  number(fontWeight);
+  number(fontSize);
   string(fontFamily);
   boolean(isMonoSpaceFont);
-  number$1(charWidth);
+  number(charWidth);
   if (typeof letterSpacing !== 'number') {
     throw new TypeError('letterSpacing must be of type number');
   }
@@ -565,12 +560,12 @@ const getX = (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, l
     return 0;
   }
   string(line);
-  number$1(tabSize);
-  number$1(halfCursorWidth);
-  number$1(width);
+  number(tabSize);
+  number(halfCursorWidth);
+  number(width);
   boolean(isMonospaceFont);
-  number$1(averageCharWidth);
-  number$1(difference);
+  number(averageCharWidth);
+  number(difference);
   if (column === 0) {
     return 0;
   }
@@ -1037,11 +1032,11 @@ const setText = (editor, text) => {
 
 const editors = Object.create(null);
 const get$6 = id => {
-  number$1(id);
+  number(id);
   return editors[id];
 };
 const set$6 = (id, oldEditor, newEditor) => {
-  number$1(id);
+  number(id);
   object(oldEditor);
   object(newEditor);
   editors[id] = {
@@ -1058,57 +1053,21 @@ const TabCompletionExecuteTabCompletionProvider = 'ExtensionHost.executeTabCompl
 const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
 
 const Two = '2.0';
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const state$1$1 = {
+const state$9 = {
   callbacks: Object.create(null)
 };
 const set$5 = (id, fn) => {
-  state$1$1.callbacks[id] = fn;
+  state$9.callbacks[id] = fn;
 };
 const get$5 = id => {
-  return state$1$1.callbacks[id];
+  return state$9.callbacks[id];
 };
 const remove$8 = id => {
-  delete state$1$1.callbacks[id];
-};
-const state$9 = {
-  id: 0
+  delete state$9.callbacks[id];
 };
+let id = 0;
 const create$3$1 = () => {
-  return ++state$9.id;
+  return ++id;
 };
 const warn$1 = (...args) => {
   console.warn(...args);
@@ -1125,15 +1084,14 @@ const registerPromise = () => {
     promise
   };
 };
-const resolve = (id, args) => {
-  number(id);
+const resolve = (id, response) => {
   const fn = get$5(id);
   if (!fn) {
-    console.log(args);
+    console.log(response);
     warn$1(`callback ${id} may already be disposed`);
     return;
   }
-  fn(args);
+  fn(response);
   remove$8(id);
 };
 const create$2$1 = (method, params) => {
@@ -1355,32 +1313,42 @@ const defaultRequiresSocket = () => {
   return false;
 };
 const defaultResolve = resolve;
-const handleJsonRpcMessage = async (...args) => {
-  let message;
-  let ipc;
-  let execute;
-  let preparePrettyError;
-  let logError;
-  let resolve;
-  let requiresSocket;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
   if (args.length === 1) {
-    const arg = args[0];
-    message = arg.message;
-    ipc = arg.ipc;
-    execute = arg.execute;
-    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
-    logError = arg.logError || defaultLogError;
-    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
-    resolve = arg.resolve || defaultResolve;
-  } else {
-    ipc = args[0];
-    message = args[1];
-    execute = args[2];
-    resolve = args[3];
-    preparePrettyError = args[4];
-    logError = args[5];
-    requiresSocket = args[6];
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
   }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
   if ('id' in message) {
     if ('method' in message) {
       const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
@@ -1401,25 +1369,24 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invoke$5 = async (ipc, method, ...params) => {
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
   } = create$2$1(method, params);
-  ipc.send(message);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
   const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+  return unwrapJsonRpcResult(responseMessage);
 };
-const invokeAndTransfer$2 = async (ipc, method, ...params) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  ipc.sendAndTransfer(message);
-  const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+const invoke$5 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
+};
+const invokeAndTransfer$2 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
 };
 
 const requiresSocket = () => {
@@ -1492,7 +1459,7 @@ const invokeAndTransfer$1 = async (method, ...params) => {
   const ipc = get$4();
   return invokeAndTransfer$2(ipc, method, ...params);
 };
-const listen$8 = ipc => {
+const listen$7 = ipc => {
   set$4(ipc);
 };
 
@@ -1547,7 +1514,7 @@ const create$d = async () => {
   }
   return port2;
 };
-const wrap$3 = port => {
+const wrap$2 = port => {
   return {
     port,
     /**
@@ -1581,7 +1548,7 @@ const wrap$3 = port => {
 const IpcParentWithExtensionHostWorker = {
   __proto__: null,
   create: create$d,
-  wrap: wrap$3
+  wrap: wrap$2
 };
 
 const sendMessagePortToSyntaxHighlightingWorker = async port => {
@@ -1737,7 +1704,7 @@ const createRpc = method => {
 };
 
 const {
-  listen: listen$7,
+  listen: listen$6,
   invoke: invoke$2
 } = createRpc(ExtensionHostWorker);
 
@@ -1787,19 +1754,13 @@ const execute = async ({
   return result;
 };
 
-const combineResults$3 = results => {
-  return results[0];
-};
 const executeDiagnosticProvider = editor => {
   return execute({
     editor,
     event: OnDiagnostic,
     method: 'ExtensionHost.executeDiagnosticProvider',
     args: [],
-    noProviderFoundMessage: 'no diagnostic provider found',
-    noProviderResult: [],
-    combineResults: combineResults$3
-  });
+    noProviderFoundMessage: 'no diagnostic provider found'});
 };
 
 const getDiagnosticType = diagnostic => {
@@ -1860,7 +1821,7 @@ const updateDiagnostics = async newState => {
     const diagnostics = await executeDiagnosticProvider(newState);
     const latest = get$6(newState.id);
     if (!latest) {
-      return;
+      return newState;
     }
     const decorations = getVisibleDiagnostics(latest.newState, diagnostics);
     const newEditor = {
@@ -1870,6 +1831,7 @@ const updateDiagnostics = async newState => {
     };
     set$6(newState.id, latest.oldState, newEditor);
     await invoke$3('Editor.rerender', newState.id);
+    return newEditor;
   } catch (error) {
     // @ts-ignore
     if (error && error.message.includes('No diagnostic provider found')) {
@@ -1932,7 +1894,7 @@ const createEditor = async ({
   uri,
   diagnosticsEnabled
 }) => {
-  number$1(id);
+  number(id);
   string(content);
   const charWidth = measureCharacterWidth(fontWeight, fontSize, fontFamily, letterSpacing);
   const editor = {
@@ -2207,14 +2169,14 @@ const normalizeGuess = (line, guess, tabSize) => {
 // @ts-ignore
 const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX) => {
   string(line);
-  number$1(fontWeight);
-  number$1(fontSize);
+  number(fontWeight);
+  number(fontSize);
   string(fontFamily);
-  number$1(letterSpacing);
+  number(letterSpacing);
   boolean(isMonospaceFont);
-  number$1(charWidth);
-  number$1(tabSize);
-  number$1(eventX);
+  number(charWidth);
+  number(tabSize);
+  number(eventX);
   // Assert.greaterZero(charWidth)
   const guess = guessOffset(eventX, charWidth);
   const normalize = shouldNormalizeText(line);
@@ -2234,8 +2196,8 @@ const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSp
 
 const at = (editor, eventX, eventY) => {
   object(editor);
-  number$1(eventX);
-  number$1(eventY);
+  number(eventX);
+  number(eventY);
   const {
     y,
     deltaY,
@@ -2246,7 +2208,6 @@ const at = (editor, eventX, eventY) => {
     letterSpacing,
     lines,
     tabSize,
-    differences,
     isMonospaceFont,
     charWidth
   } = editor;
@@ -2308,8 +2269,8 @@ const state$7 = {
 // @ts-ignore
 const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError) => {
   object(editor);
-  number$1(rowIndex);
-  number$1(columnIndex);
+  number(rowIndex);
+  number(columnIndex);
   string(message);
   const x$1 = x(editor, rowIndex, columnIndex);
   const y$1 = y(editor, rowIndex);
@@ -2655,10 +2616,10 @@ const compositionEnd = (editor, data) => {
 
 const normalizeLine$1 = line => {
   if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
+    return line.slice('Error: '.length);
   }
   if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
+    return line.slice('VError: '.length);
   }
   return line;
 };
@@ -2781,7 +2742,7 @@ const copyLineDown = editor => {
     selections
   } = editor;
   const rowIndex = selections[0];
-  number$1(rowIndex);
+  number(rowIndex);
   const position = {
     rowIndex,
     columnIndex: 0
@@ -3087,8 +3048,8 @@ const cursorHome = editor => {
 
 const cursorSet = (editor, rowIndex, columnIndex) => {
   object(editor);
-  number$1(rowIndex);
-  number$1(columnIndex);
+  number(rowIndex);
+  number(columnIndex);
   const selectionEdits = fromRange(rowIndex, columnIndex, rowIndex, columnIndex);
   return scheduleSelections(editor, selectionEdits);
 };
@@ -3485,16 +3446,12 @@ const i18nString = (key, placeholders = emptyObject) => {
 };
 
 const UiStrings$1 = {
-  GoToDefinition: 'Go to Definition',
   NoDefinitionFound: 'No definition found',
   NoDefinitionFoundFor: "No definition found for '{PH1}'",
   NoTypeDefinitionFound: 'No type definition found',
   NoTypeDefinitionFoundFor: "No type definition found for '{PH1}'",
   NoResults: 'No Results',
-  Replace: 'Replace',
   SourceAction: 'Source Action',
-  OrganizeImports: 'Organize Imports',
-  SortImports: 'Sort Imports',
   NoCodeActionsAvailable: 'No code actions available',
   EscapeToClose: 'Escape to close',
   EnterCode: 'Enter Code'
@@ -3814,9 +3771,9 @@ const getFn = modifier => {
 };
 const handleSingleClick = async (editor, modifier, x, y) => {
   object(editor);
-  number$1(modifier);
-  number$1(x);
-  number$1(y);
+  number(modifier);
+  number(x);
+  number(y);
   const position = at(editor, x, y);
   const fn = getFn(modifier);
   const newEditor = await fn(editor, position);
@@ -3855,8 +3812,8 @@ const selectLine = editor => {
 // @ts-ignore
 const handleTripleClick = (editor, modifier, x, y) => {
   object(editor);
-  number$1(x);
-  number$1(y);
+  number(x);
+  number(y);
   return {
     newState: selectLine(editor),
     commands: []
@@ -3947,8 +3904,8 @@ const getTokenIndex = (tokens, offset) => {
 // @ts-ignore
 const handleMouseMoveWithAltKey = async (editor, x, y) => {
   object(editor);
-  number$1(x);
-  number$1(y);
+  number(x);
+  number(y);
   const position = at(editor, x, y);
   const documentOffset = offsetAt(editor, position.rowIndex, position.columnIndex);
   try {
@@ -4136,9 +4093,6 @@ const handleScrollBarHorizontalPointerDown = (state, eventX) => {
     x,
     deltaX,
     width,
-    finalDeltaY,
-    height,
-    scrollBarHeight,
     longestLineWidth
   } = state;
   const relativeX = eventX - x;
@@ -4286,14 +4240,12 @@ const setDeltaYFixedValue = (editor, deltaY) => {
 
 // @ts-ignore
 const setDelta = (editor, deltaMode, eventDeltaX, eventDeltaY) => {
-  number$1(deltaMode);
-  number$1(eventDeltaX);
-  number$1(eventDeltaY);
+  number(deltaMode);
+  number(eventDeltaX);
+  number(eventDeltaY);
   // @ts-ignore
   const {
-    deltaX,
-    deltaY
-  } = editor;
+    deltaX} = editor;
   if (eventDeltaX === 0) {
     return setDeltaY$1(editor, eventDeltaY);
   }
@@ -4647,8 +4599,8 @@ const continueScrollingAndMovingSelection = async () => {
 // @ts-ignore
 const moveSelectionPx = (editor, x, y) => {
   object(editor);
-  number$1(x);
-  number$1(y);
+  number(x);
+  number(y);
   const position = at(editor, x, y);
   if (!hasListener() && (position.rowIndex < editor.minLineY || position.rowIndex > editor.maxLineY)) {
     requestAnimationFrame(continueScrollingAndMovingSelection);
@@ -4747,9 +4699,6 @@ const create$5 = () => {
   return completionWidget;
 };
 
-const combineResults$2 = results => {
-  return results[0] ?? [];
-};
 const executeCompletionProvider = async (editor, offset) => {
   return execute({
     editor,
@@ -4757,12 +4706,7 @@ const executeCompletionProvider = async (editor, offset) => {
     method: CompletionExecute,
     args: [offset],
     noProviderFoundMessage: 'no completion provider found',
-    noProviderFoundResult: [],
-    combineResults: combineResults$2
-  });
-};
-const combineResultsResolve = items => {
-  return items[0] ?? undefined;
+    noProviderFoundResult: []});
 };
 const executeResolveCompletionItem = async (editor, offset, name, completionItem) => {
   return execute({
@@ -4771,9 +4715,7 @@ const executeResolveCompletionItem = async (editor, offset, name, completionItem
     method: CompletionResolveExecute,
     args: [offset, name, completionItem],
     noProviderFoundMessage: 'no completion provider found',
-    noProviderFoundResult: [],
-    combineResults: combineResultsResolve
-  });
+    noProviderFoundResult: []});
 };
 
 const getOffsetAtCursor = editor => {
@@ -5022,9 +4964,9 @@ const getFinalDeltaY = (height, itemHeight, itemsLength) => {
 };
 
 const getListHeight = (itemsLength, itemHeight, maxHeight) => {
-  number$1(itemsLength);
-  number$1(itemHeight);
-  number$1(maxHeight);
+  number(itemsLength);
+  number(itemHeight);
+  number(maxHeight);
   if (itemsLength === 0) {
     return itemHeight;
   }
@@ -6448,14 +6390,7 @@ const TokenizePlainText = {
 
 const state$1 = {
   tokenizers: Object.create(null),
-  tokenizePaths: Object.create(null),
-  listeners: [],
-  pending: Object.create(null),
-  /**
-   * @type {number[]}
-   */
-  connectedEditors: []
-};
+  pending: Object.create(null)};
 const has = languageId => {
   return languageId in state$1.tokenizers;
 };
@@ -6478,7 +6413,7 @@ const getEnabled$1 = () => {
 };
 
 const {
-  listen: listen$6,
+  listen: listen$5,
   invoke: invoke$1
 } = createRpc(SyntaxHighlightingWorker);
 
@@ -6641,7 +6576,7 @@ const create$2 = () => {
 
 const executeHoverProvider = async (editor, offset) => {
   object(editor);
-  number$1(offset);
+  number(offset);
   return execute({
     event: OnHover,
     editor,
@@ -6653,14 +6588,14 @@ const executeHoverProvider = async (editor, offset) => {
 
 const getHover = async (editor, offset) => {
   object(editor);
-  number$1(offset);
+  number(offset);
   // TODO invoke extension host worker directly
   const hover = await executeHoverProvider(editor, offset);
   return hover;
 };
 
 let _ipc;
-const listen$5 = async () => {
+const listen$4 = async () => {
   const ipc = await create$a({
     method: RendererProcess
   });
@@ -6809,7 +6744,7 @@ const getHoverPositionXy = (editor, rowIndex, wordStart, documentationHeight) =>
   };
 };
 const getEditorHoverInfo = async (editorUid, position) => {
-  number$1(editorUid);
+  number(editorUid);
   const instance = get$6(editorUid);
   const editor = instance.newState;
   const {
@@ -7025,9 +6960,6 @@ const sortLinesAscending = editor => {
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
-const combineResults$1 = results => {
-  return results[0];
-};
 const executeTabCompletionProvider = async (editor, offset) => {
   return execute({
     editor,
@@ -7035,7 +6967,6 @@ const executeTabCompletionProvider = async (editor, offset) => {
     method: TabCompletionExecuteTabCompletionProvider,
     args: [offset],
     noProviderFoundMessage: 'No tab completion provider found',
-    combineResults: combineResults$1,
     noProviderFoundResult: undefined
   });
 };
@@ -7801,7 +7732,7 @@ const getNumberOfVisibleItems = (listHeight, itemHeight) => {
 
 const setDeltaY = (state, value) => {
   object(state);
-  number$1(value);
+  number(value);
   const {
     itemHeight,
     finalDeltaY,
@@ -7826,8 +7757,8 @@ const setDeltaY = (state, value) => {
 };
 
 const handleWheel = (state, deltaMode, deltaY) => {
-  number$1(deltaMode);
-  number$1(deltaY);
+  number(deltaMode);
+  number(deltaY);
   return setDeltaY(state, state.deltaY + deltaY);
 };
 
@@ -7897,9 +7828,7 @@ const getEdits = async (editor, completionItem) => {
   const child = getCompletionState(editor);
   // @ts-ignore
   const {
-    leadingWord,
-    uid
-  } = child;
+    leadingWord} = child;
   const word = completionItem.label;
   const resolvedItem = await resolveCompletion(editor, word, completionItem);
   const inserted = resolvedItem ? resolvedItem.snippet : word;
@@ -8005,9 +7934,7 @@ const handleSashPointerDown = (state, eventX, eventY) => {
 const handleSashPointerMove = (state, eventX, eventY) => {
   // @ts-ignore
   const {
-    x,
-    y
-  } = state;
+    x} = state;
   const minWidth = 100;
   const newWidth = Math.max(eventX - x, minWidth);
   return {
@@ -8227,9 +8154,6 @@ const renderHover = (oldState, newState) => {
   return commands;
 };
 
-const combineResults = results => {
-  return results[0] ?? [];
-};
 const executeRenameProvider = async (editor, offset, newName) => {
   return execute({
     editor,
@@ -8237,9 +8161,7 @@ const executeRenameProvider = async (editor, offset, newName) => {
     method: RenameExecuteRename,
     args: [offset, newName],
     noProviderFoundMessage: 'no rename provider found',
-    noProviderFoundResult: [],
-    combineResults
-  });
+    noProviderFoundResult: []});
 };
 
 const getRenameState = editor => {
@@ -8479,15 +8401,15 @@ const getEnabled = () => {
 };
 
 const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
-  await listen$5();
+  await listen$4();
   if (syntaxHighlightingEnabled) {
     setEnabled$1(true);
-    await listen$6();
+    await listen$5();
   }
   if (syncIncremental) {
     setEnabled(true);
   }
-  await listen$7();
+  await listen$6();
 };
 
 // TODO move cursor
@@ -9003,10 +8925,6 @@ const getVisible = async (editor, syncIncremental) => {
     lines,
     width,
     deltaX,
-    fontWeight,
-    fontSize,
-    fontFamily,
-    letterSpacing,
     charWidth
   } = editor;
   const maxLineY = Math.min(minLineY + numberOfVisibleLines, lines.length);
@@ -9596,6 +9514,7 @@ const commandMap = {
   'Editor.typeWithAutoClosing': typeWithAutoClosing,
   'Editor.undo': undo,
   'Editor.unIndent': editorUnindent,
+  'Editor.updateDiagnostics': updateDiagnostics,
   'EditorCompletion.advance': advance,
   'EditorCompletion.closeDetails': closeDetails,
   'EditorCompletion.focusFirst': focusFirst,
@@ -9669,6 +9588,27 @@ const Auto = () => {
 const getData$1 = event => {
   return event.data;
 };
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const readyMessage = 'ready';
 const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
@@ -9719,35 +9659,56 @@ const getTransferrables = value => {
   walkValue(value, transferrables, isTransferrable);
   return transferrables;
 };
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
-  };
-  that.onClose(handleClose);
+const listen$3 = ({
+  port
+}) => {
+  return port;
 };
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents(this);
+const signal$3 = port => {
+  port.postMessage(readyMessage);
+};
+class IpcChildWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
   }
 }
-const readyMessage = 'ready';
-const listen$4 = () => {
+const wrap$6 = port => {
+  return new IpcChildWithMessagePort(port);
+};
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$3,
+  signal: signal$3,
+  wrap: wrap$6
+};
+const listen$2 = () => {
   // @ts-ignore
   if (typeof WorkerGlobalScope === 'undefined') {
     throw new TypeError('module is not in web worker scope');
   }
   return globalThis;
 };
-const signal$3 = global => {
+const signal$2 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithModuleWorker extends Ipc {
@@ -9773,14 +9734,14 @@ class IpcChildWithModuleWorker extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 }
-const wrap$6 = global => {
+const wrap$5 = global => {
   return new IpcChildWithModuleWorker(global);
 };
 const IpcChildWithModuleWorker$1 = {
   __proto__: null,
-  listen: listen$4,
-  signal: signal$3,
-  wrap: wrap$6
+  listen: listen$2,
+  signal: signal$2,
+  wrap: wrap$5
 };
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
@@ -9897,10 +9858,10 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
 };
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
+    return line.slice('Error: '.length);
   }
   if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
+    return line.slice('VError: '.length);
   }
   return line;
 };
@@ -9998,10 +9959,10 @@ const waitForFirstMessage = async port => {
   // @ts-ignore
   return event.data;
 };
-const listen$3 = async () => {
-  const parentIpcRaw = listen$4();
-  signal$3(parentIpcRaw);
-  const parentIpc = wrap$6(parentIpcRaw);
+const listen$1$1 = async () => {
+  const parentIpcRaw = listen$2();
+  signal$2(parentIpcRaw);
+  const parentIpc = wrap$5(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError('unexpected first message');
@@ -10046,55 +10007,13 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$5 = port => {
+const wrap$4 = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
-  listen: listen$3,
-  wrap: wrap$5
-};
-const listen$2 = ({
-  port
-}) => {
-  return port;
-};
-const signal = port => {
-  port.postMessage(readyMessage);
-};
-class IpcChildWithMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$2 = port => {
-  return new IpcChildWithMessagePort(port);
-};
-const IpcChildWithMessagePort$1 = {
-  __proto__: null,
-  listen: listen$2,
-  signal,
-  wrap: wrap$2
+  listen: listen$1$1,
+  wrap: wrap$4
 };
 
 const getModule = method => {
@@ -10131,7 +10050,7 @@ const listen = async () => {
     method: Auto()
   });
   handleIpc(ipc);
-  listen$8(ipc);
+  listen$7(ipc);
 };
 
 const addWidget = (widget, id, render) => {
@@ -10837,7 +10756,6 @@ const EditorCompletionWidget = {
  * @enum {string}
  */
 const UiStrings = {
-  MatchesFoundFor: '{PH1} of {PH2} found for {PH3}',
   MatchOf: '{PH1} of {PH2}',
   NoResults: 'No Results',
   Close: 'Close',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/editor-worker",
-  "version": "5.6.0",
+  "version": "5.8.0",
   "description": "",
   "main": "dist/editorWorkerMain.js",
   "type": "module",