@lvce-editor/main-area-worker 9.32.7 → 9.33.1

package/dist/mainAreaWorkerMain.js

@@ -1,249 +1,3 @@
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const create$f = () => {
-  const commandQueues = new Map();
-  const generations = Object.create(null);
-  const states = Object.create(null);
-  const commandMapRef = {};
-  const getGeneration = uid => generations[uid] || 0;
-  const isCurrentGeneration = (uid, generation) => {
-    return states[uid] !== undefined && getGeneration(uid) === generation;
-  };
-  const updateState = (uid, generation, fallbackState, updater) => {
-    if (!isCurrentGeneration(uid, generation)) {
-      return Promise.resolve(fallbackState);
-    }
-    const current = states[uid];
-    const updatedState = updater(current.newState);
-    if (updatedState !== current.newState) {
-      states[uid] = {
-        newState: updatedState,
-        oldState: current.oldState,
-        scheduledState: updatedState
-      };
-    }
-    return Promise.resolve(updatedState);
-  };
-  const createAsyncCommandContext = (uid, generation) => {
-    let latestState = states[uid].newState;
-    return {
-      getState: () => {
-        if (isCurrentGeneration(uid, generation)) {
-          latestState = states[uid].newState;
-        }
-        return latestState;
-      },
-      updateState: async updater => {
-        latestState = await updateState(uid, generation, latestState, updater);
-        return latestState;
-      }
-    };
-  };
-  const enqueueCommand = async (uid, command) => {
-    const previous = commandQueues.get(uid) || Promise.resolve();
-    const run = async () => {
-      try {
-        await previous;
-      } catch {
-        // The previous caller receives its error; later commands must still run.
-      }
-      await command();
-    };
-    const current = run();
-    commandQueues.set(uid, current);
-    try {
-      await current;
-    } finally {
-      if (commandQueues.get(uid) === current) {
-        commandQueues.delete(uid);
-      }
-    }
-  };
-  return {
-    clear() {
-      commandQueues.clear();
-      for (const key of Object.keys(states)) {
-        delete states[key];
-      }
-    },
-    diff(uid, modules, numbers) {
-      const {
-        oldState,
-        scheduledState
-      } = states[uid];
-      const diffResult = [];
-      for (let i = 0; i < modules.length; i++) {
-        const fn = modules[i];
-        if (!fn(oldState, scheduledState)) {
-          diffResult.push(numbers[i]);
-        }
-      }
-      return diffResult;
-    },
-    dispose(uid) {
-      commandQueues.delete(uid);
-      delete states[uid];
-    },
-    get(uid) {
-      return states[uid];
-    },
-    getCommandIds() {
-      const keys = Object.keys(commandMapRef);
-      const ids = keys.map(toCommandId);
-      return ids;
-    },
-    getKeys() {
-      return Object.keys(states).map(Number);
-    },
-    registerCommands(commandMap) {
-      Object.assign(commandMapRef, commandMap);
-    },
-    set(uid, oldState, newState, scheduledState) {
-      const current = states[uid];
-      if (!current || oldState === newState && newState !== current.newState) {
-        generations[uid] = getGeneration(uid) + 1;
-      }
-      states[uid] = {
-        newState,
-        oldState,
-        scheduledState: scheduledState ?? newState
-      };
-    },
-    wrapAsyncCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        const generation = getGeneration(uid);
-        const context = createAsyncCommandContext(uid, generation);
-        await fn(context, ...args);
-      };
-      return wrapped;
-    },
-    wrapCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        const generation = getGeneration(uid);
-        const {
-          newState,
-          oldState
-        } = states[uid];
-        const newerState = await fn(newState, ...args);
-        if (oldState === newerState || newState === newerState) {
-          return;
-        }
-        if (!isCurrentGeneration(uid, generation)) {
-          return;
-        }
-        const latestOld = states[uid];
-        const latestNew = {
-          ...latestOld.newState,
-          ...newerState
-        };
-        states[uid] = {
-          newState: latestNew,
-          oldState: latestOld.oldState,
-          scheduledState: latestNew
-        };
-      };
-      return wrapped;
-    },
-    wrapGetter(fn) {
-      const wrapped = (uid, ...args) => {
-        const {
-          newState
-        } = states[uid];
-        return fn(newState, ...args);
-      };
-      return wrapped;
-    },
-    wrapLoadContent(fn) {
-      const wrapped = async (uid, ...args) => {
-        const generation = getGeneration(uid);
-        const {
-          newState,
-          oldState
-        } = states[uid];
-        const result = await fn(newState, ...args);
-        const {
-          error,
-          state
-        } = result;
-        if (oldState === state || newState === state) {
-          return {
-            error
-          };
-        }
-        if (!isCurrentGeneration(uid, generation)) {
-          return {
-            error
-          };
-        }
-        const latestOld = states[uid];
-        const latestNew = {
-          ...latestOld.newState,
-          ...state
-        };
-        states[uid] = {
-          newState: latestNew,
-          oldState: latestOld.oldState,
-          scheduledState: latestNew
-        };
-        return {
-          error
-        };
-      };
-      return wrapped;
-    },
-    wrapSerialAsyncCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        await enqueueCommand(uid, async () => {
-          if (!states[uid]) {
-            return;
-          }
-          const generation = getGeneration(uid);
-          const context = createAsyncCommandContext(uid, generation);
-          await fn(context, ...args);
-        });
-      };
-      return wrapped;
-    },
-    wrapSerialCommand(fn) {
-      const wrapped = async (uid, ...args) => {
-        await enqueueCommand(uid, async () => {
-          if (!states[uid]) {
-            return;
-          }
-          const generation = getGeneration(uid);
-          const {
-            newState,
-            oldState
-          } = states[uid];
-          const newerState = await fn(newState, ...args);
-          if (oldState === newerState || newState === newerState) {
-            return;
-          }
-          if (!isCurrentGeneration(uid, generation)) {
-            return;
-          }
-          const latestOld = states[uid];
-          const latestNew = {
-            ...latestOld.newState,
-            ...newerState
-          };
-          states[uid] = {
-            newState: latestNew,
-            oldState: latestOld.oldState,
-            scheduledState: latestNew
-          };
-        });
-      };
-      return wrapped;
-    }
-  };
-};
-const terminate = () => {
-  globalThis.close();
-};
-
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
     return line.slice('Error: '.length);
@@ -1137,7 +891,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$e = (message, result) => {
+const create$f = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -1146,7 +900,7 @@ const create$e = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$e(message, resultProperty);
+  return create$f(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -1240,7 +994,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$d = (method, params) => {
+const create$e = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -1248,7 +1002,7 @@ const create$d = (method, params) => {
   };
 };
 
-const create$c = (id, method, params) => {
+const create$d = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -1259,12 +1013,12 @@ const create$c = (id, method, params) => {
 };
 
 let id$1 = 0;
-const create$b = () => {
+const create$c = () => {
   return ++id$1;
 };
 
 const registerPromise = map => {
-  const id = create$b();
+  const id = create$c();
   const {
     promise,
     resolve
@@ -1281,7 +1035,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$c(id, method, params);
+  const message = create$d(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -1317,7 +1071,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$d(method, params);
+      const message = create$e(method, params);
       ipc.send(message);
     }
   };
@@ -1357,7 +1111,7 @@ const listen$1 = async (module, options) => {
   return ipc;
 };
 
-const create$a = async ({
+const create$b = async ({
   commandMap,
   messagePort,
   requiresSocket
@@ -1375,7 +1129,7 @@ const create$a = async ({
   return rpc;
 };
 
-const create$9 = async ({
+const create$a = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -1393,7 +1147,7 @@ const create$9 = async ({
   return rpc;
 };
 
-const create$8 = async ({
+const create$9 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -1403,7 +1157,7 @@ const create$8 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$9({
+  return create$a({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
@@ -1438,7 +1192,7 @@ const createSharedLazyRpc = factory => {
   };
 };
 
-const create$7 = async ({
+const create$8 = async ({
   commandMap,
   getPortTuple,
   send
@@ -1448,20 +1202,20 @@ const create$7 = async ({
     port2
   } = await getPortTuple();
   await send(port1);
-  const rpc = create$a({
+  const rpc = create$b({
     commandMap,
     messagePort: port2
   });
   return rpc;
 };
 
-const create$6 = async ({
+const create$7 = async ({
   commandMap,
   getPortTuple,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$7({
+    return create$8({
       commandMap,
       getPortTuple,
       send
@@ -1469,13 +1223,13 @@ const create$6 = async ({
   });
 };
 
-const create$5 = async ({
+const create$6 = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$8({
+    return create$9({
       commandMap,
       isMessagePortOpen,
       send
@@ -1483,7 +1237,7 @@ const create$5 = async ({
   });
 };
 
-const create$4 = async ({
+const create$5 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1515,7 +1269,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$5 = (id, rpc) => {
+const set$6 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
@@ -1526,7 +1280,7 @@ const remove = id => {
 };
 
 /* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create$3 = rpcId => {
+const create$4 = rpcId => {
   return {
     async dispose() {
       const rpc = get$1(rpcId);
@@ -1548,7 +1302,7 @@ const create$3 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$5(rpcId, mockRpc);
+      set$6(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1557,7 +1311,7 @@ const create$3 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$5(rpcId, rpc);
+      set$6(rpcId, rpc);
     }
   };
 };
@@ -1739,6 +1493,7 @@ const VirtualDomElements = {
 const Button$1 = 'event.button';
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
+const DataTransferFiles2 = 'event.dataTransfer.files2';
 const EventTargetClassName = 'event.target.className';
 const TargetName = 'event.target.name';
 
@@ -1751,6 +1506,7 @@ const None$1 = 0;
 const Electron = 2;
 
 const ClipBoardWorker = 3400;
+const DialogWorker = 7014;
 const ExtensionHostWorker = 44;
 const IconThemeWorker = 7009;
 const RendererWorker = 1;
@@ -1762,17 +1518,22 @@ const SetPatches = 'Viewlet.setPatches';
 const FocusEditorText = 12;
 
 const {
+  set: set$5
+} = create$4(ClipBoardWorker);
+
+const {
+  invoke: invoke$2,
   set: set$4
-} = create$3(ClipBoardWorker);
+} = create$4(DialogWorker);
 
 const {
   set: set$3
-} = create$3(ExtensionHostWorker);
+} = create$4(ExtensionHostWorker);
 
 const {
   invoke: invoke$1,
   set: set$2
-} = create$3(IconThemeWorker);
+} = create$4(IconThemeWorker);
 const getIcons = async iconRequests => {
   // @ts-ignore
   return invoke$1('IconTheme.getIcons', iconRequests);
@@ -1782,7 +1543,7 @@ const {
   invoke,
   invokeAndTransfer,
   set: set$1
-} = create$3(RendererWorker);
+} = create$4(RendererWorker);
 const handleModifiedStatusChange$1 = async (uri, modified) => {
   return invoke('Main.handleModifiedStatusChange', uri, modified);
 };
@@ -1793,10 +1554,18 @@ const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(y);
   await invoke('ContextMenu.show2', uid, menuId, x, y, args);
 };
+const getFileHandles = async fileIds => {
+  const files = await invoke('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
 const sendMessagePortToClipBoardWorker$1 = async (port, rpcId) => {
   const command = 'ClipBoard.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToClipBoardWorker', port, command, rpcId);
 };
+const sendMessagePortToDialogWorker = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToDialogWorker', port, command);
+};
 const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
   const command = 'IconTheme.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
@@ -1808,12 +1577,258 @@ const sendMessagePortToExtensionHostWorker$1 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
 };
-const confirm = async (message, options) => {
+const confirm$1 = async (message, options) => {
   const result = await invoke('ConfirmPrompt.prompt', message, options);
   return result;
 };
-const writeClipBoardText = async text => {
-  await invoke('ClipBoard.writeText', /* text */text);
+const writeClipBoardText = async text => {
+  await invoke('ClipBoard.writeText', /* text */text);
+};
+
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$3 = () => {
+  const commandQueues = new Map();
+  const generations = Object.create(null);
+  const states = Object.create(null);
+  const commandMapRef = {};
+  const getGeneration = uid => generations[uid] || 0;
+  const isCurrentGeneration = (uid, generation) => {
+    return states[uid] !== undefined && getGeneration(uid) === generation;
+  };
+  const updateState = (uid, generation, fallbackState, updater) => {
+    if (!isCurrentGeneration(uid, generation)) {
+      return Promise.resolve(fallbackState);
+    }
+    const current = states[uid];
+    const updatedState = updater(current.newState);
+    if (updatedState !== current.newState) {
+      states[uid] = {
+        newState: updatedState,
+        oldState: current.oldState,
+        scheduledState: updatedState
+      };
+    }
+    return Promise.resolve(updatedState);
+  };
+  const createAsyncCommandContext = (uid, generation) => {
+    let latestState = states[uid].newState;
+    return {
+      getState: () => {
+        if (isCurrentGeneration(uid, generation)) {
+          latestState = states[uid].newState;
+        }
+        return latestState;
+      },
+      updateState: async updater => {
+        latestState = await updateState(uid, generation, latestState, updater);
+        return latestState;
+      }
+    };
+  };
+  const enqueueCommand = async (uid, command) => {
+    const previous = commandQueues.get(uid) || Promise.resolve();
+    const run = async () => {
+      try {
+        await previous;
+      } catch {
+        // The previous caller receives its error; later commands must still run.
+      }
+      await command();
+    };
+    const current = run();
+    commandQueues.set(uid, current);
+    try {
+      await current;
+    } finally {
+      if (commandQueues.get(uid) === current) {
+        commandQueues.delete(uid);
+      }
+    }
+  };
+  return {
+    clear() {
+      commandQueues.clear();
+      for (const key of Object.keys(states)) {
+        delete states[key];
+      }
+    },
+    diff(uid, modules, numbers) {
+      const {
+        oldState,
+        scheduledState
+      } = states[uid];
+      const diffResult = [];
+      for (let i = 0; i < modules.length; i++) {
+        const fn = modules[i];
+        if (!fn(oldState, scheduledState)) {
+          diffResult.push(numbers[i]);
+        }
+      }
+      return diffResult;
+    },
+    dispose(uid) {
+      commandQueues.delete(uid);
+      delete states[uid];
+    },
+    get(uid) {
+      return states[uid];
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    getKeys() {
+      return Object.keys(states).map(Number);
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
+    },
+    set(uid, oldState, newState, scheduledState) {
+      const current = states[uid];
+      if (!current || oldState === newState && newState !== current.newState) {
+        generations[uid] = getGeneration(uid) + 1;
+      }
+      states[uid] = {
+        newState,
+        oldState,
+        scheduledState: scheduledState ?? newState
+      };
+    },
+    wrapAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const context = createAsyncCommandContext(uid, generation);
+        await fn(context, ...args);
+      };
+      return wrapped;
+    },
+    wrapCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const newerState = await fn(newState, ...args);
+        if (oldState === newerState || newState === newerState) {
+          return;
+        }
+        if (!isCurrentGeneration(uid, generation)) {
+          return;
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...newerState
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState,
+          scheduledState: latestNew
+        };
+      };
+      return wrapped;
+    },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
+    wrapLoadContent(fn) {
+      const wrapped = async (uid, ...args) => {
+        const generation = getGeneration(uid);
+        const {
+          newState,
+          oldState
+        } = states[uid];
+        const result = await fn(newState, ...args);
+        const {
+          error,
+          state
+        } = result;
+        if (oldState === state || newState === state) {
+          return {
+            error
+          };
+        }
+        if (!isCurrentGeneration(uid, generation)) {
+          return {
+            error
+          };
+        }
+        const latestOld = states[uid];
+        const latestNew = {
+          ...latestOld.newState,
+          ...state
+        };
+        states[uid] = {
+          newState: latestNew,
+          oldState: latestOld.oldState,
+          scheduledState: latestNew
+        };
+        return {
+          error
+        };
+      };
+      return wrapped;
+    },
+    wrapSerialAsyncCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const context = createAsyncCommandContext(uid, generation);
+          await fn(context, ...args);
+        });
+      };
+      return wrapped;
+    },
+    wrapSerialCommand(fn) {
+      const wrapped = async (uid, ...args) => {
+        await enqueueCommand(uid, async () => {
+          if (!states[uid]) {
+            return;
+          }
+          const generation = getGeneration(uid);
+          const {
+            newState,
+            oldState
+          } = states[uid];
+          const newerState = await fn(newState, ...args);
+          if (oldState === newerState || newState === newerState) {
+            return;
+          }
+          if (!isCurrentGeneration(uid, generation)) {
+            return;
+          }
+          const latestOld = states[uid];
+          const latestNew = {
+            ...latestOld.newState,
+            ...newerState
+          };
+          states[uid] = {
+            newState: latestNew,
+            oldState: latestOld.oldState,
+            scheduledState: latestNew
+          };
+        });
+      };
+      return wrapped;
+    }
+  };
+};
+const terminate = () => {
+  globalThis.close();
 };
 
 const addClosedTabs = (state, entries) => {
@@ -2013,7 +2028,7 @@ const withActiveEditorChangeAsync = fn => {
   };
 };
 
-const registry = create$f();
+const registry = create$3();
 const {
   get,
   getCommandIds,
@@ -2360,6 +2375,17 @@ const saveEditor = async editorUid => {
   return invoke('Editor.save', editorUid);
 };
 
+const missingDialogWorkerRelay = 'Command "SendMessagePortToExtensionHostWorker.sendMessagePortToDialogWorker" not found';
+const confirm = async (message, options) => {
+  try {
+    return await invoke$2('ConfirmPrompt.prompt', message, options);
+  } catch (error) {
+    if (!String(error).includes(missingDialogWorkerRelay)) {
+      throw error;
+    }
+    return confirm$1(message, options);
+  }
+};
 const promptSave = async title => {
   const shouldSave = await confirm(`Do you want to save the changes you made to ${title}?`, {
     cancelMessage: 'More Options',
@@ -4060,11 +4086,14 @@ const updateIconCache = (iconCache, missingRequests, newIcons) => {
   return newFileIconCache;
 };
 
+const getUri = tab => {
+  return tab.uri || '';
+};
 const getFileIconsForTabs = async (tabs, fileIconCache) => {
   const missingRequests = getMissingIconRequestsForTabs(tabs, fileIconCache);
   const newIcons = await requestFileIcons(missingRequests);
   const newFileIconCache = updateIconCache(fileIconCache, missingRequests, newIcons);
-  const tabUris = tabs.map(tab => tab.uri || '');
+  const tabUris = tabs.map(getUri);
   const icons = getIconsCached(tabUris, newFileIconCache);
   return {
     icons,
@@ -4612,23 +4641,6 @@ const Down = 2;
 const Left = 3;
 const Right = 4;
 
-const getSplitDirection = (x, y, width, height) => {
-  const percentX = x / width;
-  if (percentX < 0.25) {
-    return Left;
-  }
-  if (percentX > 0.75) {
-    return Right;
-  }
-  const percentY = y / height;
-  if (percentY < 0.25) {
-    return Up;
-  }
-  if (percentY > 0.75) {
-    return Down;
-  }
-  return None;
-};
 const getOverlay = (x, y, width, height, splitDirection) => {
   const halfHeight = height / 2;
   const halfWidth = width / 2;
@@ -4670,6 +4682,25 @@ const getOverlay = (x, y, width, height, splitDirection) => {
       };
   }
 };
+
+const getSplitDirection = (x, y, width, height) => {
+  const percentX = x / width;
+  if (percentX < 0.25) {
+    return Left;
+  }
+  if (percentX > 0.75) {
+    return Right;
+  }
+  const percentY = y / height;
+  if (percentY < 0.25) {
+    return Up;
+  }
+  if (percentY > 0.75) {
+    return Down;
+  }
+  return None;
+};
+
 const getDragOverlay = (state, eventX, eventY) => {
   const {
     height,
@@ -4705,6 +4736,37 @@ const handleDragOver = (state, eventX, eventY) => {
   };
 };
 
+const lineSeparatorRegex = /\r?\n/;
+const isUriList = item => {
+  if (!item || typeof item !== 'object') {
+    return false;
+  }
+  const candidate = item;
+  return candidate.kind === 'string' && candidate.type === 'text/uri-list' && typeof candidate.value === 'string';
+};
+const parseUriList = value => {
+  return value.split(lineSeparatorRegex).map(uri => uri.trim()).filter(uri => uri && !uri.startsWith('#'));
+};
+const getDroppedUris = async itemIds => {
+  if (itemIds.length === 0) {
+    return [];
+  }
+  const items = await getFileHandles(itemIds);
+  return items.filter(isUriList).flatMap(item => parseUriList(item.value));
+};
+
+const openUrisWithContext = async (context, uris) => {
+  for (const uri of uris) {
+    await openUriWithContext(context, uri);
+  }
+};
+
+const handleDrop = async (context, itemIds) => {
+  await context.updateState(handleDragLeave);
+  const uris = await getDroppedUris(itemIds);
+  await openUrisWithContext(context, uris);
+};
+
 const EditorGroupHeader = 'EditorGroupHeader';
 const EmptyGroupHeader = 'EmptyGroupHeader';
 const EmptyGroupCloseButton = 'EmptyGroupCloseButton';
@@ -5648,7 +5710,7 @@ const sendMessagePortToExtensionHostWorker = async port => {
 
 const createExtensionHostRpc = async () => {
   try {
-    const rpc = await create$8({
+    const rpc = await create$9({
       commandMap: {},
       send: sendMessagePortToExtensionHostWorker
     });
@@ -6042,28 +6104,6 @@ const newWindow = async state => {
   return state;
 };
 
-const openUrisWithContext = async (context, uris) => {
-  if (uris.length === 0) {
-    return;
-  }
-  await openUriWithContext(context, uris[0]);
-  if (uris.length === 1) {
-    return;
-  }
-  let currentState = context.getState();
-  const firstTab = findTabByUri(currentState, uris[0]);
-  for (const uri of uris.slice(1)) {
-    const existingTab = findTabByUri(currentState, uri);
-    if (!existingTab) {
-      currentState = ensureActiveGroup(currentState, uri);
-    }
-  }
-  if (firstTab) {
-    currentState = switchTab(currentState, firstTab.groupId, firstTab.tab.id);
-  }
-  await context.updateState(() => currentState);
-};
-
 const refresh = state => {
   return {
     ...state
@@ -6334,14 +6374,11 @@ const compareNodes = (oldNode, newNode) => {
   }
   const patches = [];
   // Handle reference nodes - special handling for uid changes
-  if (oldNode.type === Reference) {
-    if (oldNode.uid !== newNode.uid) {
-      patches.push({
-        type: SetReferenceNodeUid,
-        uid: newNode.uid
-      });
-    }
-    return patches;
+  if (oldNode.type === Reference && oldNode.uid !== newNode.uid) {
+    patches.push({
+      type: SetReferenceNodeUid,
+      uid: newNode.uid
+    });
   }
   // Handle text nodes
   if (oldNode.type === Text && newNode.type === Text) {
@@ -6354,8 +6391,8 @@ const compareNodes = (oldNode, newNode) => {
     return patches;
   }
   // Compare attributes
-  const oldKeys = getKeys(oldNode);
-  const newKeys = getKeys(newNode);
+  const oldKeys = getKeys(oldNode).filter(key => oldNode.type !== Reference || key !== 'uid');
+  const newKeys = getKeys(newNode).filter(key => newNode.type !== Reference || key !== 'uid');
   // Check for attribute changes
   for (const key of newKeys) {
     if (oldNode[key] !== newNode[key]) {
@@ -6379,9 +6416,14 @@ const compareNodes = (oldNode, newNode) => {
 };
 
 const treeToArray = node => {
-  const result = [node.node];
-  for (const child of node.children) {
-    result.push(...treeToArray(child));
+  const result = [];
+  const stack = [node];
+  while (stack.length > 0) {
+    const current = stack.pop();
+    result.push(current.node);
+    for (let i = current.children.length - 1; i >= 0; i--) {
+      stack.push(current.children[i]);
+    }
   }
   return result;
 };
@@ -6493,17 +6535,14 @@ const diffTrees = (oldTree, newTree, patches, path) => {
 };
 
 const removeTrailingNavigationPatches = patches => {
-  // Find the last non-navigation patch
-  let lastNonNavigationIndex = -1;
-  for (let i = patches.length - 1; i >= 0; i--) {
-    const patch = patches[i];
+  while (patches.length > 0) {
+    const patch = patches.at(-1);
     if (patch.type !== NavigateChild && patch.type !== NavigateParent && patch.type !== NavigateSibling) {
-      lastNonNavigationIndex = i;
       break;
     }
+    patches.pop();
   }
-  // Return patches up to and including the last non-navigation patch
-  return lastNonNavigationIndex === -1 ? [] : patches.slice(0, lastNonNavigationIndex + 1);
+  return patches;
 };
 
 const diffTree = (oldNodes, newNodes) => {
@@ -6572,15 +6611,16 @@ const paragraphNode = {
   childCount: 1,
   type: P
 };
+const retryButtonNode = {
+  childCount: 1,
+  className: mergeClassNames(Button, ButtonSecondary),
+  'data-action': RetryOpen,
+  name: RetryOpen,
+  onClick: HandleClickAction,
+  type: Button$2
+};
 const renderError = errorMessage => {
-  return [textEditorErrorNode, editorContentErrorNode, paragraphNode, text(`Error: ${errorMessage}`), {
-    childCount: 1,
-    className: mergeClassNames(Button, ButtonSecondary),
-    'data-action': RetryOpen,
-    name: RetryOpen,
-    onClick: HandleClickAction,
-    type: Button$2
-  }, text(retry())];
+  return [textEditorErrorNode, editorContentErrorNode, paragraphNode, text(`Error: ${errorMessage}`), retryButtonNode, text(retry())];
 };
 
 const textEditorLoadingNode = {
@@ -7177,7 +7217,7 @@ const renderEventListeners = () => {
     params: ['handleDragLeave']
   }, {
     name: HandleDrop,
-    params: ['handleDragLeave'],
+    params: ['handleDrop', DataTransferFiles2],
     preventDefault: true
   }];
 };
@@ -7798,6 +7838,7 @@ const commandMap = {
   'MainArea.handleDoubleClick': wrapSerialCommand(handleDoubleClick),
   'MainArea.handleDragLeave': wrapSerialCommand(handleDragLeave),
   'MainArea.handleDragOver': wrapSerialCommand(handleDragOver),
+  'MainArea.handleDrop': wrapSerialAsyncCommand(handleDrop),
   'MainArea.handleHeaderDoubleClick': wrapSerialCommand(handleHeaderDoubleClick),
   'MainArea.handleIconThemeChange': wrapSerialCommand(handleIconThemeChange),
   'MainArea.handleModifiedStatusChange': wrapAsyncCommand(handleModifiedStatusChangeWithContext),
@@ -7851,11 +7892,11 @@ const sendMessagePortToClipBoardWorker = async port => {
 };
 
 const initializeClipBoardWorker = async () => {
-  const rpc = await create$6({
+  const rpc = await create$7({
     commandMap: {},
     send: sendMessagePortToClipBoardWorker
   });
-  set$4(rpc);
+  set$5(rpc);
 };
 
 const send = port => {
@@ -7863,7 +7904,7 @@ const send = port => {
 };
 const createIconThemeWorkerRpc = async () => {
   try {
-    const rpc = await create$5({
+    const rpc = await create$6({
       commandMap: {},
       send
     });
@@ -7892,7 +7933,7 @@ const initializeIconThemeWorker = async () => {
 };
 
 const initializeRendererWorker = async () => {
-  const rpc = await create$4({
+  const rpc = await create$5({
     commandMap: commandMap
   });
   set$1(rpc);
@@ -7901,6 +7942,11 @@ const initializeRendererWorker = async () => {
 const listen = async () => {
   registerCommands(commandMap);
   await Promise.all([initializeRendererWorker(), initializeIconThemeWorker(), initializeClipBoardWorker()]);
+  const dialogRpc = await create$6({
+    commandMap: {},
+    send: sendMessagePortToDialogWorker
+  });
+  set$4(dialogRpc);
 };
 
 const main$1 = async () => {
@@ -7909,7 +7955,7 @@ const main$1 = async () => {
 
 const main = async () => {
   registerCommands(commandMap);
-  const rpc = await create$4({
+  const rpc = await create$5({
     commandMap: commandMap
   });
   set$1(rpc);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/main-area-worker",
-  "version": "9.32.7",
+  "version": "9.33.1",
   "description": "Main Area Worker",
   "repository": {
     "type": "git",