@lvce-editor/editor-worker 5.13.0 → 5.16.0

package/dist/editorWorkerMain.js

@@ -145,7 +145,7 @@ const InsertLineBreak = 'insertLineBreak';
 const LineComment = 'lineComment';
 const Rename$1 = 'rename';
 const ReplaceAll$2 = 'replaceAll';
-const ToggleBlockComment = 'toggleBlockComment';
+const ToggleBlockComment$1 = 'toggleBlockComment';
 
 const map$1 = Object.create(null);
 const set$7 = (id, widget) => {
@@ -236,6 +236,34 @@ const getNewDeltaPercent = (height, scrollBarHeight, relativeY) => {
   };
 };
 
+// TODO this should be in a separate scrolling module
+const setDeltaY$3 = (state, value) => {
+  object(state);
+  number(value);
+  const {
+    finalDeltaY,
+    deltaY,
+    numberOfVisibleLines,
+    height,
+    scrollBarHeight,
+    itemHeight
+  } = state;
+  const newDeltaY = clamp(value, 0, finalDeltaY);
+  if (deltaY === newDeltaY) {
+    return state;
+  }
+  const newMinLineY = Math.floor(newDeltaY / itemHeight);
+  const newMaxLineY = newMinLineY + numberOfVisibleLines;
+  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height, scrollBarHeight);
+  return {
+    ...state,
+    minLineY: newMinLineY,
+    maxLineY: newMaxLineY,
+    deltaY: newDeltaY,
+    scrollBarY
+  };
+};
+
 const splitLines$2 = lines => {
   if (!lines) {
     return [];
@@ -424,34 +452,6 @@ const positionAt = (textDocument, offset) => {
   };
 };
 
-// TODO this should be in a separate scrolling module
-const setDeltaY$3 = (state, value) => {
-  object(state);
-  number(value);
-  const {
-    finalDeltaY,
-    deltaY,
-    numberOfVisibleLines,
-    height,
-    scrollBarHeight,
-    itemHeight
-  } = state;
-  const newDeltaY = clamp(value, 0, finalDeltaY);
-  if (deltaY === newDeltaY) {
-    return state;
-  }
-  const newMinLineY = Math.floor(newDeltaY / itemHeight);
-  const newMaxLineY = newMinLineY + numberOfVisibleLines;
-  const scrollBarY = getScrollBarY(newDeltaY, finalDeltaY, height, scrollBarHeight);
-  return {
-    ...state,
-    minLineY: newMinLineY,
-    maxLineY: newMaxLineY,
-    deltaY: newDeltaY,
-    scrollBarY
-  };
-};
-
 const getSelectionPairs = (selections, i) => {
   const first = selections[i];
   const second = selections[i + 1];
@@ -464,7 +464,7 @@ const getSelectionPairs = (selections, i) => {
 };
 
 const EmptyString$1 = '';
-const NewLine$4 = '\n';
+const NewLine$3 = '\n';
 const Space$2 = ' ';
 const Tab$1 = '\t';
 const DoubleQuote$1 = '"';
@@ -1067,9 +1067,6 @@ let id = 0;
 const create$3$1 = () => {
   return ++id;
 };
-const warn$1 = (...args) => {
-  console.warn(...args);
-};
 const registerPromise = () => {
   const id = create$3$1();
   const {
@@ -1082,16 +1079,6 @@ const registerPromise = () => {
     promise
   };
 };
-const resolve = (id, response) => {
-  const fn = get$5(id);
-  if (!fn) {
-    console.log(response);
-    warn$1(`callback ${id} may already be disposed`);
-    return;
-  }
-  fn(response);
-  remove$8(id);
-};
 const create$2$1 = (method, params) => {
   const {
     id,
@@ -1114,7 +1101,7 @@ class JsonRpcError extends Error {
     this.name = 'JsonRpcError';
   }
 }
-const NewLine$3 = '\n';
+const NewLine$2 = '\n';
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
@@ -1159,23 +1146,23 @@ const constructError = (message, type, name) => {
   }
   return new ErrorConstructor(message);
 };
-const getNewLineIndex$2 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$3, startIndex);
+const getNewLineIndex$1 = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$2, startIndex);
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine$3 + parentStack;
+    parentStack = error.message + NewLine$2 + parentStack;
   }
   return parentStack;
 };
 const joinLines$1 = lines => {
-  return lines.join(NewLine$3);
+  return lines.join(NewLine$2);
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
 const splitLines$1 = lines => {
-  return lines.split(NewLine$3);
+  return lines.split(NewLine$2);
 };
 const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
@@ -1185,14 +1172,14 @@ const restoreJsonRpcError = error => {
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine$3 + currentStack;
+    restoredError.stack = parentStack + NewLine$2 + currentStack;
     return restoredError;
   }
   if (error && error.message) {
     const restoredError = constructError(error.message, error.type, error.name);
     if (error.data) {
       if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine$3 + error.data.stack + NewLine$3 + currentStack;
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$2 + error.data.stack + NewLine$2 + currentStack;
       } else if (error.data.stack) {
         restoredError.stack = error.data.stack;
       }
@@ -1212,7 +1199,7 @@ const restoreJsonRpcError = error => {
       if (error.stack) {
         const lowerStack = restoredError.stack || '';
         // @ts-ignore
-        const indexNewLine = getNewLineIndex$2(lowerStack);
+        const indexNewLine = getNewLineIndex$1(lowerStack);
         const parentStack = getParentStack(error);
         // @ts-ignore
         restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
@@ -1239,6 +1226,19 @@ const unwrapJsonRpcResult = responseMessage => {
   }
   throw new JsonRpcError('unexpected response message');
 };
+const warn$1 = (...args) => {
+  console.warn(...args);
+};
+const resolve = (id, response) => {
+  const fn = get$5(id);
+  if (!fn) {
+    console.log(response);
+    warn$1(`callback ${id} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove$8(id);
+};
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
   if (prettyError && prettyError.type) {
@@ -1457,7 +1457,7 @@ const invokeAndTransfer$1 = async (method, ...params) => {
   const ipc = get$4();
   return invokeAndTransfer$2(ipc, method, ...params);
 };
-const listen$7 = ipc => {
+const listen$5 = ipc => {
   set$4(ipc);
 };
 
@@ -1549,8 +1549,8 @@ const IpcParentWithExtensionHostWorker = {
   wrap: wrap$2
 };
 
-const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer('SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort');
+const sendMessagePortToRendererProcess = async port => {
+  await invokeAndTransfer('SendMessagePortToRendererProcess.sendMessagePortToRendererProcess', port, 'HandleMessagePort.handleMessagePort');
 };
 
 const create$c = async () => {
@@ -1558,7 +1558,7 @@ const create$c = async () => {
     port1,
     port2
   } = getPortTuple();
-  await sendMessagePortToSyntaxHighlightingWorker(port1);
+  await sendMessagePortToRendererProcess(port1);
   const event = await waitForFirstMessage$1(port2);
   if (event.data !== 'ready') {
     throw new IpcError$1('unexpected first message');
@@ -1596,14 +1596,14 @@ const wrap$1 = port => {
   };
 };
 
-const IpcParentWithSyntaxHighlightingWorker = {
+const IpcParentWithRendererProcess = {
   __proto__: null,
   create: create$c,
   wrap: wrap$1
 };
 
-const sendMessagePortToRendererProcess = async port => {
-  await invokeAndTransfer('SendMessagePortToRendererProcess.sendMessagePortToRendererProcess', port, 'HandleMessagePort.handleMessagePort');
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer('SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort');
 };
 
 const create$b = async () => {
@@ -1611,7 +1611,7 @@ const create$b = async () => {
     port1,
     port2
   } = getPortTuple();
-  await sendMessagePortToRendererProcess(port1);
+  await sendMessagePortToSyntaxHighlightingWorker(port1);
   const event = await waitForFirstMessage$1(port2);
   if (event.data !== 'ready') {
     throw new IpcError$1('unexpected first message');
@@ -1649,7 +1649,7 @@ const wrap = port => {
   };
 };
 
-const IpcParentWithRendererProcess = {
+const IpcParentWithSyntaxHighlightingWorker = {
   __proto__: null,
   create: create$b,
   wrap
@@ -1672,7 +1672,7 @@ const create$a = async ({
   method,
   ...options
 }) => {
-  const module = await getModule$1(method);
+  const module = getModule$1(method);
   // @ts-ignore
   const rawIpc = await module.create(options);
   // @ts-ignore
@@ -1702,7 +1702,7 @@ const createRpc = method => {
 };
 
 const {
-  listen: listen$6,
+  listen: listen$4,
   invoke: invoke$2
 } = createRpc(ExtensionHostWorker);
 
@@ -1752,19 +1752,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 => {
@@ -2212,7 +2206,6 @@ const at = (editor, eventX, eventY) => {
     letterSpacing,
     lines,
     tabSize,
-    differences,
     isMonospaceFont,
     charWidth
   } = editor;
@@ -2364,15 +2357,6 @@ const cancelSelection = editor => {
   return scheduleSelections(editor, newSelections);
 };
 
-const CodeGenerator = 1;
-const ColorPicker$1 = 2;
-const Completion = 3;
-const CompletionDetail = 4;
-const Find = 5;
-const Hover = 6;
-const Rename = 7;
-const SourceAction = 8;
-
 const getIndex = (widgets, id) => {
   for (const [i, widget] of widgets.entries()) {
     if (widget.id === id) {
@@ -2387,6 +2371,15 @@ const removeEditorWidget = (widgets, id) => {
   return newWidgets;
 };
 
+const CodeGenerator = 1;
+const ColorPicker$1 = 2;
+const Completion = 3;
+const CompletionDetail = 4;
+const Find = 5;
+const Hover = 6;
+const Rename = 7;
+const SourceAction$1 = 8;
+
 const isMatchingWidget$2 = widget => {
   return widget.id === CodeGenerator;
 };
@@ -2464,7 +2457,7 @@ const closeRename = editor => {
 };
 
 const isMatchingWidget = widget => {
-  return widget.id === SourceAction;
+  return widget.id === SourceAction$1;
 };
 const closeSourceAction = editor => {
   const {
@@ -2474,7 +2467,7 @@ const closeSourceAction = editor => {
   if (index === -1) {
     return editor;
   }
-  const newWidgets = removeEditorWidget(widgets, SourceAction);
+  const newWidgets = removeEditorWidget(widgets, SourceAction$1);
   return {
     ...editor,
     widgets: newWidgets
@@ -2618,7 +2611,7 @@ const compositionEnd = (editor, data) => {
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
-const normalizeLine$1 = line => {
+const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
   }
@@ -2627,41 +2620,41 @@ const normalizeLine$1 = line => {
   }
   return line;
 };
-const getCombinedMessage$1 = (error, message) => {
-  const stringifiedError = normalizeLine$1(`${error}`);
+const getCombinedMessage = (error, message) => {
+  const stringifiedError = normalizeLine(`${error}`);
   if (message) {
     return `${message}: ${stringifiedError}`;
   }
   return stringifiedError;
 };
-const NewLine$2 = '\n';
-const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
+const NewLine$1 = '\n';
+const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf(NewLine$1, startIndex);
 };
-const mergeStacks$1 = (parent, child) => {
+const mergeStacks = (parent, child) => {
   if (!child) {
     return parent;
   }
-  const parentNewLineIndex = getNewLineIndex$1(parent);
-  const childNewLineIndex = getNewLineIndex$1(child);
+  const parentNewLineIndex = getNewLineIndex(parent);
+  const childNewLineIndex = getNewLineIndex(child);
   if (childNewLineIndex === -1) {
     return parent;
   }
   const parentFirstLine = parent.slice(0, parentNewLineIndex);
   const childRest = child.slice(childNewLineIndex);
-  const childFirstLine = normalizeLine$1(child.slice(0, childNewLineIndex));
+  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
   if (parentFirstLine.includes(childFirstLine)) {
     return parentFirstLine + childRest;
   }
   return child;
 };
-let VError$1 = class VError extends Error {
+class VError extends Error {
   constructor(error, message) {
-    const combinedMessage = getCombinedMessage$1(error, message);
+    const combinedMessage = getCombinedMessage(error, message);
     super(combinedMessage);
     this.name = 'VError';
     if (error instanceof Error) {
-      this.stack = mergeStacks$1(this.stack, error.stack);
+      this.stack = mergeStacks(this.stack, error.stack);
     }
     if (error.codeFrame) {
       // @ts-ignore
@@ -2672,14 +2665,14 @@ let VError$1 = class VError extends Error {
       this.code = error.code;
     }
   }
-};
+}
 
 const writeText = async text => {
   try {
     string(text);
     await invoke$3('ClipBoard.writeText', /* text */text);
   } catch (error) {
-    throw new VError$1(error, 'Failed to write text to clipboard');
+    throw new VError(error, 'Failed to write text to clipboard');
   }
 };
 
@@ -3449,151 +3442,130 @@ const i18nString = (key, placeholders = emptyObject) => {
   return key.replaceAll(RE_PLACEHOLDER, replacer);
 };
 
-const UiStrings$1 = {
-  Copy: 'Copy',
-  CopyLineDown: 'Copy Line Down',
-  CopyLineUp: 'Copy Line Up',
-  Cut: 'Cut',
-  DuplicateSelection: 'Duplicate Selection',
-  EditorCloseColorPicker: 'Editor: Close Color Picker',
-  EditorCopyLineDown: 'Editor: Copy Line Down',
-  EditorCopyLineUp: 'Editor: Copy Line Up',
-  EditorFormatDocumentForced: 'Editor: Format Document (forced)',
-  EditorGoToDefinition: 'Editor: Go To Definition',
-  EditorGoToTypeDefinition: 'Editor: Go To Type Definition',
-  EditorIndent: 'Editor: Indent',
-  EditorOpenColorPicker: 'Editor: Open Color Picker',
-  EditorSelectAllOccurrences: 'Editor: Select All Occurrences',
-  EditorSelectDown: 'Editor: Select Down',
-  EditorSelectInsideString: 'Editor: Select Inside String',
-  EditorSelectNextOccurrence: 'Editor: Select Next Occurrence',
-  EditorSelectUp: 'Editor: Select Up',
-  EditorShowHover: 'Show Hover',
-  EditorSortLinesAscending: 'Editor: Sort Lines Ascending',
-  EditorToggleBlockComment: 'Editor: Toggle Block Comment',
-  EditorToggleComment: 'Editor: Toggle Comment',
-  EditorUnindent: 'Editor: Unindent',
-  EnterCode: 'Enter Code',
-  EscapeToClose: 'Escape to close',
-  FindAllImplementations: 'Find All Implementations',
-  FindAllReferences: 'Find All References',
-  FormatDocument: 'Format Document',
-  GoToDefinition: 'Go to Definition',
-  GoToTypeDefinition: 'Go to Type Definition',
-  MoveLineDown: 'Move Line Down',
-  MoveLineUp: 'Move Line Up',
-  NoCodeActionsAvailable: 'No code actions available',
-  NoDefinitionFound: 'No definition found',
-  NoDefinitionFoundFor: "No definition found for '{PH1}'",
-  NoResults: 'No Results',
-  NoTypeDefinitionFound: 'No type definition found',
-  NoTypeDefinitionFoundFor: "No type definition found for '{PH1}'",
-  OrganizeImports: 'Organize Imports',
-  Paste: 'Paste',
-  Redo: 'Redo',
-  Replace: 'Replace',
-  SelectAll: 'Select All',
-  Separator: 'Separator',
-  SortImports: 'Sort Imports',
-  SourceAction: 'Source Action',
-  SourceActions: 'Source Actions',
-  ToggleBlockComment: 'Toggle Block Comment',
-  ToggleLineComment: 'Toggle Line Comment',
-  Undo: 'Undo'
-};
+const EditorCloseColorPicker = 'Editor: Close Color Picker';
+const EditorCopyLineDown = 'Editor: Copy Line Down';
+const EditorCopyLineUp = 'Editor: Copy Line Up';
+const EditorFormatDocumentForced = 'Editor: Format Document (forced)';
+const EditorGoToDefinition = 'Editor: Go To Definition';
+const EditorGoToTypeDefinition = 'Editor: Go To Type Definition';
+const EditorIndent = 'Editor: Indent';
+const EditorOpenColorPicker = 'Editor: Open Color Picker';
+const EditorSelectAllOccurrences = 'Editor: Select All Occurrences';
+const EditorSelectDown = 'Editor: Select Down';
+const EditorSelectInsideString = 'Editor: Select Inside String';
+const EditorSelectNextOccurrence = 'Editor: Select Next Occurrence';
+const EditorSelectUp = 'Editor: Select Up';
+const EditorShowHover = 'Show Hover';
+const EditorSortLinesAscending = 'Editor: Sort Lines Ascending';
+const EditorToggleComment = 'Editor: Toggle Comment';
+const EditorUnindent = 'Editor: Unindent';
+const EnterCode = 'Enter Code';
+const EscapeToClose = 'Escape to close';
+const FormatDocument = 'Format Document';
+const MoveLineDown = 'Move Line Down';
+const MoveLineUp = 'Move Line Up';
+const NoCodeActionsAvailable = 'No code actions available';
+const NoDefinitionFound = 'No definition found';
+const NoDefinitionFoundFor = "No definition found for '{PH1}'";
+const NoResults = 'No Results';
+const NoTypeDefinitionFound = 'No type definition found';
+const NoTypeDefinitionFoundFor = "No type definition found for '{PH1}'";
+const SourceAction = 'Source Action';
+const ToggleBlockComment = 'Toggle Block Comment';
+
 const noDefinitionFound = () => {
-  return i18nString(UiStrings$1.NoDefinitionFound);
+  return i18nString(NoDefinitionFound);
 };
 const noDefinitionFoundFor = word => {
-  return i18nString(UiStrings$1.NoDefinitionFoundFor, {
+  return i18nString(NoDefinitionFoundFor, {
     PH1: word
   });
 };
 const noTypeDefinitionFoundFor = word => {
-  return i18nString(UiStrings$1.NoTypeDefinitionFoundFor, {
+  return i18nString(NoTypeDefinitionFoundFor, {
     PH1: word
   });
 };
 const noTypeDefinitionFound = () => {
-  return i18nString(UiStrings$1.NoTypeDefinitionFound);
+  return i18nString(NoTypeDefinitionFound);
 };
 const noResults$1 = () => {
-  return i18nString(UiStrings$1.NoResults);
+  return i18nString(NoResults);
 };
 const sourceAction = () => {
-  return i18nString(UiStrings$1.SourceAction);
+  return i18nString(SourceAction);
 };
 const noCodeActionsAvailable = () => {
-  return i18nString(UiStrings$1.NoCodeActionsAvailable);
+  return i18nString(NoCodeActionsAvailable);
 };
 const escapeToClose = () => {
-  return i18nString(UiStrings$1.EscapeToClose);
+  return i18nString(EscapeToClose);
 };
 const enterCode = () => {
-  return i18nString(UiStrings$1.EnterCode);
+  return i18nString(EnterCode);
 };
 const toggleBlockComment$1 = () => {
-  return i18nString(UiStrings$1.ToggleBlockComment);
+  return i18nString(ToggleBlockComment);
 };
 const moveLineUp$1 = () => {
-  return i18nString(UiStrings$1.MoveLineUp);
+  return i18nString(MoveLineUp);
 };
 const moveLineDown$1 = () => {
-  return i18nString(UiStrings$1.MoveLineDown);
+  return i18nString(MoveLineDown);
 };
 const formatDocument = () => {
-  return i18nString(UiStrings$1.FormatDocument);
+  return i18nString(FormatDocument);
 };
 const editorShowHover = () => {
-  return i18nString(UiStrings$1.EditorShowHover);
+  return i18nString(EditorShowHover);
 };
 const editorFormatDocumentForced = () => {
-  return i18nString(UiStrings$1.EditorFormatDocumentForced);
+  return i18nString(EditorFormatDocumentForced);
 };
 const editorSelectNextOccurrence = () => {
-  return i18nString(UiStrings$1.EditorSelectNextOccurrence);
+  return i18nString(EditorSelectNextOccurrence);
 };
 const editorSelectAllOccurrences = () => {
-  return i18nString(UiStrings$1.EditorSelectAllOccurrences);
+  return i18nString(EditorSelectAllOccurrences);
 };
 const editorGoToDefinition = () => {
-  return i18nString(UiStrings$1.EditorGoToDefinition);
+  return i18nString(EditorGoToDefinition);
 };
 const editorGoToTypeDefinition = () => {
-  return i18nString(UiStrings$1.EditorGoToTypeDefinition);
+  return i18nString(EditorGoToTypeDefinition);
 };
 const editorSelectInsideString = () => {
-  return i18nString(UiStrings$1.EditorSelectInsideString);
+  return i18nString(EditorSelectInsideString);
 };
 const editorIndent = () => {
-  return i18nString(UiStrings$1.EditorIndent);
+  return i18nString(EditorIndent);
 };
 const editorUnindent$1 = () => {
-  return i18nString(UiStrings$1.EditorUnindent);
+  return i18nString(EditorUnindent);
 };
 const editorSortLinesAscending = () => {
-  return i18nString(UiStrings$1.EditorSortLinesAscending);
+  return i18nString(EditorSortLinesAscending);
 };
 const editorToggleComment = () => {
-  return i18nString(UiStrings$1.EditorToggleComment);
+  return i18nString(EditorToggleComment);
 };
 const editorSelectUp = () => {
-  return i18nString(UiStrings$1.EditorSelectUp);
+  return i18nString(EditorSelectUp);
 };
 const editorSelectDown = () => {
-  return i18nString(UiStrings$1.EditorSelectDown);
+  return i18nString(EditorSelectDown);
 };
 const editorOpenColorPicker = () => {
-  return i18nString(UiStrings$1.EditorOpenColorPicker);
+  return i18nString(EditorOpenColorPicker);
 };
 const editorCloseColorPicker = () => {
-  return i18nString(UiStrings$1.EditorCloseColorPicker);
+  return i18nString(EditorCloseColorPicker);
 };
 const editorCopyLineDown = () => {
-  return i18nString(UiStrings$1.EditorCopyLineDown);
+  return i18nString(EditorCopyLineDown);
 };
 const editorCopyLineUp = () => {
-  return i18nString(UiStrings$1.EditorCopyLineUp);
+  return i18nString(EditorCopyLineUp);
 };
 
 // @ts-ignore
@@ -3817,9 +3789,6 @@ const setPosition$1 = position => {
   state$5.position = position;
 };
 
-const Ctrl = 1;
-const Alt$1 = 2;
-
 // TODO first change cursor position, then run go to definition
 // cursor should appear at mousedown position immediately
 const handleSingleClickWithAlt = async (editor, position) => {
@@ -3836,6 +3805,7 @@ const handleSingleClickWithAlt = async (editor, position) => {
   const newEditor2 = await goToDefinition(newEditor);
   return newEditor2;
 };
+
 const handleSingleClickWithCtrl = async (editor, position) => {
   const selections = editor.selections;
   for (let i = 0; i < selections.length; i += 4) {
@@ -3859,6 +3829,10 @@ const handleSingleClickWithCtrl = async (editor, position) => {
   newSelections[insertIndex + 3] = position.columnIndex;
   return scheduleSelections(editor, newSelections);
 };
+
+const Ctrl = 1;
+const Alt$1 = 2;
+
 const handleSingleClickDefault = (editor, position) => {
   setPosition$1(position);
   return {
@@ -3867,7 +3841,7 @@ const handleSingleClickDefault = (editor, position) => {
     focused: true
   };
 };
-const getFn = modifier => {
+const getClickHandler = modifier => {
   switch (modifier) {
     case Alt$1:
       return handleSingleClickWithAlt;
@@ -3877,13 +3851,14 @@ const getFn = modifier => {
       return handleSingleClickDefault;
   }
 };
+
 const handleSingleClick = async (editor, modifier, x, y) => {
   object(editor);
   number(modifier);
   number(x);
   number(y);
   const position = at(editor, x, y);
-  const fn = getFn(modifier);
+  const fn = getClickHandler(modifier);
   const newEditor = await fn(editor, position);
   // switch (newEditor.completionState) {
   //   case EditorCompletionState.None:
@@ -4201,9 +4176,6 @@ const handleScrollBarHorizontalPointerDown = (state, eventX) => {
     x,
     deltaX,
     width,
-    finalDeltaY,
-    height,
-    scrollBarHeight,
     longestLineWidth
   } = state;
   const relativeX = eventX - x;
@@ -4356,9 +4328,7 @@ const setDelta = (editor, deltaMode, eventDeltaX, eventDeltaY) => {
   number(eventDeltaY);
   // @ts-ignore
   const {
-    deltaX,
-    deltaY
-  } = editor;
+    deltaX} = editor;
   if (eventDeltaX === 0) {
     return setDeltaY$1(editor, eventDeltaY);
   }
@@ -4812,9 +4782,6 @@ const create$5 = () => {
   return completionWidget;
 };
 
-const combineResults$2 = results => {
-  return results[0] ?? [];
-};
 const executeCompletionProvider = async (editor, offset) => {
   return execute({
     editor,
@@ -4822,12 +4789,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({
@@ -4836,9 +4798,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 => {
@@ -5129,6 +5089,7 @@ const getWordAtOffset = editor => {
   }
   return '';
 };
+
 const handleEditorType$2 = (editorUid, state, text) => {
   const editor = getEditor(editorUid);
   const {
@@ -5337,19 +5298,6 @@ const create$4 = () => {
   return widget;
 };
 
-// copied from https://github.com/microsoft/vscode/tree/main/src/vs/base/common/strings.ts by Microsoft (License MIT)
-
-const RE_ESCAPE = /[\\\{\}\*\+\?\|\^\$\.\[\]\(\)]/g;
-const escapeRegExpCharacters = value => {
-  return value.replaceAll(RE_ESCAPE, '\\$&');
-};
-
-const regexFlags = 'gi';
-const getSearchRegex = searchString => {
-  const escaped = escapeRegExpCharacters(searchString);
-  return new RegExp(escaped, regexFlags);
-};
-
 const findRegexMatches = (lines, regex) => {
   if (!regex.global) {
     throw new Error('regex must be global');
@@ -5372,6 +5320,19 @@ const findRegexMatches = (lines, regex) => {
   return new Uint32Array(matches);
 };
 
+// copied from https://github.com/microsoft/vscode/tree/main/src/vs/base/common/strings.ts by Microsoft (License MIT)
+
+const RE_ESCAPE = /[\\\{\}\*\+\?\|\^\$\.\[\]\(\)]/g;
+const escapeRegExpCharacters = value => {
+  return value.replaceAll(RE_ESCAPE, '\\$&');
+};
+
+const regexFlags = 'gi';
+const getSearchRegex = searchString => {
+  const escaped = escapeRegExpCharacters(searchString);
+  return new RegExp(escaped, regexFlags);
+};
+
 const findMatchesCaseInsensitive = (lines, searchString) => {
   if (searchString.length === 0) {
     return new Uint32Array([]);
@@ -5946,7 +5907,7 @@ const save = async editor => {
     return newEditor;
   } catch (error) {
     // @ts-ignore
-    const betterError = new VError$1(error, `Failed to save file "${editor.uri}"`);
+    const betterError = new VError(error, `Failed to save file "${editor.uri}"`);
     await handleError(betterError);
     return editor;
   }
@@ -6235,6 +6196,23 @@ const selectInsideString = editor => {
   return scheduleSelections(editor, newSelections);
 };
 
+// import * as ExtensionHostSelection from '../ExtensionHost/ExtensionHostSelection.ts'
+
+const getNewSelections = async (editor, selections) => {
+  const newSelections = await invoke$3('ExtensionHostSelection.executeGrowSelection', editor, selections);
+  if (newSelections.length === 0) {
+    return selections;
+  }
+  return new Uint32Array(newSelections);
+};
+const selectionGrow = async editor => {
+  const {
+    selections
+  } = editor;
+  const newSelections = await getNewSelections(editor, selections);
+  return scheduleSelections(editor, newSelections);
+};
+
 // TODO handle virtual space
 
 // TODO editors behave differently when selecting next occurrence, for example:
@@ -6446,23 +6424,6 @@ const selectWordRight = editor => {
   return editorSelectHorizontalRight(editor, wordRight);
 };
 
-// import * as ExtensionHostSelection from '../ExtensionHost/ExtensionHostSelection.ts'
-
-const getNewSelections = async (editor, selections) => {
-  const newSelections = await invoke$3('ExtensionHostSelection.executeGrowSelection', editor, selections);
-  if (newSelections.length === 0) {
-    return selections;
-  }
-  return new Uint32Array(newSelections);
-};
-const selectionGrow = async editor => {
-  const {
-    selections
-  } = editor;
-  const newSelections = await getNewSelections(editor, selections);
-  return scheduleSelections(editor, newSelections);
-};
-
 const setDecorations = (editor, decorations, diagnostics) => {
   if (editor.decorations.length === 0 && decorations.length === 0) {
     return editor;
@@ -6474,6 +6435,19 @@ const setDecorations = (editor, decorations, diagnostics) => {
   };
 };
 
+let enabled$1 = false;
+const setEnabled$1 = value => {
+  enabled$1 = value;
+};
+const getEnabled$1 = () => {
+  return enabled$1;
+};
+
+const {
+  listen: listen$3,
+  invoke: invoke$1
+} = createRpc(SyntaxHighlightingWorker);
+
 /**
  * @enum number
  */
@@ -6513,14 +6487,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;
 };
@@ -6534,19 +6501,6 @@ const isPending = languageId => {
   return languageId in state$1.pending;
 };
 
-let enabled$1 = false;
-const setEnabled$1 = value => {
-  enabled$1 = value;
-};
-const getEnabled$1 = () => {
-  return enabled$1;
-};
-
-const {
-  listen: listen$5,
-  invoke: invoke$1
-} = createRpc(SyntaxHighlightingWorker);
-
 const tokenMaps = Object.create(null);
 const set$1 = (languageId, tokenMap) => {
   tokenMaps[languageId] = tokenMap;
@@ -6666,12 +6620,6 @@ const setSelections = (editor, selections) => {
   };
 };
 
-const EditorHover = 'EditorHover';
-const showHover = async state => {
-  await invoke$3('Viewlet.openWidget', EditorHover);
-  return state;
-};
-
 const create$2 = () => {
   const uid = create$8();
   const widget = {
@@ -6725,7 +6673,7 @@ const getHover = async (editor, offset) => {
 };
 
 let _ipc;
-const listen$4 = async () => {
+const listen$2 = async () => {
   const ipc = await create$a({
     method: RendererProcess
   });
@@ -6946,6 +6894,12 @@ const showHover2 = async editor => {
   return addWidgetToEditor(Hover, FocusEditorHover, editor, create$2, newStateGenerator);
 };
 
+const EditorHover = 'EditorHover';
+const showHover = async state => {
+  await invoke$3('Viewlet.openWidget', EditorHover);
+  return state;
+};
+
 // TODO ask extension host worker instead
 const getEditorSourceActions = async () => {
   const sourceActions = await invoke$3('GetEditorSourceActions.getEditorSourceActions');
@@ -6999,7 +6953,7 @@ const loadSourceActions = async (editor, state) => {
 const create$1 = () => {
   const completionUid = create$8();
   const widget = {
-    id: SourceAction,
+    id: SourceAction$1,
     oldState: {
       uid: completionUid,
       x: 0,
@@ -7028,7 +6982,7 @@ const showSourceActions = async editor => {
   const newStateGenerator = async state => {
     return loadSourceActions(editor, state);
   };
-  return addWidgetToEditor(SourceAction, SourceActions, editor, create$1, newStateGenerator);
+  return addWidgetToEditor(SourceAction$1, SourceActions, editor, create$1, newStateGenerator);
 };
 
 const compareString = (a, b) => {
@@ -7090,9 +7044,6 @@ const sortLinesAscending = editor => {
   return scheduleDocumentAndCursorsSelections(editor, changes);
 };
 
-const combineResults$1 = results => {
-  return results[0];
-};
 const executeTabCompletionProvider = async (editor, offset) => {
   return execute({
     editor,
@@ -7100,7 +7051,6 @@ const executeTabCompletionProvider = async (editor, offset) => {
     method: TabCompletionExecuteTabCompletionProvider,
     args: [offset],
     noProviderFoundMessage: 'No tab completion provider found',
-    combineResults: combineResults$1,
     noProviderFoundResult: undefined
   });
 };
@@ -7281,7 +7231,7 @@ const getBlockCommentEdits = (editor, blockComment) => {
         },
         inserted: [],
         deleted: [blockCommentStart],
-        origin: ToggleBlockComment
+        origin: ToggleBlockComment$1
       };
       const change2 = {
         start: {
@@ -7294,7 +7244,7 @@ const getBlockCommentEdits = (editor, blockComment) => {
         },
         inserted: [],
         deleted: [blockCommentEnd],
-        origin: ToggleBlockComment
+        origin: ToggleBlockComment$1
       };
       changes.push(change1, change2);
     } else {
@@ -7309,7 +7259,7 @@ const getBlockCommentEdits = (editor, blockComment) => {
         },
         inserted: [],
         deleted: [blockCommentStart],
-        origin: ToggleBlockComment
+        origin: ToggleBlockComment$1
       };
       const change2 = {
         start: {
@@ -7322,7 +7272,7 @@ const getBlockCommentEdits = (editor, blockComment) => {
         },
         inserted: [],
         deleted: [blockCommentEnd],
-        origin: ToggleBlockComment
+        origin: ToggleBlockComment$1
       };
       changes.push(change1, change2);
 
@@ -7361,7 +7311,7 @@ const getBlockCommentEdits = (editor, blockComment) => {
       },
       inserted: [blockCommentStart],
       deleted: [],
-      origin: ToggleBlockComment
+      origin: ToggleBlockComment$1
     };
     const change2 = {
       start: {
@@ -7374,7 +7324,7 @@ const getBlockCommentEdits = (editor, blockComment) => {
       },
       inserted: [blockCommentEnd],
       deleted: [],
-      origin: ToggleBlockComment
+      origin: ToggleBlockComment$1
     };
     changes.push(change1, change2);
     // TextDocument.setLine(
@@ -7890,14 +7840,14 @@ const setDeltaY = (state, value) => {
   };
 };
 
-const handleWheel = (state, deltaMode, deltaY) => {
+const handleWheel$1 = (state, deltaMode, deltaY) => {
   number(deltaMode);
   number(deltaY);
   return setDeltaY(state, state.deltaY + deltaY);
 };
 
-const handelWheel = (state, deltaMode, deltaY) => {
-  const newState = handleWheel(state, deltaMode, deltaY);
+const handleWheel = (state, deltaMode, deltaY) => {
+  const newState = handleWheel$1(state, deltaMode, deltaY);
   return newState;
 };
 
@@ -7962,9 +7912,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;
@@ -8070,9 +8018,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 {
@@ -8139,6 +8085,30 @@ const SourceActionItem = 'SourceActionItem';
 const SourceActionItemFocused = 'SourceActionItemFocused';
 const Viewlet = 'Viewlet';
 
+const HandleBeforeInput = 'handleBeforeInput';
+const HandleBlur = 'handleBlur';
+const HandleClick = 'handleClick';
+const HandleClickClose = 'handleClickClose';
+const HandleClickNextMatch = 'handleClickNextMatch';
+const HandleClickPreviousMatch = 'handleClickPreviousMatch';
+const HandleClickReplace = 'handleClickReplace';
+const HandleClickReplaceAll = 'handleClickReplaceAll';
+const HandleClose = 'handleClose';
+const HandleCompositionEnd = 'handleCompositionEnd';
+const HandleCompositionStart = 'handleCompositionStart';
+const HandleCompositionUpdate = 'handleCompositionUpdate';
+const HandleContextMenu = 'handleContextMenu';
+const HandleCut = 'handleCut';
+const HandleFocus = 'handleFocus';
+const HandleFocusIn = 'handleFocusIn';
+const HandleInput = 'handleInput';
+const HandleMouseMove = 'handleMouseMove';
+const HandlePointerDown = 'handlePointerDown';
+const HandleReplaceFocus = 'handleReplaceFocus';
+const HandleReplaceInput = 'handleReplaceInput';
+const HandleSashPointerDown = 'handleSashPointerDown';
+const HandleWheel = 'handleWheel';
+
 const Button = 1;
 const Div = 4;
 const Input = 6;
@@ -8177,21 +8147,6 @@ const getLineInfosVirtualDom = lineInfos => {
   return dom;
 };
 
-const HandlePointerDown = 'handlePointerDown';
-const HandleSashPointerDown = 'handleSashPointerDown';
-const HandleClose = 'handleClose';
-const HandleFocusIn = 'handleFocusIn';
-const HandleClick = 'handleClick';
-const HandleInput = 'handleInput';
-const HandleFocus = 'handleFocus';
-const HandleClickPreviousMatch = 'handleClickPreviousMatch';
-const HandleClickNextMatch = 'handleClickNextMatch';
-const HandleClickClose = 'handleClickClose';
-const HandleClickReplace = 'handleClickReplace';
-const HandleClickReplaceAll = 'handleClickReplaceAll';
-const HandleReplaceInput = 'handleReplaceInput';
-const HandleReplaceFocus = 'handleReplaceFocus';
-
 const hoverProblemMessage = {
   type: Span,
   className: HoverProblemMessage,
@@ -8290,9 +8245,6 @@ const renderHover = (oldState, newState) => {
   return commands;
 };
 
-const combineResults = results => {
-  return results[0] ?? [];
-};
 const executeRenameProvider = async (editor, offset, newName) => {
   return execute({
     editor,
@@ -8300,9 +8252,7 @@ const executeRenameProvider = async (editor, offset, newName) => {
     method: RenameExecuteRename,
     args: [offset, newName],
     noProviderFoundMessage: 'no rename provider found',
-    noProviderFoundResult: [],
-    combineResults
-  });
+    noProviderFoundResult: []});
 };
 
 const getRenameState = editor => {
@@ -8475,7 +8425,7 @@ const loadFont = async (fontName, fontUrl) => {
     // @ts-ignore
     fonts.add(fontFace);
   } catch (error) {
-    throw new VError$1(error, `Failed to load font ${fontName}`);
+    throw new VError(error, `Failed to load font ${fontName}`);
   }
 };
 
@@ -8981,7 +8931,7 @@ const getText = editorUid => {
   const {
     lines
   } = editor;
-  return lines.join(NewLine$4);
+  return lines.join(NewLine$3);
 };
 
 const InsertText = 'insertText';
@@ -9017,15 +8967,15 @@ const getEnabled = () => {
 };
 
 const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
-  await listen$4();
+  await listen$2();
   if (syntaxHighlightingEnabled) {
     setEnabled$1(true);
-    await listen$5();
+    await listen$3();
   }
   if (syncIncremental) {
     setEnabled(true);
   }
-  await listen$6();
+  await listen$4();
 };
 
 // TODO move cursor
@@ -9541,10 +9491,6 @@ const getVisible = async (editor, syncIncremental) => {
     lines,
     width,
     deltaX,
-    fontWeight,
-    fontSize,
-    fontFamily,
-    letterSpacing,
     charWidth
   } = editor;
   const maxLineY = Math.min(minLineY + numberOfVisibleLines, lines.length);
@@ -9900,6 +9846,43 @@ const renderEditor = async id => {
   return commands;
 };
 
+const renderEventListeners = () => {
+  return [{
+    name: HandleFocus,
+    params: ['handleFocus']
+  }, {
+    name: HandleMouseMove,
+    params: ['handleInput', 'event.clientX', 'event.clientY', 'event.altKey']
+  }, {
+    name: HandleBlur,
+    params: ['handleBlur']
+  }, {
+    name: HandleBeforeInput,
+    params: ['handleBeforeInput', 'event.inputType', 'event.data']
+  }, {
+    name: HandleCompositionStart,
+    params: ['compositionStart', 'event.data']
+  }, {
+    name: HandleCompositionUpdate,
+    params: ['compositionUpdate', 'event.data']
+  }, {
+    name: HandleCompositionEnd,
+    params: ['compositionUpdate', 'event.data']
+  }, {
+    name: HandleCut,
+    params: ['cut'],
+    preventDefault: true
+  }, {
+    name: HandleWheel,
+    params: ['setDelta', 'event.deltaMode', 'event.deltaY'],
+    preventDefault: true
+  }, {
+    name: HandleContextMenu,
+    params: ['handleContextMenu', 'event.button', 'event.clientX', 'event.clientY'],
+    preventDefault: true
+  }];
+};
+
 const editorDiagnosticEffect = {
   isActive(oldEditor, newEditor) {
     // TODO avoid slow comparison
@@ -10099,6 +10082,7 @@ const commandMap = {
   'Editor.paste': paste,
   'Editor.pasteText': pasteText,
   'Editor.render': renderEditor,
+  'Editor.renderEventListeners': renderEventListeners,
   'Editor.replaceRange': replaceRange,
   'Editor.rerender': rerender,
   'Editor.save': save,
@@ -10147,7 +10131,7 @@ const commandMap = {
   'EditorCompletion.handleEditorClick': handleEditorClick,
   'EditorCompletion.handleEditorDeleteLeft': handleEditorDeleteLeft$2,
   'EditorCompletion.handleEditorType': handleEditorType$2,
-  'EditorCompletion.handleWheel': handelWheel,
+  'EditorCompletion.handleWheel': handleWheel,
   'EditorCompletion.loadContent': loadContent$2,
   'EditorCompletion.openDetails': openDetails,
   'EditorCompletion.selectCurrent': selectCurrent,
@@ -10191,67 +10175,6 @@ const commandMap = {
 };
 wrapCommands(commandMap);
 
-const MessagePort$1 = 1;
-const ModuleWorker = 2;
-const ReferencePort = 3;
-const ModuleWorkerAndMessagePort = 8;
-const Auto = () => {
-  // @ts-ignore
-  if (globalThis.acceptPort) {
-    return MessagePort$1;
-  }
-  // @ts-ignore
-  if (globalThis.acceptReferencePort) {
-    return ReferencePort;
-  }
-  return ModuleWorkerAndMessagePort;
-};
-
-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;
-  }
-  if (isTransferrable(value)) {
-    transferrables.push(value);
-    return;
-  }
-  if (Array.isArray(value)) {
-    for (const item of value) {
-      walkValue(item, transferrables, isTransferrable);
-    }
-    return;
-  }
-  if (typeof value === 'object') {
-    for (const property of Object.values(value)) {
-      walkValue(property, transferrables, isTransferrable);
-    }
-    return;
-  }
-};
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -10276,126 +10199,88 @@ const isTransferrable = value => {
   }
   return false;
 };
-const getTransferrables = value => {
-  const transferrables = [];
-  walkValue(value, transferrables, isTransferrable);
-  return transferrables;
-};
-const listen$3 = ({
-  port
-}) => {
-  return port;
-};
-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);
+const walkValue = (value, transferrables, isTransferrable) => {
+  if (!value) {
+    return;
   }
-  dispose() {
-    // ignore
+  if (isTransferrable(value)) {
+    transferrables.push(value);
+    return;
   }
-  onClose(callback) {
-    // ignore
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables, isTransferrable);
+    }
+    return;
   }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
+  if (typeof value === 'object') {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables, isTransferrable);
+    }
+    return;
   }
-}
-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 getTransferrables = value => {
+  const transferrables = [];
+  walkValue(value, transferrables, isTransferrable);
+  return transferrables;
 };
-const signal$2 = global => {
-  global.postMessage(readyMessage);
+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 IpcChildWithModuleWorker extends Ipc {
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    // @ts-ignore
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    // @ts-ignore
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
   }
 }
-const wrap$5 = global => {
-  return new IpcChildWithModuleWorker(global);
-};
-const IpcChildWithModuleWorker$1 = {
-  __proto__: null,
-  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';
 const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
-const NewLine$1 = '\n';
+const NewLine = '\n';
 const joinLines = lines => {
-  return lines.join(NewLine$1);
-};
-const splitLines = lines => {
-  return lines.split(NewLine$1);
+  return lines.join(NewLine);
 };
-const isModuleNotFoundMessage = line => {
-  return line.includes('[ERR_MODULE_NOT_FOUND]');
+const RE_AT = /^\s+at/;
+const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
+const isNormalStackLine = line => {
+  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
 };
-const getModuleNotFoundError = stderr => {
-  const lines = splitLines(stderr);
-  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
-  const message = lines[messageIndex];
+const getDetails = lines => {
+  const index = lines.findIndex(isNormalStackLine);
+  if (index === -1) {
+    return {
+      actualMessage: joinLines(lines),
+      rest: []
+    };
+  }
+  let lastIndex = index - 1;
+  while (++lastIndex < lines.length) {
+    if (!isNormalStackLine(lines[lastIndex])) {
+      break;
+    }
+  }
   return {
-    message,
-    code: ERR_MODULE_NOT_FOUND
+    actualMessage: lines[index - 1],
+    rest: lines.slice(index, lastIndex)
   };
 };
-const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
-const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const splitLines = lines => {
+  return lines.split(NewLine);
+};
 const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
 const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
-const RE_AT = /^\s+at/;
-const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
-const isUnhelpfulNativeModuleError = stderr => {
-  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
-};
 const isMessageCodeBlockStartIndex = line => {
   return RE_MESSAGE_CODE_BLOCK_START.test(line);
 };
@@ -10410,51 +10295,46 @@ const getMessageCodeBlock = stderr => {
   const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
   return relevantMessage;
 };
-const getNativeModuleErrorMessage = stderr => {
-  const message = getMessageCodeBlock(stderr);
+const isModuleNotFoundMessage = line => {
+  return line.includes('[ERR_MODULE_NOT_FOUND]');
+};
+const getModuleNotFoundError = stderr => {
+  const lines = splitLines(stderr);
+  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
+  const message = lines[messageIndex];
   return {
-    message: `Incompatible native node module: ${message}`,
-    code: E_INCOMPATIBLE_NATIVE_MODULE
+    message,
+    code: ERR_MODULE_NOT_FOUND
   };
 };
-const isModulesSyntaxError = stderr => {
+const isModuleNotFoundError = stderr => {
   if (!stderr) {
     return false;
   }
-  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
-};
-const getModuleSyntaxError = () => {
-  return {
-    message: `ES Modules are not supported in electron`,
-    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
-  };
+  return stderr.includes('ERR_MODULE_NOT_FOUND');
 };
-const isModuleNotFoundError = stderr => {
+const isModulesSyntaxError = stderr => {
   if (!stderr) {
     return false;
   }
-  return stderr.includes('ERR_MODULE_NOT_FOUND');
+  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
 };
-const isNormalStackLine = line => {
-  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
+const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
+const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
+const isUnhelpfulNativeModuleError = stderr => {
+  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
 };
-const getDetails = lines => {
-  const index = lines.findIndex(isNormalStackLine);
-  if (index === -1) {
-    return {
-      actualMessage: joinLines(lines),
-      rest: []
-    };
-  }
-  let lastIndex = index - 1;
-  while (++lastIndex < lines.length) {
-    if (!isNormalStackLine(lines[lastIndex])) {
-      break;
-    }
-  }
+const getNativeModuleErrorMessage = stderr => {
+  const message = getMessageCodeBlock(stderr);
   return {
-    actualMessage: lines[index - 1],
-    rest: lines.slice(index, lastIndex)
+    message: `Incompatible native node module: ${message}`,
+    code: E_INCOMPATIBLE_NATIVE_MODULE
+  };
+};
+const getModuleSyntaxError = () => {
+  return {
+    message: `ES Modules are not supported in electron`,
+    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON
   };
 };
 const getHelpfulChildProcessError = (stdout, stderr) => {
@@ -10473,66 +10353,11 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
     rest
   } = getDetails(lines);
   return {
-    message: `${actualMessage}`,
+    message: actualMessage,
     code: '',
     stack: rest
   };
 };
-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 = '\n';
-const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
-};
-const mergeStacks = (parent, child) => {
-  if (!child) {
-    return parent;
-  }
-  const parentNewLineIndex = getNewLineIndex(parent);
-  const childNewLineIndex = getNewLineIndex(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;
-    }
-  }
-}
 class IpcError extends VError {
   // @ts-ignore
   constructor(betterMessage, stdout = '', stderr = '') {
@@ -10559,12 +10384,98 @@ class IpcError extends VError {
     this.stderr = stderr;
   }
 }
+const readyMessage = 'ready';
+const getData$2 = event => {
+  return event.data;
+};
+const listen$8 = ({
+  port
+}) => {
+  return port;
+};
+const signal$9 = port => {
+  port.postMessage(readyMessage);
+};
+class IpcChildWithMessagePort extends Ipc {
+  getData(event) {
+    return getData$2(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$g = port => {
+  return new IpcChildWithMessagePort(port);
+};
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$8,
+  signal: signal$9,
+  wrap: wrap$g
+};
+const listen$7 = () => {
+  // @ts-ignore
+  if (typeof WorkerGlobalScope === 'undefined') {
+    throw new TypeError('module is not in web worker scope');
+  }
+  return globalThis;
+};
+const signal$8 = global => {
+  global.postMessage(readyMessage);
+};
+class IpcChildWithModuleWorker extends Ipc {
+  getData(event) {
+    return getData$2(event);
+  }
+  send(message) {
+    // @ts-ignore
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    // @ts-ignore
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+}
+const wrap$f = global => {
+  return new IpcChildWithModuleWorker(global);
+};
+const IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$7,
+  signal: signal$8,
+  wrap: wrap$f
+};
 const withResolvers = () => {
   let _resolve;
   const promise = new Promise(resolve => {
     _resolve = resolve;
   });
   return {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     resolve: _resolve,
     promise
   };
@@ -10581,10 +10492,10 @@ const waitForFirstMessage = async port => {
   // @ts-ignore
   return event.data;
 };
-const listen$1$1 = async () => {
-  const parentIpcRaw = listen$2();
-  signal$2(parentIpcRaw);
-  const parentIpc = wrap$5(parentIpcRaw);
+const listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$8(parentIpcRaw);
+  const parentIpc = wrap$f(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError('unexpected first message');
@@ -10603,11 +10514,8 @@ const listen$1$1 = async () => {
   return globalThis;
 };
 class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
   getData(event) {
-    return getData$1(event);
+    return getData$2(event);
   }
   send(message) {
     this._rawIpc.postMessage(message);
@@ -10629,13 +10537,29 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$4 = port => {
+const wrap$e = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
-  listen: listen$1$1,
-  wrap: wrap$4
+  listen: listen$6,
+  wrap: wrap$e
+};
+
+const MessagePort$1 = 1;
+const ModuleWorker = 2;
+const ReferencePort = 3;
+const ModuleWorkerAndMessagePort = 8;
+const Auto = () => {
+  // @ts-ignore
+  if (globalThis.acceptPort) {
+    return MessagePort$1;
+  }
+  // @ts-ignore
+  if (globalThis.acceptReferencePort) {
+    return ReferencePort;
+  }
+  return ModuleWorkerAndMessagePort;
 };
 
 const getModule = method => {
@@ -10656,12 +10580,14 @@ const listen$1 = async ({
   method
 }) => {
   const module = await getModule(method);
+  // @ts-ignore
   const rawIpc = await module.listen();
   // @ts-ignore
   if (module.signal) {
     // @ts-ignore
     module.signal(rawIpc);
   }
+  // @ts-ignore
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
@@ -10672,7 +10598,7 @@ const listen = async () => {
     method: Auto()
   });
   handleIpc(ipc);
-  listen$7(ipc);
+  listen$5(ipc);
 };
 
 const addWidget = (widget, id, render) => {
@@ -11378,7 +11304,6 @@ const EditorCompletionWidget = {
  * @enum {string}
  */
 const UiStrings = {
-  MatchesFoundFor: '{PH1} of {PH2} found for {PH3}',
   MatchOf: '{PH1} of {PH2}',
   NoResults: 'No Results',
   Close: 'Close',
@@ -12043,11 +11968,27 @@ const registerWidgets = () => {
   set$7(Find, EditorFindWidget);
   set$7(Hover, EditorHoverWidget);
   set$7(Rename, EditorRenameWidget);
-  set$7(SourceAction, EditorSourceActionWidget);
+  set$7(SourceAction$1, EditorSourceActionWidget);
   set$7(CodeGenerator, EditorCodeGeneratorWidget);
 };
 
+const handleUnhandledRejection = event => {
+  event.preventDefault();
+  console.error(`[editor-worker] Unhandled Rejection: ${event.reason}`);
+};
+const handleUnhandledError = (message, filename, lineno, colno, error) => {
+  console.error(`[editor-worker] Unhandled Error: ${error}`);
+  return true;
+};
+
+const setupUnhandledErrorHandling = global => {
+  // @ts-ignore
+  global.addEventListener('error', handleUnhandledError);
+  global.addEventListener('unhandledrejection', handleUnhandledRejection);
+};
+
 const main = async () => {
+  setupUnhandledErrorHandling(globalThis);
   await listen();
   registerWidgets();
 };