@lvce-editor/static-server 0.99.9 → 0.99.11

package/static/{b4e39e5 → 3322d7b}/packages/main-area-worker/dist/mainAreaWorkerMain.js

@@ -54,6 +54,61 @@ class VError extends Error {
   }
 }
 
+class AssertionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'AssertionError';
+  }
+}
+const Object$1 = 1;
+const Number$1 = 2;
+const Array$1 = 3;
+const String$1 = 4;
+const Boolean$1 = 5;
+const Function = 6;
+const Null = 7;
+const Unknown = 8;
+const getType = value => {
+  switch (typeof value) {
+    case 'number':
+      return Number$1;
+    case 'function':
+      return Function;
+    case 'string':
+      return String$1;
+    case 'object':
+      if (value === null) {
+        return Null;
+      }
+      if (Array.isArray(value)) {
+        return Array$1;
+      }
+      return Object$1;
+    case 'boolean':
+      return Boolean$1;
+    default:
+      return Unknown;
+  }
+};
+const object = value => {
+  const type = getType(value);
+  if (type !== Object$1) {
+    throw new AssertionError('expected value to be of type object');
+  }
+};
+const number = value => {
+  const type = getType(value);
+  if (type !== Number$1) {
+    throw new AssertionError('expected value to be of type number');
+  }
+};
+const string = value => {
+  const type = getType(value);
+  if (type !== String$1) {
+    throw new AssertionError('expected value to be of type string');
+  }
+};
+
 const isMessagePort = value => {
   return value && value instanceof MessagePort;
 };
@@ -1074,41 +1129,6 @@ const create$b = async ({
   return rpc;
 };
 
-const create$a = async ({
-  commandMap,
-  isMessagePortOpen = true,
-  messagePort
-}) => {
-  // TODO create a commandMap per rpc instance
-  register(commandMap);
-  const rawIpc = await IpcParentWithMessagePort$1.create({
-    isMessagePortOpen,
-    messagePort
-  });
-  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
-  handleIpc(ipc);
-  const rpc = createRpc(ipc);
-  messagePort.start();
-  return rpc;
-};
-
-const create$9 = async ({
-  commandMap,
-  isMessagePortOpen,
-  send
-}) => {
-  const {
-    port1,
-    port2
-  } = new MessageChannel();
-  await send(port1);
-  return create$a({
-    commandMap,
-    isMessagePortOpen,
-    messagePort: port2
-  });
-};
-
 const createSharedLazyRpc = factory => {
   let rpcPromise;
   const getOrCreate = () => {
@@ -1137,7 +1157,7 @@ const createSharedLazyRpc = factory => {
   };
 };
 
-const create$8 = async ({
+const create$a = async ({
   commandMap,
   getPortTuple,
   send
@@ -1154,13 +1174,13 @@ const create$8 = async ({
   return rpc;
 };
 
-const create$7 = async ({
+const create$9 = async ({
   commandMap,
   getPortTuple,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$8({
+    return create$a({
       commandMap,
       getPortTuple,
       send
@@ -1168,13 +1188,48 @@ const create$7 = async ({
   });
 };
 
+const create$8 = async ({
+  commandMap,
+  isMessagePortOpen = true,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+
+const create$7 = async ({
+  commandMap,
+  isMessagePortOpen,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$8({
+    commandMap,
+    isMessagePortOpen,
+    messagePort: port2
+  });
+};
+
 const create$6 = async ({
   commandMap,
   isMessagePortOpen,
   send
 }) => {
   return createSharedLazyRpc(() => {
-    return create$9({
+    return create$7({
       commandMap,
       isMessagePortOpen,
       send
@@ -1214,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 => {
@@ -1247,7 +1302,7 @@ const create$4 = rpcId => {
       const mockRpc = createMockRpc({
         commandMap
       });
-      set$5(rpcId, mockRpc);
+      set$6(rpcId, mockRpc);
       // @ts-ignore
       mockRpc[Symbol.dispose] = () => {
         remove(rpcId);
@@ -1256,7 +1311,7 @@ const create$4 = rpcId => {
       return mockRpc;
     },
     set(rpc) {
-      set$5(rpcId, rpc);
+      set$6(rpcId, rpc);
     }
   };
 };
@@ -1438,7 +1493,6 @@ const VirtualDomElements = {
 const Button$1 = 'event.button';
 const ClientX = 'event.clientX';
 const ClientY = 'event.clientY';
-const DataTransferFiles = 'event.dataTransfer.files';
 const DataTransferFiles2 = 'event.dataTransfer.files2';
 const EventTargetClassName = 'event.target.className';
 const TargetName = 'event.target.name';
@@ -1453,11 +1507,11 @@ const Add$1 = 6;
 const NavigateChild$1 = 7;
 const NavigateParent$1 = 8;
 
-const Web = 1;
 const Electron = 2;
 
 const ClipBoardWorker = 3400;
 const DialogWorker = 7014;
+const DragAndDropWorker = 3404;
 const IconThemeWorker = 7009;
 const RendererWorker = 1;
 
@@ -1468,17 +1522,25 @@ const SetPatches = 'Viewlet.setPatches';
 const FocusEditorText = 12;
 
 const {
-  invoke: invoke$3,
-  set: set$4
+  invoke: invoke$4,
+  set: set$5
 } = create$4(ClipBoardWorker);
 const writeText = async text => {
-  return invoke$3('ClipBoard.writeText', text);
+  return invoke$4('ClipBoard.writeText', text);
 };
 
+const {
+  invoke: invoke$3,
+  set: set$4
+} = create$4(DialogWorker);
+
 const {
   invoke: invoke$2,
   set: set$3
-} = create$4(DialogWorker);
+} = create$4(DragAndDropWorker);
+const getDroppedItems = async (itemIds, isElectron) => {
+  return invoke$2('DragAndDrop.getDroppedItems', itemIds, isElectron);
+};
 
 const {
   invoke: invoke$1,
@@ -1489,61 +1551,6 @@ const getIcons = async iconRequests => {
   return invoke$1('IconTheme.getIcons', iconRequests);
 };
 
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const Object$1 = 1;
-const Number$1 = 2;
-const Array$1 = 3;
-const String$1 = 4;
-const Boolean$1 = 5;
-const Function = 6;
-const Null = 7;
-const Unknown = 8;
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return Number$1;
-    case 'function':
-      return Function;
-    case 'string':
-      return String$1;
-    case 'object':
-      if (value === null) {
-        return Null;
-      }
-      if (Array.isArray(value)) {
-        return Array$1;
-      }
-      return Object$1;
-    case 'boolean':
-      return Boolean$1;
-    default:
-      return Unknown;
-  }
-};
-const object = value => {
-  const type = getType(value);
-  if (type !== Object$1) {
-    throw new AssertionError('expected value to be of type object');
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== Number$1) {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const string = value => {
-  const type = getType(value);
-  if (type !== String$1) {
-    throw new AssertionError('expected value to be of type string');
-  }
-};
-
 const {
   invoke,
   invokeAndTransfer,
@@ -1559,14 +1566,14 @@ 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 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);
@@ -2419,7 +2426,7 @@ const saveEditor = async editorUid => {
 const missingDialogWorkerRelay = 'Command "SendMessagePortToExtensionHostWorker.sendMessagePortToDialogWorker" not found';
 const confirm = async (message, options) => {
   try {
-    return await invoke$2('ConfirmPrompt.prompt', message, options);
+    return await invoke$3('ConfirmPrompt.prompt', message, options);
   } catch (error) {
     if (!String(error).includes(missingDialogWorkerRelay)) {
       throw error;
@@ -4249,7 +4256,7 @@ const openInputWithContext = async (context, options) => {
   const title = getEditorInputTitle(editorInput);
   const editorType = getEditorInputEditorType(editorInput);
   const currentState = state;
-  const existingTab = findTabByUri(currentState, uri);
+  const existingTab = options.reuseExisting === false ? undefined : findTabByUri(currentState, uri);
   const shouldRetryExistingTab = !!existingTab && existingTab.tab.loadingState === 'error';
   if (existingTab && !shouldRetryExistingTab) {
     const switchedState = getExistingTabState(currentState, existingTab, preview);
@@ -4363,12 +4370,13 @@ const getViewletContext = (options, viewletContext) => {
   if (viewletContext !== undefined || typeof options === 'string') {
     return viewletContext;
   }
-  const context = Object.fromEntries(Object.entries(options).filter(([key]) => key !== 'focus' && key !== 'preview' && key !== 'uri'));
+  const context = Object.fromEntries(Object.entries(options).filter(([key]) => key !== 'focus' && key !== 'preview' && key !== 'reuseExisting' && key !== 'uri'));
   return Object.keys(context).length === 0 ? undefined : context;
 };
 const getOpenInputOptions = (options, focus = true, viewletContext) => {
   const uri = getOptionUriOptions(options);
   const preview = typeof options === 'string' ? false : options.preview ?? false;
+  const reuseExisting = typeof options === 'string' ? true : options.reuseExisting ?? true;
   const context = getViewletContext(options, viewletContext);
   return {
     ...(context !== undefined && {
@@ -4376,7 +4384,8 @@ const getOpenInputOptions = (options, focus = true, viewletContext) => {
     }),
     editorInput: getNormalizedOpenEditorInput(uri),
     focus: typeof options === 'string' ? focus : options.focus,
-    preview
+    preview,
+    reuseExisting
   };
 };
 const openUri = async (state, options, focus = true, viewletContext) => {
@@ -4763,6 +4772,7 @@ const getOverlay = (x, y, width, height, splitDirection) => {
     case Down:
       return {
         height: halfHeight,
+        splitDirection,
         width,
         x,
         y: y + halfHeight
@@ -4770,6 +4780,7 @@ const getOverlay = (x, y, width, height, splitDirection) => {
     case Left:
       return {
         height,
+        splitDirection,
         width: halfWidth,
         x,
         y
@@ -4777,6 +4788,7 @@ const getOverlay = (x, y, width, height, splitDirection) => {
     case Right:
       return {
         height,
+        splitDirection,
         width: halfWidth,
         x: x + halfWidth,
         y
@@ -4784,6 +4796,7 @@ const getOverlay = (x, y, width, height, splitDirection) => {
     case Up:
       return {
         height: halfHeight,
+        splitDirection,
         width,
         x,
         y
@@ -4791,6 +4804,7 @@ const getOverlay = (x, y, width, height, splitDirection) => {
     default:
       return {
         height,
+        splitDirection,
         width,
         x,
         y
@@ -4841,7 +4855,7 @@ const getDragOverlay = (state, eventX, eventY) => {
 };
 
 const isEqual = (oldOverlay, newOverlay) => {
-  return oldOverlay?.x === newOverlay?.x && oldOverlay?.y === newOverlay?.y && oldOverlay?.width === newOverlay?.width && oldOverlay?.height === newOverlay?.height;
+  return oldOverlay?.x === newOverlay?.x && oldOverlay?.y === newOverlay?.y && oldOverlay?.width === newOverlay?.width && oldOverlay?.height === newOverlay?.height && oldOverlay?.splitDirection === newOverlay?.splitDirection;
 };
 const handleDragOver = (state, eventX, eventY) => {
   const {
@@ -4857,139 +4871,229 @@ const handleDragOver = (state, eventX, eventY) => {
   };
 };
 
-const chromiumDragIdRegex = /^[A-F\d]{32}$/i;
-const isChromiumDragId = item => {
-  if (!item || typeof item !== 'object') {
-    return false;
-  }
-  const candidate = item;
-  return candidate.kind === 'string' && (candidate.type === '' || candidate.type === 'chromium/x-drag-id') && typeof candidate.value === 'string' && chromiumDragIdRegex.test(candidate.value);
-};
-
-const isDroppedFileSystemHandle = item => {
-  if (!item || typeof item !== 'object') {
-    return false;
-  }
-  const candidate = item;
-  const handle = candidate.value;
-  return candidate.kind === 'file' && Boolean(handle) && typeof handle === 'object' && (handle.kind === 'directory' || handle.kind === 'file') && typeof handle.name === 'string';
-};
-
-const isUriList = item => {
-  if (!item || typeof item !== 'object') {
-    return false;
+const openUrisWithContext = async (context, uris, reuseExisting = true) => {
+  for (const uri of uris) {
+    await openUriWithContext(context, {
+      focus: true,
+      reuseExisting,
+      uri
+    });
   }
-  const candidate = item;
-  return candidate.kind === 'string' && candidate.type === 'text/uri-list' && typeof candidate.value === 'string';
-};
-
-const lineSeparatorRegex = /\r?\n/;
-const parseUriList = value => {
-  return value.split(lineSeparatorRegex).map(uri => uri.trim()).filter(uri => uri && !uri.startsWith('#'));
 };
 
-const suffixByHandleKind = {
-  directory: '/',
-  file: ''
-};
-const getDroppedBrowserUris = async itemIds => {
-  if (itemIds.length === 0) {
-    return [];
-  }
-  const items = await getFileHandles(itemIds);
-  let hasChromiumDragId = false;
-  const uris = [];
-  for (const [index, item] of items.entries()) {
-    if (isUriList(item)) {
-      uris.push(...parseUriList(item.value));
-      continue;
-    }
-    if (isChromiumDragId(item)) {
-      hasChromiumDragId = true;
-      continue;
-    }
-    if (!isDroppedFileSystemHandle(item)) {
-      continue;
-    }
-    const handle = item.value;
-    const suffix = suffixByHandleKind[handle.kind];
-    const uri = `html:///dropped-files/${Date.now()}/${itemIds[index]}/${handle.name}${suffix}`;
-    await invoke('PersistentFileHandle.addHandle', uri, handle);
-    uris.push(uri);
-  }
-  if (uris.length > 0 || !hasChromiumDragId) {
-    return uris;
-  }
-  const dragInfo = await invoke('Viewlet.getDragData');
-  if (!dragInfo || typeof dragInfo !== 'object' || !Array.isArray(dragInfo.items)) {
-    return uris;
-  }
-  for (const item of dragInfo.items) {
-    const candidate = item;
-    if (candidate.type === 'text/uri-list' && typeof candidate.data === 'string') {
-      uris.push(...parseUriList(candidate.data));
-    }
-  }
-  return uris;
-};
+const splitDown$1 = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    direction,
+    groups
+  } = layout;
 
-const windowsDriveLetterRegex = /^[a-zA-Z]:\\/;
-const encodeFilePath = path => {
-  return encodeURI(path).replaceAll('#', '%23').replaceAll('?', '%3F');
-};
-const toFileUri$1 = path => {
-  if (path.startsWith('file://')) {
-    return path;
+  // If there are no groups, create an initial empty group first
+  if (groups.length === 0) {
+    const initialGroupId = create$2();
+    const initialGroup = {
+      activeTabId: -1,
+      direction,
+      focused: true,
+      id: initialGroupId,
+      isEmpty: true,
+      size: 100,
+      tabs: []
+    };
+    const stateWithInitialGroup = {
+      ...state,
+      layout: {
+        ...layout,
+        activeGroupId: initialGroupId,
+        groups: [initialGroup]
+      }
+    };
+    return splitEditorGroup$1(stateWithInitialGroup, initialGroupId, 'down');
   }
-  if (windowsDriveLetterRegex.test(path)) {
-    const normalizedPath = path.replaceAll('\\', '/');
-    return `file:///${encodeFilePath(normalizedPath)}`;
+  const resolvedGroupId = groupId ?? activeGroupId;
+  if (!resolvedGroupId) {
+    return state;
   }
-  return `file://${encodeFilePath(path)}`;
+  return splitEditorGroup$1(state, resolvedGroupId, 'down');
 };
 
-const getDroppedElectronUris = async (itemIds, files) => {
-  if (itemIds.length > 0) {
-    await getFileHandles(itemIds);
-  }
-  const uris = [];
-  for (const file of files) {
-    const path = await invoke('FileSystemHandle.getFilePathElectron', file);
-    uris.push(toFileUri$1(path));
+const splitLeft$1 = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    direction,
+    groups
+  } = layout;
+  if (groups.length === 0) {
+    const initialGroupId = create$2();
+    const initialGroup = {
+      activeTabId: -1,
+      direction,
+      focused: true,
+      id: initialGroupId,
+      isEmpty: true,
+      size: 100,
+      tabs: []
+    };
+    const stateWithInitialGroup = {
+      ...state,
+      layout: {
+        ...layout,
+        activeGroupId: initialGroupId,
+        groups: [initialGroup]
+      }
+    };
+    return splitEditorGroup$1(stateWithInitialGroup, initialGroupId, Left$1);
   }
-  return uris;
+  const targetGroupId = groupId ?? (activeGroupId === -1 ? groups[0]?.id : activeGroupId) ?? 0;
+  return splitEditorGroup$1(state, targetGroupId, Left$1);
 };
 
-const getDroppedUris = async (itemIds, files = [], platform = Web) => {
-  if (platform === Electron && files.length > 0) {
-    return getDroppedElectronUris(itemIds, files);
+const splitRight$1 = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    direction,
+    groups
+  } = layout;
+
+  // If there are no groups, create an initial empty group first
+  if (groups.length === 0) {
+    const initialGroupId = create$2();
+    const initialGroup = {
+      activeTabId: -1,
+      direction,
+      focused: true,
+      id: initialGroupId,
+      isEmpty: true,
+      size: 100,
+      tabs: []
+    };
+    const stateWithInitialGroup = {
+      ...state,
+      layout: {
+        ...layout,
+        activeGroupId: initialGroupId,
+        groups: [initialGroup]
+      }
+    };
+    return splitEditorGroup$1(stateWithInitialGroup, initialGroupId, Right$1);
   }
-  return getDroppedBrowserUris(itemIds);
+  const targetGroupId = groupId ?? (activeGroupId === -1 ? groups[0]?.id : activeGroupId) ?? 0;
+  return splitEditorGroup$1(state, targetGroupId, Right$1);
 };
 
-const openUrisWithContext = async (context, uris) => {
-  for (const uri of uris) {
-    await openUriWithContext(context, uri);
+const splitUp$1 = (state, groupId) => {
+  const {
+    layout
+  } = state;
+  const {
+    activeGroupId,
+    direction,
+    groups
+  } = layout;
+  if (groups.length === 0) {
+    const initialGroupId = create$2();
+    const initialGroup = {
+      activeTabId: -1,
+      direction,
+      focused: true,
+      id: initialGroupId,
+      isEmpty: true,
+      size: 100,
+      tabs: []
+    };
+    const stateWithInitialGroup = {
+      ...state,
+      layout: {
+        ...layout,
+        activeGroupId: initialGroupId,
+        groups: [initialGroup]
+      }
+    };
+    return splitEditorGroup$1(stateWithInitialGroup, initialGroupId, 'up');
   }
+  const resolvedGroupId = groupId ?? activeGroupId;
+  if (!resolvedGroupId) {
+    return state;
+  }
+  return splitEditorGroup$1(state, resolvedGroupId, 'up');
 };
 
-const handleDrop = async (context, itemIds, files = []) => {
-  await context.updateState(handleDragLeave);
-  const {
-    platform
-  } = context.getState();
-  const uris = await getDroppedUris(itemIds, files, platform);
+const splitForDrop = (state, splitDirection) => {
+  switch (splitDirection) {
+    case Down:
+      return splitDown$1(state);
+    case Left:
+      return splitLeft$1(state);
+    case Right:
+      return splitRight$1(state);
+    case Up:
+      return splitUp$1(state);
+    default:
+      return state;
+  }
+};
+const getDropAction = async uris => {
   for (const uri of uris) {
     if (uri.endsWith('/') || (await isDirectoryEditorInput({
       type: 'editor',
       uri
     }))) {
-      const command = uri.startsWith('file://') ? 'Workspace.setUri' : 'Workspace.setPath';
-      void invoke(command, uri).catch(() => {});
-      return;
+      if (uri.startsWith('file://')) {
+        return {
+          command: 'setUri',
+          value: uri
+        };
+      }
+      return {
+        command: 'setPath',
+        value: uri
+      };
     }
   }
-  await openUrisWithContext(context, uris);
+  return {
+    command: 'openFiles',
+    uris
+  };
+};
+const applyDropAction = async (context, action, splitDirection) => {
+  switch (action.command) {
+    case 'openFiles':
+      {
+        if (action.uris.length > 0 && splitDirection !== None) {
+          await context.updateState(state => splitForDrop(state, splitDirection));
+        }
+        await openUrisWithContext(context, action.uris, splitDirection === None);
+        break;
+      }
+    case 'setPath':
+      void invoke('Workspace.setPath', action.value).catch(() => {});
+      break;
+    case 'setUri':
+      void invoke('Workspace.setUri', action.value).catch(() => {});
+      break;
+  }
+};
+const handleDrop = async (context, itemIds) => {
+  const splitDirection = context.getState().dragOverlay?.splitDirection ?? None;
+  await context.updateState(handleDragLeave);
+  const {
+    platform
+  } = context.getState();
+  const isElectron = platform === Electron;
+  const {
+    uris
+  } = await getDroppedItems(itemIds, isElectron);
+  const actions = await getDropAction(uris);
+  await applyDropAction(context, actions, splitDirection);
 };
 
 const EditorGroupHeader = 'EditorGroupHeader';
@@ -6024,16 +6128,16 @@ const Retry = 'Retry';
 const openFile = () => {
   return i18nString(OpenFile);
 };
-const splitUp$1 = () => {
+const splitUp = () => {
   return i18nString(SplitUp);
 };
-const splitDown$1 = () => {
+const splitDown = () => {
   return i18nString(SplitDown);
 };
-const splitLeft$1 = () => {
+const splitLeft = () => {
   return i18nString(SplitLeft);
 };
-const splitRight$1 = () => {
+const splitRight = () => {
   return i18nString(SplitRight);
 };
 const splitEditorGroup = () => {
@@ -6149,25 +6253,25 @@ const getMenuEntries$2 = (state, groupId) => {
     command: 'Main.splitUp',
     flags: None$1,
     id: 'splitUp',
-    label: splitUp$1()
+    label: splitUp()
   }, {
     args: groupArgs,
     command: 'Main.splitDown',
     flags: None$1,
     id: 'splitDown',
-    label: splitDown$1()
+    label: splitDown()
   }, {
     args: groupArgs,
     command: 'Main.splitLeft',
     flags: None$1,
     id: 'splitLeft',
-    label: splitLeft$1()
+    label: splitLeft()
   }, {
     args: groupArgs,
     command: 'Main.splitRight',
     flags: None$1,
     id: 'splitRight',
-    label: splitRight$1()
+    label: splitRight()
   }, ...getNewWindowMenuEntries(state)];
   if (!hasTargetGroup(groupId)) {
     return entries;
@@ -6281,7 +6385,7 @@ const getMenuEntries$1 = state => {
     command: 'Main.splitRight',
     flags: None$1,
     id: 'splitRight',
-    label: splitRight$1()
+    label: splitRight()
   }, {
     command: '',
     flags: None$1,
@@ -7450,7 +7554,7 @@ const renderEventListeners = () => {
     params: ['handleDragLeave']
   }, {
     name: HandleDrop,
-    params: ['handleDrop', DataTransferFiles2, DataTransferFiles],
+    params: ['handleDrop', DataTransferFiles2],
     preventDefault: true
   }];
 };
@@ -7878,152 +7982,6 @@ const setEditorLayoutTwoColumnsBottom = state => {
   }]);
 };
 
-const splitDown = (state, groupId) => {
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    direction,
-    groups
-  } = layout;
-
-  // If there are no groups, create an initial empty group first
-  if (groups.length === 0) {
-    const initialGroupId = create$2();
-    const initialGroup = {
-      activeTabId: -1,
-      direction,
-      focused: true,
-      id: initialGroupId,
-      isEmpty: true,
-      size: 100,
-      tabs: []
-    };
-    const stateWithInitialGroup = {
-      ...state,
-      layout: {
-        ...layout,
-        activeGroupId: initialGroupId,
-        groups: [initialGroup]
-      }
-    };
-    return splitEditorGroup$1(stateWithInitialGroup, initialGroupId, 'down');
-  }
-  const resolvedGroupId = groupId ?? activeGroupId;
-  if (!resolvedGroupId) {
-    return state;
-  }
-  return splitEditorGroup$1(state, resolvedGroupId, 'down');
-};
-
-const splitLeft = (state, groupId) => {
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    direction,
-    groups
-  } = layout;
-  if (groups.length === 0) {
-    const initialGroupId = create$2();
-    const initialGroup = {
-      activeTabId: -1,
-      direction,
-      focused: true,
-      id: initialGroupId,
-      isEmpty: true,
-      size: 100,
-      tabs: []
-    };
-    const stateWithInitialGroup = {
-      ...state,
-      layout: {
-        ...layout,
-        activeGroupId: initialGroupId,
-        groups: [initialGroup]
-      }
-    };
-    return splitEditorGroup$1(stateWithInitialGroup, initialGroupId, Left$1);
-  }
-  const targetGroupId = groupId ?? (activeGroupId === -1 ? groups[0]?.id : activeGroupId) ?? 0;
-  return splitEditorGroup$1(state, targetGroupId, Left$1);
-};
-
-const splitRight = (state, groupId) => {
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    direction,
-    groups
-  } = layout;
-
-  // If there are no groups, create an initial empty group first
-  if (groups.length === 0) {
-    const initialGroupId = create$2();
-    const initialGroup = {
-      activeTabId: -1,
-      direction,
-      focused: true,
-      id: initialGroupId,
-      isEmpty: true,
-      size: 100,
-      tabs: []
-    };
-    const stateWithInitialGroup = {
-      ...state,
-      layout: {
-        ...layout,
-        activeGroupId: initialGroupId,
-        groups: [initialGroup]
-      }
-    };
-    return splitEditorGroup$1(stateWithInitialGroup, initialGroupId, Right$1);
-  }
-  const targetGroupId = groupId ?? (activeGroupId === -1 ? groups[0]?.id : activeGroupId) ?? 0;
-  return splitEditorGroup$1(state, targetGroupId, Right$1);
-};
-
-const splitUp = (state, groupId) => {
-  const {
-    layout
-  } = state;
-  const {
-    activeGroupId,
-    direction,
-    groups
-  } = layout;
-  if (groups.length === 0) {
-    const initialGroupId = create$2();
-    const initialGroup = {
-      activeTabId: -1,
-      direction,
-      focused: true,
-      id: initialGroupId,
-      isEmpty: true,
-      size: 100,
-      tabs: []
-    };
-    const stateWithInitialGroup = {
-      ...state,
-      layout: {
-        ...layout,
-        activeGroupId: initialGroupId,
-        groups: [initialGroup]
-      }
-    };
-    return splitEditorGroup$1(stateWithInitialGroup, initialGroupId, 'up');
-  }
-  const resolvedGroupId = groupId ?? activeGroupId;
-  if (!resolvedGroupId) {
-    return state;
-  }
-  return splitEditorGroup$1(state, resolvedGroupId, 'up');
-};
-
 const pendingLoads = new Map();
 const loadContent = wrapSerialCommand(loadContent$1);
 const loadContentTracked = async (uid, ...args) => {
@@ -8075,7 +8033,7 @@ const commandMap = {
   'Main.restoreClosedTab': wrapSerialCommand(restoreClosedTab),
   'Main.save': wrapSerialCommand(save),
   'Main.saveState': wrapGetter(saveState),
-  'Main.splitRight': wrapSerialCommand(splitRight),
+  'Main.splitRight': wrapSerialCommand(splitRight$1),
   'MainArea.closeActiveEditor': wrapSerialCommand(closeActiveEditor),
   'MainArea.closeAll': wrapSerialCommand(closeAll$1),
   'MainArea.closeAllEditors': wrapSerialCommand(closeAll$1),
@@ -8149,10 +8107,10 @@ const commandMap = {
   'MainArea.setEditorLayoutTwoColumnsBottom': wrapSerialCommand(setEditorLayoutTwoColumnsBottom),
   'MainArea.setEditorLayoutTwoRows': wrapSerialCommand(setEditorLayoutTwoRows),
   'MainArea.setEditorLayoutTwoRowsRight': wrapSerialCommand(setEditorLayoutTwoRowsRight),
-  'MainArea.splitDown': wrapSerialCommand(splitDown),
-  'MainArea.splitLeft': wrapSerialCommand(splitLeft),
-  'MainArea.splitRight': wrapSerialCommand(splitRight),
-  'MainArea.splitUp': wrapSerialCommand(splitUp),
+  'MainArea.splitDown': wrapSerialCommand(splitDown$1),
+  'MainArea.splitLeft': wrapSerialCommand(splitLeft$1),
+  'MainArea.splitRight': wrapSerialCommand(splitRight$1),
+  'MainArea.splitUp': wrapSerialCommand(splitUp$1),
   'MainArea.terminate': terminate
 };
 
@@ -8162,11 +8120,25 @@ const sendMessagePortToClipBoardWorker = async port => {
 };
 
 const initializeClipBoardWorker = async () => {
-  const rpc = await create$7({
+  const rpc = await create$9({
     commandMap: {},
     send: sendMessagePortToClipBoardWorker
   });
-  set$4(rpc);
+  set$5(rpc);
+};
+
+const send$1 = async port => {
+  await sendMessagePortToDragAndDropWorker(port);
+};
+const createDragAndDropWorkerRpc = async () => {
+  return create$6({
+    commandMap: {},
+    send: send$1
+  });
+};
+
+const initializeDragAndDropWorker = async () => {
+  set$3(await createDragAndDropWorkerRpc());
 };
 
 const send = port => {
@@ -8211,12 +8183,12 @@ const initializeRendererWorker = async () => {
 
 const listen = async () => {
   registerCommands(commandMap);
-  await Promise.all([initializeRendererWorker(), initializeIconThemeWorker(), initializeClipBoardWorker()]);
+  await Promise.all([initializeRendererWorker(), initializeIconThemeWorker(), initializeClipBoardWorker(), initializeDragAndDropWorker()]);
   const dialogRpc = await create$6({
     commandMap: {},
     send: sendMessagePortToDialogWorker
   });
-  set$3(dialogRpc);
+  set$4(dialogRpc);
 };
 
 const main$1 = async () => {