@lvce-editor/explorer-view 7.21.1 → 7.21.3

package/dist/explorerViewWorkerMain.js

@@ -1,249 +1,3 @@
-const toCommandId = key => {
-  const dotIndex = key.indexOf('.');
-  return key.slice(dotIndex + 1);
-};
-const create$a = () => {
-  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);
@@ -300,12 +54,6 @@ class VError extends Error {
   }
 }
 
-const CreateFolder$1 = 1;
-const CreateFile$1 = 2;
-const Copy$1 = 3;
-const Rename$2 = 4;
-const Remove = 5;
-
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -997,7 +745,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$9 = (message, result) => {
+const create$a = (message, result) => {
   return {
     id: message.id,
     jsonrpc: Two$1,
@@ -1006,7 +754,7 @@ const create$9 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$9(message, resultProperty);
+  return create$a(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
@@ -1100,7 +848,7 @@ const handleJsonRpcMessage = async (...args) => {
 
 const Two = '2.0';
 
-const create$8 = (method, params) => {
+const create$9 = (method, params) => {
   return {
     jsonrpc: Two,
     method,
@@ -1108,7 +856,7 @@ const create$8 = (method, params) => {
   };
 };
 
-const create$7 = (id, method, params) => {
+const create$8 = (id, method, params) => {
   const message = {
     id,
     jsonrpc: Two,
@@ -1119,12 +867,12 @@ const create$7 = (id, method, params) => {
 };
 
 let id = 0;
-const create$6 = () => {
+const create$7 = () => {
   return ++id;
 };
 
 const registerPromise = map => {
-  const id = create$6();
+  const id = create$7();
   const {
     promise,
     resolve
@@ -1141,7 +889,7 @@ const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer)
     id,
     promise
   } = registerPromise(callbacks);
-  const message = create$7(id, method, params);
+  const message = create$8(id, method, params);
   if (useSendAndTransfer && ipc.sendAndTransfer) {
     ipc.sendAndTransfer(message);
   } else {
@@ -1177,7 +925,7 @@ const createRpc = ipc => {
      * @deprecated
      */
     send(method, ...params) {
-      const message = create$8(method, params);
+      const message = create$9(method, params);
       ipc.send(message);
     }
   };
@@ -1245,7 +993,7 @@ const createSharedLazyRpc = factory => {
   };
 };
 
-const create$5 = async ({
+const create$6 = async ({
   commandMap,
   isMessagePortOpen = true,
   messagePort
@@ -1263,7 +1011,7 @@ const create$5 = async ({
   return rpc;
 };
 
-const create$4 = async ({
+const create$5 = async ({
   commandMap,
   isMessagePortOpen,
   send
@@ -1273,20 +1021,20 @@ const create$4 = async ({
     port2
   } = new MessageChannel();
   await send(port1);
-  return create$5({
+  return create$6({
     commandMap,
     isMessagePortOpen,
     messagePort: port2
   });
 };
 
-const create$3 = async ({
+const create$4 = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$4({
+    return create$5({
       commandMap,
       isMessagePortOpen,
       send
@@ -1294,7 +1042,7 @@ const create$3 = async ({
   });
 };
 
-const create$2 = async ({
+const create$3 = async ({
   commandMap
 }) => {
   // TODO create a commandMap per rpc instance
@@ -1326,7 +1074,7 @@ const createMockRpc = ({
 };
 
 const rpcs = Object.create(null);
-const set$7 = (id, rpc) => {
+const set$9 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get$1 = id => {
@@ -1337,7 +1085,7 @@ const remove$1 = id => {
 };
 
 /* eslint-disable  @typescript-eslint/explicit-function-return-type */
-const create$1 = rpcId => {
+const create$2 = rpcId => {
   return {
     async dispose() {
       const rpc = get$1(rpcId);
@@ -1359,7 +1107,7 @@ const create$1 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$7(rpcId, mockRpc);
+      set$9(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove$1(rpcId);
@@ -1368,7 +1116,7 @@ const create$1 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$7(rpcId, rpc);
+      set$9(rpcId, rpc);
     }
   };
 };
@@ -1546,7 +1294,6 @@ const Button$3 = 'event.button';
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
 const CtrlKey = 'event.ctrlKey';
-const DataTransferFiles = 'event.dataTransfer.files';
 const DataTransferFiles2 = 'event.dataTransfer.files2';
 const DefaultPrevented = 'event.defaultPrevented';
 const DeltaMode = 'event.deltaMode';
@@ -1570,7 +1317,6 @@ const DownArrow = 16;
 const Delete$1 = 18;
 const KeyA = 29;
 const KeyC = 31;
-const KeyV = 50;
 const KeyX = 52;
 const F2 = 58;
 const Star = 131;
@@ -1579,6 +1325,8 @@ const CtrlCmd = 1 << 11 >>> 0;
 const Shift = 1 << 10 >>> 0;
 const Alt = 1 << 9 >>> 0;
 
+const DialogWorker = 7014;
+const DragAndDropWorker = 3404;
 const FileSystemWorker$1 = 209;
 const IconThemeWorker = 7009;
 const RendererWorker = 1;
@@ -1594,9 +1342,22 @@ const SetPatches = 'Viewlet.setPatches';
 const FocusExplorer = 13;
 const FocusExplorerEditBox = 14;
 
+const {
+  invoke: invoke$5,
+  set: set$8
+} = create$2(DialogWorker);
+
+const {
+  invoke: invoke$4,
+  set: set$7
+} = create$2(DragAndDropWorker);
+const getDroppedItems$1 = async (itemIds, isElectron) => {
+  return invoke$4('DragAndDrop.getDroppedItems', itemIds, isElectron);
+};
+
 const {
   set: set$6
-} = create$1(FileSystemWorker$1);
+} = create$2(FileSystemWorker$1);
 
 const FileSystemWorker = {
   __proto__: null,
@@ -1606,7 +1367,7 @@ const FileSystemWorker = {
 const {
   invoke: invoke$3,
   set: set$5
-} = create$1(IconThemeWorker);
+} = create$2(IconThemeWorker);
 const getIcons = async iconRequests => {
   // @ts-ignore
   return invoke$3('IconTheme.getIcons', iconRequests);
@@ -1677,7 +1438,7 @@ const {
   invoke: invoke$2,
   invokeAndTransfer,
   set: set$4
-} = create$1(RendererWorker);
+} = create$2(RendererWorker);
 const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(uid);
   number(menuId);
@@ -1685,9 +1446,13 @@ const showContextMenu2 = async (uid, menuId, x, y, args) => {
   number(y);
   await invoke$2('ContextMenu.show2', uid, menuId, x, y, args);
 };
-const getFileHandles$1 = async fileIds => {
-  const files = await invoke$2('FileSystemHandle.getFileHandles', fileIds);
-  return files;
+const sendMessagePortToDragAndDropWorker = async port => {
+  const command = 'DragAndDrop.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToDragAndDropWorker', port, command);
+};
+const sendMessagePortToDialogWorker = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToDialogWorker', port, command);
 };
 const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
   const command = 'IconTheme.handleMessagePort';
@@ -1697,7 +1462,7 @@ const sendMessagePortToFileSystemWorker$1 = async (port, rpcId) => {
   const command = 'FileSystem.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
-const confirm = async (message, options) => {
+const confirm$1 = async (message, options) => {
   const result = await invoke$2('ConfirmPrompt.prompt', message, options);
   return result;
 };
@@ -1708,18 +1473,270 @@ const sendMessagePortToSourceControlWorker = async port => {
   const command = 'SourceControl.handleMessagePort';
   await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToSourceControlWorker', port, command, 0);
 };
-const openUri$1 = async (uri, focus, options) => {
-  await invoke$2('Main.openUri', {
-    ...options,
-    focus,
-    uri
-  });
+const openUri$1 = async (uri, focus, options) => {
+  await invoke$2('Main.openUri', {
+    ...options,
+    focus,
+    uri
+  });
+};
+
+const {
+  invoke: invoke$1,
+  set: set$3
+} = create$2(SourceControlWorker);
+
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
+const create$1 = () => {
+  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 {
-  invoke: invoke$1,
-  set: set$3
-} = create$1(SourceControlWorker);
+const CreateFolder$1 = 1;
+const CreateFile$1 = 2;
+const Copy$1 = 3;
+const Rename$2 = 4;
+const Remove = 5;
 
 // TODO use direct connection
 const invoke = async (method, ...params) => {
@@ -1818,7 +1835,7 @@ const dirname = (pathSeparator, path) => {
 const dirname2 = path => {
   return dirname('/', path);
 };
-const join = (pathSeparator, ...parts) => {
+const join$1 = (pathSeparator, ...parts) => {
   return parts.join(pathSeparator);
 };
 const getBaseName = (pathSeparator, path) => {
@@ -1862,11 +1879,12 @@ const createTree = (items, root) => {
   return tree;
 };
 
-const None$5 = 0;
+const None$6 = 0;
 const CreateFile = 1;
 const CreateFolder = 2;
 const Rename$1 = 3;
 
+const None$5 = 0;
 const List = 1;
 const Input$1 = 2;
 
@@ -2319,6 +2337,7 @@ const i18nString = (key, placeholders = emptyObject) => {
 };
 
 const CollapseAllFoldersInExplorer = 'Collapse All Folders in Explorer';
+const CannotMoveFolderIntoSubfolderOfItself = 'Cannot move folder {PH1} into a subfolder of itself';
 const Copy = 'Copy';
 const CopyPath = 'Copy Path';
 const CopyRelativePath = 'Copy Relative Path';
@@ -2422,6 +2441,11 @@ const fileOrFolderAlreadyExists = name => {
     PH1: name
   });
 };
+const cannotMoveFolderIntoSubfolderOfItself = folderName => {
+  return i18nString(CannotMoveFolderIntoSubfolderOfItself, {
+    PH1: folderName
+  });
+};
 const theNameIsNotValid = () => {
   return i18nString(TheNameIsNotValid);
 };
@@ -2498,7 +2522,7 @@ const acceptCreate = async (state, newDirentType) => {
   return {
     ...state,
     editingIndex: -1,
-    editingType: None$5,
+    editingType: None$6,
     focus: List,
     focusedIndex: newFocusedIndex,
     items: dirents
@@ -2548,7 +2572,7 @@ const cancelEditRename = (state, keepFocus) => {
     editingIndex: -1,
     editingSelectionEnd: 0,
     editingSelectionStart: 0,
-    editingType: None$5,
+    editingType: None$6,
     editingValue: '',
     focus: List,
     focused: keepFocus,
@@ -2667,7 +2691,7 @@ const acceptRename = async state => {
     editingIndex: -1,
     editingSelectionEnd: 0,
     editingSelectionStart: 0,
-    editingType: None$5,
+    editingType: None$6,
     editingValue: '',
     focus: List,
     focused: true,
@@ -2722,7 +2746,7 @@ const cancelEditCreate = async (state, keepFocus) => {
     ...state,
     editingErrorMessage: '',
     editingIndex: -1,
-    editingType: None$5,
+    editingType: None$6,
     editingValue: '',
     focus: List,
     focused: keepFocus,
@@ -2867,6 +2891,30 @@ const copyRelativePath = async state => {
   return state;
 };
 
+const missingDialogWorkerRelay = 'Command "SendMessagePortToExtensionHostWorker.sendMessagePortToDialogWorker" not found';
+const state = {
+  isTest: false
+};
+const setIsTest = value => {
+  state.isTest = value;
+};
+const confirm = async message => {
+  const {
+    isTest
+  } = state;
+  if (isTest) {
+    return confirm$1(message);
+  }
+  try {
+    return await invoke$5('ConfirmPrompt.prompt', message, undefined);
+  } catch (error) {
+    if (!String(error).includes(missingDialogWorkerRelay)) {
+      throw error;
+    }
+    return confirm$1(message);
+  }
+};
+
 const commandCompletions = new WeakMap();
 const set$1 = (state, completion) => {
   commandCompletions.set(state, completion);
@@ -2976,7 +3024,7 @@ const getFileIcons = async (dirents, fileIconCache) => {
   };
 };
 
-const directoryTypes$1 = new Set([DirectoryExpanded, DirectoryExpanding, EditingDirectoryExpanded]);
+const directoryTypes$2 = new Set([DirectoryExpanded, DirectoryExpanding, EditingDirectoryExpanded]);
 const getParentPath = (path, pathSeparator) => {
   const index = path.lastIndexOf(pathSeparator);
   if (index === -1) {
@@ -2987,7 +3035,7 @@ const getParentPath = (path, pathSeparator) => {
 const getGitIgnoreCandidateDirs = (root, items, pathSeparator) => {
   const dirs = new Set([root]);
   for (const item of items) {
-    if (directoryTypes$1.has(item.type)) {
+    if (directoryTypes$2.has(item.type)) {
       dirs.add(item.path);
     }
     const parent = getParentPath(item.path, pathSeparator);
@@ -3663,7 +3711,7 @@ const {
   registerCommands,
   set,
   wrapGetter
-} = create$a();
+} = create$1();
 const commandQueues = new Map();
 const runQueuedCommand = async (previousCommand, command) => {
   await previousCommand;
@@ -3791,7 +3839,8 @@ const ListItem = 22;
 const Slash = '/';
 
 // TODO parentUid might ot be needed
-const create = (id, uri, x, y, width, height, args, parentUid, platform = 0, assetDir = '') => {
+const create = (id, uri, x, y, width, height, args, parentUid, platform = 0, assetDir = '', isTest = false) => {
+  setIsTest(isTest);
   const state = {
     assetDir,
     chevronSpace: 22,
@@ -3809,7 +3858,7 @@ const create = (id, uri, x, y, width, height, args, parentUid, platform = 0, ass
     editingSelectionEnd: 0,
     editingSelectionStart: 0,
     editingSessionId: 0,
-    editingType: None$5,
+    editingType: None$6,
     editingValue: '',
     errorCode: '',
     errorMessage: '',
@@ -4226,10 +4275,6 @@ const getKeyBindings = () => {
     command: 'Explorer.collapseAll',
     key: CtrlCmd | LeftArrow,
     when: FocusExplorer
-  }, {
-    command: 'Explorer.handlePaste',
-    key: CtrlCmd | KeyV,
-    when: FocusExplorer
   }, {
     command: 'Explorer.handleCopy',
     key: CtrlCmd | KeyC,
@@ -4665,6 +4710,7 @@ const handleBlur = async state => {
   });
   return {
     ...state,
+    focus: None$5,
     focused: false,
     items: newItems
   };
@@ -5039,7 +5085,7 @@ const resetEditing = {
     end: 0,
     start: 0
   },
-  editingType: None$5,
+  editingType: None$6,
   editingValue: ''
 };
 
@@ -5917,7 +5963,7 @@ const getFileOperationsElectron = async (root, paths, fileHandles, pathSeparator
     const path = paths[i];
     operations.push({
       from: path,
-      path: join(pathSeparator, root, name),
+      path: join$1(pathSeparator, root, name),
       type: Copy$1
     });
   }
@@ -5985,6 +6031,121 @@ const handleDrop$1 = async (state, fileHandles, files, paths) => {
   };
 };
 
+const directoryTypes$1 = [Directory, DirectoryExpanded, DirectoryExpanding];
+const isDirectory = item => {
+  return directoryTypes$1.includes(item.type);
+};
+const isDescendant = (path, parentPath, pathSeparator) => {
+  const prefix = parentPath.endsWith(pathSeparator) ? parentPath : `${parentPath}${pathSeparator}`;
+  return path.startsWith(prefix);
+};
+const join = (parentPath, name, pathSeparator) => {
+  if (parentPath.endsWith(pathSeparator)) {
+    return `${parentPath}${name}`;
+  }
+  return `${parentPath}${pathSeparator}${name}`;
+};
+const getTargetFolder = (state, index) => {
+  const {
+    items,
+    pathSeparator,
+    root
+  } = state;
+  if (index === -1) {
+    return root;
+  }
+  const item = items[index];
+  if (!item) {
+    throw new Error('Drop target does not exist');
+  }
+  if (isDirectory(item)) {
+    return item.path;
+  }
+  if (item.type === File) {
+    return dirname(pathSeparator, item.path);
+  }
+  throw new Error('Drop target is not a file or folder');
+};
+const getTopLevelSourcePaths = (sourcePaths, pathSeparator) => {
+  const uniquePaths = [...new Set(sourcePaths)];
+  return uniquePaths.filter(path => uniquePaths.every(otherPath => otherPath === path || !isDescendant(path, otherPath, pathSeparator)));
+};
+const getMoveOperations = (state, sourcePaths, targetFolder) => {
+  const {
+    items,
+    pathSeparator
+  } = state;
+  const itemByPath = new Map(items.map(item => [item.path, item]));
+  const existingPaths = new Set(itemByPath.keys());
+  const destinationPaths = new Set();
+  const operations = [];
+  for (const sourcePath of getTopLevelSourcePaths(sourcePaths, pathSeparator)) {
+    const sourceItem = itemByPath.get(sourcePath);
+    if (!sourceItem) {
+      throw new Error(`Dragged item no longer exists: ${sourcePath}`);
+    }
+    if (sourcePath === targetFolder) {
+      continue;
+    }
+    if (isDirectory(sourceItem) && isDescendant(targetFolder, sourcePath, pathSeparator)) {
+      throw new Error(cannotMoveFolderIntoSubfolderOfItself(sourceItem.name));
+    }
+    const destinationPath = join(targetFolder, sourceItem.name, pathSeparator);
+    if (destinationPath === sourcePath) {
+      continue;
+    }
+    if (destinationPaths.has(destinationPath) || existingPaths.has(destinationPath)) {
+      throw new Error(fileOrFolderAlreadyExists(sourceItem.name));
+    }
+    destinationPaths.add(destinationPath);
+    operations.push({
+      from: sourcePath,
+      path: destinationPath
+    });
+  }
+  return operations;
+};
+const expandTargetFolder = (items, targetFolder) => {
+  return items.map(item => {
+    if (item.path === targetFolder && item.type === Directory) {
+      return {
+        ...item,
+        type: DirectoryExpanded
+      };
+    }
+    return item;
+  });
+};
+const handleInternalDrop = async (state, sourcePaths, index) => {
+  const {
+    isReadonly,
+    items
+  } = state;
+  if (isReadonly) {
+    return state;
+  }
+  const targetFolder = getTargetFolder(state, index);
+  const operations = getMoveOperations(state, sourcePaths, targetFolder);
+  if (operations.length === 0) {
+    return {
+      ...state,
+      dropTargets: []
+    };
+  }
+  for (const operation of operations) {
+    await rename$1(operation.from, operation.path);
+  }
+  const expandedItems = expandTargetFolder(items, targetFolder);
+  const updated = await refresh({
+    ...state,
+    items: expandedItems
+  });
+  return {
+    ...updated,
+    dropTargets: []
+  };
+};
+
 const Electron = 2;
 
 const getModule = isElectron => {
@@ -5997,6 +6158,9 @@ const handleDropRoot = async (state, fileHandles, files, paths) => {
   if (state.isReadonly && state.root !== '') {
     return state;
   }
+  if (fileHandles.length === 0 && paths.length > 0) {
+    return handleInternalDrop(state, paths, -1);
+  }
   const isElectron = state.platform === Electron;
   const fn = getModule(isElectron);
   return fn(state, fileHandles, files, paths);
@@ -6050,6 +6214,9 @@ const handleDropIndex = async (state, fileHandles, files, paths, index) => {
   if (state.isReadonly) {
     return state;
   }
+  if (fileHandles.length === 0 && paths.length > 0) {
+    return handleInternalDrop(state, paths, index);
+  }
   const {
     items
   } = state;
@@ -6077,50 +6244,53 @@ const getDropHandler = index => {
   }
 };
 
-const getFileArray = fileList => {
-  // @ts-ignore
-  const files = [...fileList];
-  return files;
+const getDroppedItems = async (itemIds, isElectron) => {
+  const result = await getDroppedItems$1(itemIds, isElectron);
+  const files = isElectron ? result.files : result.files.filter(file => file.handle);
+  const fileHandles = files.map(file => file.handle || {
+    kind: file.kind,
+    name: file.name
+  });
+  const paths = files.map(file => file.path);
+  return {
+    fileHandles,
+    paths,
+    uris: result.uris
+  };
 };
 
-const getFileHandles = async fileIds => {
-  if (fileIds.length === 0) {
+const getInternalDragPaths = (items, uris) => {
+  if (uris.length === 0) {
     return [];
   }
-  const files = await getFileHandles$1(fileIds);
-  return files;
-};
-
-const getFilePathElectron = async file => {
-  return invoke$2('FileSystemHandle.getFilePathElectron', file);
-};
-
-const getFilepath = async file => {
-  return getFilePathElectron(file);
-};
-const getFilePaths = async (files, platform) => {
-  if (platform !== Electron) {
-    return files.map(file => '');
+  const pathByUri = new Map(items.map(item => [ensureUri(item.path), item.path]));
+  const paths = [];
+  for (const uri of uris) {
+    const path = pathByUri.get(uri);
+    if (path === undefined) {
+      return [];
+    }
+    paths.push(path);
   }
-  const promises = files.map(getFilepath);
-  const paths = await Promise.all(promises);
   return paths;
 };
 
-const handleDrop = async (state, x, y, fileIds, fileList) => {
+const handleDrop = async (state, x, y, fileIds) => {
   if (state.isReadonly && state.root !== '') {
     return state;
   }
   try {
+    const isElectron = state.platform === Electron;
     const {
-      platform
-    } = state;
-    const files = getFileArray(fileList);
-    const fileHandles = await getFileHandles(fileIds);
-    const paths = await getFilePaths(files, platform);
+      fileHandles,
+      paths,
+      uris
+    } = await getDroppedItems(fileIds, isElectron);
+    const internalPaths = getInternalDragPaths(state.items, uris);
+    const droppedPaths = internalPaths.length > 0 ? internalPaths : paths;
     const index = getIndexFromPosition(state, x, y);
     const fn = getDropHandler(index);
-    const result = await fn(state, fileHandles, files, paths, index);
+    const result = await fn(state, fileHandles, [], droppedPaths, index);
     return result;
   } catch (error) {
     throw new VError(error, 'Failed to drop files');
@@ -6501,6 +6671,42 @@ const handlePaste = async state => {
   return handlePasteCopy(state, nativeFiles);
 };
 
+const handleNativePaste = async (state, itemIds) => {
+  const {
+    focusedIndex,
+    isReadonly,
+    platform
+  } = state;
+  if (isReadonly) {
+    return state;
+  }
+  if (itemIds.length === 0) {
+    return handlePaste(state);
+  }
+  try {
+    const isElectron = platform === Electron;
+    const {
+      fileHandles,
+      paths
+    } = await getDroppedItems(itemIds, isElectron);
+    if (isElectron) {
+      const nativePaths = paths.filter(Boolean);
+      if (nativePaths.length === 0) {
+        return handlePaste(state);
+      }
+      return handlePasteCopy(state, {
+        files: nativePaths,
+        source: 'gnomeCopiedFiles',
+        type: 'copy'
+      });
+    }
+    const handleDrop = getDropHandler(focusedIndex);
+    return handleDrop(state, fileHandles, [], paths, focusedIndex);
+  } catch (error) {
+    throw new VError(error, 'Failed to paste native files');
+  }
+};
+
 const handlePointerDown = (state, button, x, y) => {
   const index = getIndexFromPosition(state, x, y);
   if (button === LeftClick && index === -1) {
@@ -7004,14 +7210,8 @@ const getDragLabel = urls => {
   return String(urls.length);
 };
 
-const toUri = path => {
-  if (path.startsWith('file://')) {
-    return path;
-  }
-  return 'file://' + path;
-};
 const getDragData = urls => {
-  const data = urls.map(toUri).join('\n');
+  const data = urls.map(ensureUri).join('\n');
   const dragData = [{
     data,
     type: 'text/uri-list'
@@ -7118,6 +7318,7 @@ const HandleInputClick = 9;
 const HandleKeyDown = 21;
 const HandleListBlur = 11;
 const HandleListFocus = 12;
+const HandleNativePaste = 26;
 const HandlePointerDown = 14;
 const HandlePointerUp = 25;
 const HandleScrollBarMove = 22;
@@ -7313,6 +7514,7 @@ const getListItemsVirtualDom = (visibleItems, focusedIndex, focused, dropTargets
     onDragStart: HandleDragStart,
     onDrop: HandleDrop,
     onFocus: HandleListFocus,
+    onPaste: HandleNativePaste,
     onPointerDown: HandlePointerDown,
     onPointerUp: HandlePointerUp,
     onWheel: HandleWheel,
@@ -7679,7 +7881,11 @@ const renderEventListeners = () => {
     preventDefault: true
   }, {
     name: HandleDrop,
-    params: ['handleDrop', ClientX, ClientY, DataTransferFiles2, DataTransferFiles],
+    params: ['handleDrop', ClientX, ClientY, DataTransferFiles2],
+    preventDefault: true
+  }, {
+    name: HandleNativePaste,
+    params: ['handleNativePaste', 'event.clipboardData.files2'],
     preventDefault: true
   }, {
     name: HandleDragLeave,
@@ -8055,6 +8261,7 @@ const commandMap = {
   'Explorer.handleInputClick': wrapListItemCommand(handleInputClick),
   'Explorer.handleInputKeyDown': wrapListItemCommand(handleInputKeyDown),
   'Explorer.handleKeyDown': wrapListItemCommand(handleKeyDown),
+  'Explorer.handleNativePaste': wrapListItemCommand(handleNativePaste),
   'Explorer.handlePaste': wrapListItemCommand(handlePaste),
   'Explorer.handlePointerDown': wrapListItemCommand(handlePointerDown),
   'Explorer.handlePointerUp': wrapListItemCommand(handlePointerUp),
@@ -8095,13 +8302,27 @@ const commandMap = {
   'Explorer.updateIcons': wrapListItemCommand(updateIcons)
 };
 
+const send$2 = async port => {
+  await sendMessagePortToDragAndDropWorker(port);
+};
+const createDragAndDropWorkerRpc = async () => {
+  return create$4({
+    commandMap: {},
+    send: send$2
+  });
+};
+
+const initializeDragAndDropWorker = async () => {
+  set$7(await createDragAndDropWorkerRpc());
+};
+
 const sendMessagePortToFileSystemWorker = async port => {
   await sendMessagePortToFileSystemWorker$1(port, 0);
 };
 
 const createFileSystemWorkerRpc = async () => {
   try {
-    const rpc = await create$3({
+    const rpc = await create$4({
       commandMap: {},
       send: sendMessagePortToFileSystemWorker
     });
@@ -8121,7 +8342,7 @@ const send$1 = port => {
 };
 const createIconThemeWorkerRpc = async () => {
   try {
-    const rpc = await create$3({
+    const rpc = await create$4({
       commandMap: {},
       send: send$1
     });
@@ -8137,7 +8358,7 @@ const initializeIconThemeWorker = async () => {
 };
 
 const initializeRendererWorker = async () => {
-  const rpc = await create$2({
+  const rpc = await create$3({
     commandMap: commandMap
   });
   set$4(rpc);
@@ -8149,7 +8370,7 @@ const send = port => {
 };
 const createSourceControlWorkerRpc = async () => {
   try {
-    const rpc = await create$3({
+    const rpc = await create$4({
       commandMap: {},
       send
     });
@@ -8171,7 +8392,12 @@ const initializeSourceControlWorker = async () => {
 
 const listen = async () => {
   registerCommands(commandMap);
-  await Promise.all([initializeRendererWorker(), initializeFileSystemWorker(), initializeIconThemeWorker(), initializeSourceControlWorker()]);
+  await Promise.all([initializeRendererWorker(), initializeFileSystemWorker(), initializeIconThemeWorker(), initializeSourceControlWorker(), initializeDragAndDropWorker()]);
+  const dialogRpc = await create$4({
+    commandMap: {},
+    send: sendMessagePortToDialogWorker
+  });
+  set$8(dialogRpc);
 };
 
 const main = async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/explorer-view",
-  "version": "7.21.1",
+  "version": "7.21.3",
   "description": "Explorer Worker",
   "repository": {
     "type": "git",