@lvce-editor/editor-worker 5.12.0 → 5.15.0

package/dist/editorWorkerMain.js

@@ -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 = '"';
@@ -500,15 +500,15 @@ const createMeasureContext = () => {
   return ctx;
 };
 
-const state$a = {
+const state$9 = {
   ctx: undefined
 };
 const getOrCreate = createCtx => {
-  if (state$a.ctx) {
-    return state$a.ctx;
+  if (state$9.ctx) {
+    return state$9.ctx;
   }
-  state$a.ctx = createCtx();
-  return state$a.ctx;
+  state$9.ctx = createCtx();
+  return state$9.ctx;
 };
 
 const getContext = () => {
@@ -1053,25 +1053,20 @@ const TabCompletionExecuteTabCompletionProvider = 'ExtensionHost.executeTabCompl
 const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
 
 const Two = '2.0';
-const state$9 = {
-  callbacks: Object.create(null)
-};
+const callbacks = Object.create(null);
 const set$5 = (id, fn) => {
-  state$9.callbacks[id] = fn;
+  callbacks[id] = fn;
 };
 const get$5 = id => {
-  return state$9.callbacks[id];
+  return callbacks[id];
 };
 const remove$8 = id => {
-  delete state$9.callbacks[id];
+  delete callbacks[id];
 };
 let id = 0;
 const create$3$1 = () => {
   return ++id;
 };
-const warn$1 = (...args) => {
-  console.warn(...args);
-};
 const registerPromise = () => {
   const id = create$3$1();
   const {
@@ -1084,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,
@@ -1116,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';
@@ -1161,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) {
@@ -1187,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;
       }
@@ -1214,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);
@@ -1241,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) {
@@ -1459,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);
 };
 
@@ -1551,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 () => {
@@ -1560,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');
@@ -1598,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 () => {
@@ -1613,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');
@@ -1651,7 +1649,7 @@ const wrap = port => {
   };
 };
 
-const IpcParentWithRendererProcess = {
+const IpcParentWithSyntaxHighlightingWorker = {
   __proto__: null,
   create: create$b,
   wrap
@@ -1704,7 +1702,7 @@ const createRpc = method => {
 };
 
 const {
-  listen: listen$6,
+  listen: listen$4,
   invoke: invoke$2
 } = createRpc(ExtensionHostWorker);
 
@@ -2366,16 +2364,6 @@ const cancelSelection = editor => {
   return scheduleSelections(editor, newSelections);
 };
 
-// TODO use numeric widget id
-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) {
@@ -2390,6 +2378,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 = 8;
+
 const isMatchingWidget$2 = widget => {
   return widget.id === CodeGenerator;
 };
@@ -2621,7 +2618,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);
   }
@@ -2630,41 +2627,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
@@ -2675,14 +2672,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');
   }
 };
 
@@ -3820,9 +3817,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) => {
@@ -3839,6 +3833,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) {
@@ -3862,6 +3857,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 {
@@ -3870,7 +3869,7 @@ const handleSingleClickDefault = (editor, position) => {
     focused: true
   };
 };
-const getFn = modifier => {
+const getClickHandler = modifier => {
   switch (modifier) {
     case Alt$1:
       return handleSingleClickWithAlt;
@@ -3880,13 +3879,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:
@@ -5340,19 +5340,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');
@@ -5375,6 +5362,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([]);
@@ -5949,7 +5949,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;
   }
@@ -6238,6 +6238,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:
@@ -6449,23 +6466,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;
@@ -6477,6 +6477,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
  */
@@ -6537,19 +6550,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;
@@ -6669,12 +6669,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 = {
@@ -6728,7 +6722,7 @@ const getHover = async (editor, offset) => {
 };
 
 let _ipc;
-const listen$4 = async () => {
+const listen$2 = async () => {
   const ipc = await create$a({
     method: RendererProcess
   });
@@ -6949,6 +6943,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');
@@ -8142,13 +8142,28 @@ const SourceActionItem = 'SourceActionItem';
 const SourceActionItemFocused = 'SourceActionItemFocused';
 const Viewlet = 'Viewlet';
 
-const Button = 1;
-const Div = 4;
-const Input = 6;
-const Span = 8;
-const Text = 12;
-const Img = 17;
-const TextArea = 62;
+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 Button = 1;
+const Div = 4;
+const Input = 6;
+const Span = 8;
+const Text = 12;
+const Img = 17;
+const TextArea = 62;
 
 const text = data => {
   return {
@@ -8180,21 +8195,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,
@@ -8478,7 +8478,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}`);
   }
 };
 
@@ -8984,7 +8984,7 @@ const getText = editorUid => {
   const {
     lines
   } = editor;
-  return lines.join(NewLine$4);
+  return lines.join(NewLine$3);
 };
 
 const InsertText = 'insertText';
@@ -9020,15 +9020,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
@@ -10194,67 +10194,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;
 };
@@ -10279,126 +10218,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);
 };
@@ -10413,51 +10314,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) => {
@@ -10476,66 +10372,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 = '') {
@@ -10562,12 +10403,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
   };
@@ -10584,10 +10511,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');
@@ -10606,11 +10533,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);
@@ -10632,13 +10556,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 => {
@@ -10659,12 +10599,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;
 };
@@ -10675,7 +10617,7 @@ const listen = async () => {
     method: Auto()
   });
   handleIpc(ipc);
-  listen$7(ipc);
+  listen$5(ipc);
 };
 
 const addWidget = (widget, id, render) => {

package/package.json

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