@lvce-editor/editor-worker 5.7.0 → 5.9.0

package/dist/editorWorkerMain.js

@@ -1,11 +1,6 @@
 const commands = Object.create(null);
-const registerCommand = (key, fn) => {
-  commands[key] = fn;
-};
 const register = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
+  Object.assign(commands, commandMap);
 };
 const getCommand = key => {
   return commands[key];
@@ -23,13 +18,13 @@ const codeGeneratorAccept = state => {
   return state;
 };
 
-let AssertionError$1 = class AssertionError extends Error {
+class AssertionError extends Error {
   constructor(message) {
     super(message);
     this.name = 'AssertionError';
   }
-};
-const getType$1 = value => {
+}
+const getType = value => {
   switch (typeof value) {
     case 'number':
       return 'number';
@@ -52,40 +47,40 @@ const getType$1 = value => {
   }
 };
 const object = value => {
-  const type = getType$1(value);
+  const type = getType(value);
   if (type !== 'object') {
-    throw new AssertionError$1('expected value to be of type object');
+    throw new AssertionError('expected value to be of type object');
   }
 };
-const number$1 = value => {
-  const type = getType$1(value);
+const number = value => {
+  const type = getType(value);
   if (type !== 'number') {
-    throw new AssertionError$1('expected value to be of type number');
+    throw new AssertionError('expected value to be of type number');
   }
 };
 const array = value => {
-  const type = getType$1(value);
+  const type = getType(value);
   if (type !== 'array') {
-    throw new AssertionError$1('expected value to be of type array');
+    throw new AssertionError('expected value to be of type array');
   }
 };
 const string = value => {
-  const type = getType$1(value);
+  const type = getType(value);
   if (type !== 'string') {
-    throw new AssertionError$1('expected value to be of type string');
+    throw new AssertionError('expected value to be of type string');
   }
 };
 const boolean = value => {
-  const type = getType$1(value);
+  const type = getType(value);
   if (type !== 'boolean') {
-    throw new AssertionError$1('expected value to be of type boolean');
+    throw new AssertionError('expected value to be of type boolean');
   }
 };
 
 const clamp = (num, min, max) => {
-  number$1(num);
-  number$1(min);
-  number$1(max);
+  number(num);
+  number(min);
+  number(max);
   return Math.min(Math.max(num, min), max);
 };
 
@@ -304,10 +299,10 @@ const applyEdits = (textDocument, changes) => {
     const endColumnIndex = change.end.columnIndex;
     const inserted = change.inserted;
     const deleted = change.deleted;
-    number$1(startRowIndex);
-    number$1(endRowIndex);
-    number$1(startColumnIndex);
-    number$1(endColumnIndex);
+    number(startRowIndex);
+    number(endRowIndex);
+    number(startColumnIndex);
+    number(endColumnIndex);
     array(inserted);
     array(deleted);
     if (startRowIndex === endRowIndex) {
@@ -377,8 +372,8 @@ const getSelectionText = (textDocument, range) => {
 };
 const offsetAtSync = async (textDocument, positionRowIndex, positionColumnIndex) => {
   object(textDocument);
-  number$1(positionRowIndex);
-  number$1(positionColumnIndex);
+  number(positionRowIndex);
+  number(positionColumnIndex);
   let offset = 0;
   let rowIndex = 0;
   const lines = textDocument.lines;
@@ -392,8 +387,8 @@ const offsetAtSync = async (textDocument, positionRowIndex, positionColumnIndex)
 };
 const offsetAt = (textDocument, positionRowIndex, positionColumnIndex) => {
   object(textDocument);
-  number$1(positionRowIndex);
-  number$1(positionColumnIndex);
+  number(positionRowIndex);
+  number(positionColumnIndex);
   let offset = 0;
   let rowIndex = 0;
   const lines = textDocument.lines;
@@ -432,7 +427,7 @@ const positionAt = (textDocument, offset) => {
 // TODO this should be in a separate scrolling module
 const setDeltaY$3 = (state, value) => {
   object(state);
-  number$1(value);
+  number(value);
   const {
     finalDeltaY,
     deltaY,
@@ -525,11 +520,11 @@ const getContext = () => {
 
 const measureTextWidthSlow = (text, fontWeight, fontSize, fontFamily, letterSpacing, isMonoSpaceFont, charWidth) => {
   string(text);
-  number$1(fontWeight);
-  number$1(fontSize);
+  number(fontWeight);
+  number(fontSize);
   string(fontFamily);
   boolean(isMonoSpaceFont);
-  number$1(charWidth);
+  number(charWidth);
   if (typeof letterSpacing !== 'number') {
     throw new TypeError('letterSpacing must be of type number');
   }
@@ -565,12 +560,12 @@ const getX = (line, column, fontWeight, fontSize, fontFamily, isMonospaceFont, l
     return 0;
   }
   string(line);
-  number$1(tabSize);
-  number$1(halfCursorWidth);
-  number$1(width);
+  number(tabSize);
+  number(halfCursorWidth);
+  number(width);
   boolean(isMonospaceFont);
-  number$1(averageCharWidth);
-  number$1(difference);
+  number(averageCharWidth);
+  number(difference);
   if (column === 0) {
     return 0;
   }
@@ -1037,11 +1032,11 @@ const setText = (editor, text) => {
 
 const editors = Object.create(null);
 const get$6 = id => {
-  number$1(id);
+  number(id);
   return editors[id];
 };
 const set$6 = (id, oldEditor, newEditor) => {
-  number$1(id);
+  number(id);
   object(oldEditor);
   object(newEditor);
   editors[id] = {
@@ -1058,57 +1053,21 @@ const TabCompletionExecuteTabCompletionProvider = 'ExtensionHost.executeTabCompl
 const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
 
 const Two = '2.0';
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const state$1$1 = {
+const state$9 = {
   callbacks: Object.create(null)
 };
 const set$5 = (id, fn) => {
-  state$1$1.callbacks[id] = fn;
+  state$9.callbacks[id] = fn;
 };
 const get$5 = id => {
-  return state$1$1.callbacks[id];
+  return state$9.callbacks[id];
 };
 const remove$8 = id => {
-  delete state$1$1.callbacks[id];
-};
-const state$9 = {
-  id: 0
+  delete state$9.callbacks[id];
 };
+let id = 0;
 const create$3$1 = () => {
-  return ++state$9.id;
+  return ++id;
 };
 const warn$1 = (...args) => {
   console.warn(...args);
@@ -1125,15 +1084,14 @@ const registerPromise = () => {
     promise
   };
 };
-const resolve = (id, args) => {
-  number(id);
+const resolve = (id, response) => {
   const fn = get$5(id);
   if (!fn) {
-    console.log(args);
+    console.log(response);
     warn$1(`callback ${id} may already be disposed`);
     return;
   }
-  fn(args);
+  fn(response);
   remove$8(id);
 };
 const create$2$1 = (method, params) => {
@@ -1355,32 +1313,42 @@ const defaultRequiresSocket = () => {
   return false;
 };
 const defaultResolve = resolve;
-const handleJsonRpcMessage = async (...args) => {
-  let message;
-  let ipc;
-  let execute;
-  let preparePrettyError;
-  let logError;
-  let resolve;
-  let requiresSocket;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
   if (args.length === 1) {
-    const arg = args[0];
-    message = arg.message;
-    ipc = arg.ipc;
-    execute = arg.execute;
-    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
-    logError = arg.logError || defaultLogError;
-    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
-    resolve = arg.resolve || defaultResolve;
-  } else {
-    ipc = args[0];
-    message = args[1];
-    execute = args[2];
-    resolve = args[3];
-    preparePrettyError = args[4];
-    logError = args[5];
-    requiresSocket = args[6];
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
   }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
   if ('id' in message) {
     if ('method' in message) {
       const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
@@ -1401,25 +1369,24 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const invoke$5 = async (ipc, method, ...params) => {
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
   } = create$2$1(method, params);
-  ipc.send(message);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
   const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+  return unwrapJsonRpcResult(responseMessage);
 };
-const invokeAndTransfer$2 = async (ipc, method, ...params) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  ipc.sendAndTransfer(message);
-  const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+const invoke$5 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
+};
+const invokeAndTransfer$2 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
 };
 
 const requiresSocket = () => {
@@ -1492,7 +1459,7 @@ const invokeAndTransfer$1 = async (method, ...params) => {
   const ipc = get$4();
   return invokeAndTransfer$2(ipc, method, ...params);
 };
-const listen$8 = ipc => {
+const listen$7 = ipc => {
   set$4(ipc);
 };
 
@@ -1547,7 +1514,7 @@ const create$d = async () => {
   }
   return port2;
 };
-const wrap$3 = port => {
+const wrap$2 = port => {
   return {
     port,
     /**
@@ -1581,7 +1548,7 @@ const wrap$3 = port => {
 const IpcParentWithExtensionHostWorker = {
   __proto__: null,
   create: create$d,
-  wrap: wrap$3
+  wrap: wrap$2
 };
 
 const sendMessagePortToSyntaxHighlightingWorker = async port => {
@@ -1737,7 +1704,7 @@ const createRpc = method => {
 };
 
 const {
-  listen: listen$7,
+  listen: listen$6,
   invoke: invoke$2
 } = createRpc(ExtensionHostWorker);
 
@@ -1933,7 +1900,7 @@ const createEditor = async ({
   uri,
   diagnosticsEnabled
 }) => {
-  number$1(id);
+  number(id);
   string(content);
   const charWidth = measureCharacterWidth(fontWeight, fontSize, fontFamily, letterSpacing);
   const editor = {
@@ -2208,14 +2175,14 @@ const normalizeGuess = (line, guess, tabSize) => {
 // @ts-ignore
 const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSpacing, isMonospaceFont, charWidth, tabSize, eventX) => {
   string(line);
-  number$1(fontWeight);
-  number$1(fontSize);
+  number(fontWeight);
+  number(fontSize);
   string(fontFamily);
-  number$1(letterSpacing);
+  number(letterSpacing);
   boolean(isMonospaceFont);
-  number$1(charWidth);
-  number$1(tabSize);
-  number$1(eventX);
+  number(charWidth);
+  number(tabSize);
+  number(eventX);
   // Assert.greaterZero(charWidth)
   const guess = guessOffset(eventX, charWidth);
   const normalize = shouldNormalizeText(line);
@@ -2235,8 +2202,8 @@ const getAccurateColumnIndex = (line, fontWeight, fontSize, fontFamily, letterSp
 
 const at = (editor, eventX, eventY) => {
   object(editor);
-  number$1(eventX);
-  number$1(eventY);
+  number(eventX);
+  number(eventY);
   const {
     y,
     deltaY,
@@ -2309,8 +2276,8 @@ const state$7 = {
 // @ts-ignore
 const editorShowMessage = async (editor, rowIndex, columnIndex, message, isError) => {
   object(editor);
-  number$1(rowIndex);
-  number$1(columnIndex);
+  number(rowIndex);
+  number(columnIndex);
   string(message);
   const x$1 = x(editor, rowIndex, columnIndex);
   const y$1 = y(editor, rowIndex);
@@ -2656,10 +2623,10 @@ const compositionEnd = (editor, data) => {
 
 const normalizeLine$1 = line => {
   if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
+    return line.slice('Error: '.length);
   }
   if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
+    return line.slice('VError: '.length);
   }
   return line;
 };
@@ -2782,7 +2749,7 @@ const copyLineDown = editor => {
     selections
   } = editor;
   const rowIndex = selections[0];
-  number$1(rowIndex);
+  number(rowIndex);
   const position = {
     rowIndex,
     columnIndex: 0
@@ -3088,8 +3055,8 @@ const cursorHome = editor => {
 
 const cursorSet = (editor, rowIndex, columnIndex) => {
   object(editor);
-  number$1(rowIndex);
-  number$1(columnIndex);
+  number(rowIndex);
+  number(columnIndex);
   const selectionEdits = fromRange(rowIndex, columnIndex, rowIndex, columnIndex);
   return scheduleSelections(editor, selectionEdits);
 };
@@ -3815,9 +3782,9 @@ const getFn = modifier => {
 };
 const handleSingleClick = async (editor, modifier, x, y) => {
   object(editor);
-  number$1(modifier);
-  number$1(x);
-  number$1(y);
+  number(modifier);
+  number(x);
+  number(y);
   const position = at(editor, x, y);
   const fn = getFn(modifier);
   const newEditor = await fn(editor, position);
@@ -3856,8 +3823,8 @@ const selectLine = editor => {
 // @ts-ignore
 const handleTripleClick = (editor, modifier, x, y) => {
   object(editor);
-  number$1(x);
-  number$1(y);
+  number(x);
+  number(y);
   return {
     newState: selectLine(editor),
     commands: []
@@ -3948,8 +3915,8 @@ const getTokenIndex = (tokens, offset) => {
 // @ts-ignore
 const handleMouseMoveWithAltKey = async (editor, x, y) => {
   object(editor);
-  number$1(x);
-  number$1(y);
+  number(x);
+  number(y);
   const position = at(editor, x, y);
   const documentOffset = offsetAt(editor, position.rowIndex, position.columnIndex);
   try {
@@ -4287,9 +4254,9 @@ const setDeltaYFixedValue = (editor, deltaY) => {
 
 // @ts-ignore
 const setDelta = (editor, deltaMode, eventDeltaX, eventDeltaY) => {
-  number$1(deltaMode);
-  number$1(eventDeltaX);
-  number$1(eventDeltaY);
+  number(deltaMode);
+  number(eventDeltaX);
+  number(eventDeltaY);
   // @ts-ignore
   const {
     deltaX,
@@ -4648,8 +4615,8 @@ const continueScrollingAndMovingSelection = async () => {
 // @ts-ignore
 const moveSelectionPx = (editor, x, y) => {
   object(editor);
-  number$1(x);
-  number$1(y);
+  number(x);
+  number(y);
   const position = at(editor, x, y);
   if (!hasListener() && (position.rowIndex < editor.minLineY || position.rowIndex > editor.maxLineY)) {
     requestAnimationFrame(continueScrollingAndMovingSelection);
@@ -5023,9 +4990,9 @@ const getFinalDeltaY = (height, itemHeight, itemsLength) => {
 };
 
 const getListHeight = (itemsLength, itemHeight, maxHeight) => {
-  number$1(itemsLength);
-  number$1(itemHeight);
-  number$1(maxHeight);
+  number(itemsLength);
+  number(itemHeight);
+  number(maxHeight);
   if (itemsLength === 0) {
     return itemHeight;
   }
@@ -6479,7 +6446,7 @@ const getEnabled$1 = () => {
 };
 
 const {
-  listen: listen$6,
+  listen: listen$5,
   invoke: invoke$1
 } = createRpc(SyntaxHighlightingWorker);
 
@@ -6642,7 +6609,7 @@ const create$2 = () => {
 
 const executeHoverProvider = async (editor, offset) => {
   object(editor);
-  number$1(offset);
+  number(offset);
   return execute({
     event: OnHover,
     editor,
@@ -6654,14 +6621,14 @@ const executeHoverProvider = async (editor, offset) => {
 
 const getHover = async (editor, offset) => {
   object(editor);
-  number$1(offset);
+  number(offset);
   // TODO invoke extension host worker directly
   const hover = await executeHoverProvider(editor, offset);
   return hover;
 };
 
 let _ipc;
-const listen$5 = async () => {
+const listen$4 = async () => {
   const ipc = await create$a({
     method: RendererProcess
   });
@@ -6810,7 +6777,7 @@ const getHoverPositionXy = (editor, rowIndex, wordStart, documentationHeight) =>
   };
 };
 const getEditorHoverInfo = async (editorUid, position) => {
-  number$1(editorUid);
+  number(editorUid);
   const instance = get$6(editorUid);
   const editor = instance.newState;
   const {
@@ -7802,7 +7769,7 @@ const getNumberOfVisibleItems = (listHeight, itemHeight) => {
 
 const setDeltaY = (state, value) => {
   object(state);
-  number$1(value);
+  number(value);
   const {
     itemHeight,
     finalDeltaY,
@@ -7827,8 +7794,8 @@ const setDeltaY = (state, value) => {
 };
 
 const handleWheel = (state, deltaMode, deltaY) => {
-  number$1(deltaMode);
-  number$1(deltaY);
+  number(deltaMode);
+  number(deltaY);
   return setDeltaY(state, state.deltaY + deltaY);
 };
 
@@ -8480,15 +8447,15 @@ const getEnabled = () => {
 };
 
 const intialize = async (syntaxHighlightingEnabled, syncIncremental) => {
-  await listen$5();
+  await listen$4();
   if (syntaxHighlightingEnabled) {
     setEnabled$1(true);
-    await listen$6();
+    await listen$5();
   }
   if (syncIncremental) {
     setEnabled(true);
   }
-  await listen$7();
+  await listen$6();
 };
 
 // TODO move cursor
@@ -9671,6 +9638,27 @@ const Auto = () => {
 const getData$1 = event => {
   return event.data;
 };
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const readyMessage = 'ready';
 const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
@@ -9721,35 +9709,56 @@ const getTransferrables = value => {
   walkValue(value, transferrables, isTransferrable);
   return transferrables;
 };
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
-  };
-  that.onClose(handleClose);
+const listen$3 = ({
+  port
+}) => {
+  return port;
 };
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents(this);
+const signal$3 = port => {
+  port.postMessage(readyMessage);
+};
+class IpcChildWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
   }
 }
-const readyMessage = 'ready';
-const listen$4 = () => {
+const wrap$6 = port => {
+  return new IpcChildWithMessagePort(port);
+};
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$3,
+  signal: signal$3,
+  wrap: wrap$6
+};
+const listen$2 = () => {
   // @ts-ignore
   if (typeof WorkerGlobalScope === 'undefined') {
     throw new TypeError('module is not in web worker scope');
   }
   return globalThis;
 };
-const signal$3 = global => {
+const signal$2 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithModuleWorker extends Ipc {
@@ -9775,14 +9784,14 @@ class IpcChildWithModuleWorker extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 }
-const wrap$6 = global => {
+const wrap$5 = global => {
   return new IpcChildWithModuleWorker(global);
 };
 const IpcChildWithModuleWorker$1 = {
   __proto__: null,
-  listen: listen$4,
-  signal: signal$3,
-  wrap: wrap$6
+  listen: listen$2,
+  signal: signal$2,
+  wrap: wrap$5
 };
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
@@ -9899,10 +9908,10 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
 };
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
+    return line.slice('Error: '.length);
   }
   if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
+    return line.slice('VError: '.length);
   }
   return line;
 };
@@ -10000,10 +10009,10 @@ const waitForFirstMessage = async port => {
   // @ts-ignore
   return event.data;
 };
-const listen$3 = async () => {
-  const parentIpcRaw = listen$4();
-  signal$3(parentIpcRaw);
-  const parentIpc = wrap$6(parentIpcRaw);
+const listen$1$1 = async () => {
+  const parentIpcRaw = listen$2();
+  signal$2(parentIpcRaw);
+  const parentIpc = wrap$5(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError('unexpected first message');
@@ -10048,55 +10057,13 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$5 = port => {
+const wrap$4 = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
-  listen: listen$3,
-  wrap: wrap$5
-};
-const listen$2 = ({
-  port
-}) => {
-  return port;
-};
-const signal = port => {
-  port.postMessage(readyMessage);
-};
-class IpcChildWithMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$2 = port => {
-  return new IpcChildWithMessagePort(port);
-};
-const IpcChildWithMessagePort$1 = {
-  __proto__: null,
-  listen: listen$2,
-  signal,
-  wrap: wrap$2
+  listen: listen$1$1,
+  wrap: wrap$4
 };
 
 const getModule = method => {
@@ -10133,7 +10100,7 @@ const listen = async () => {
     method: Auto()
   });
   handleIpc(ipc);
-  listen$8(ipc);
+  listen$7(ipc);
 };
 
 const addWidget = (widget, id, render) => {

package/package.json

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