@lvce-editor/static-server 0.58.2 → 0.59.0

package/static/{38a6439 → 91d96a2}/packages/references-view/dist/referencesViewWorkerMain.js

@@ -527,7 +527,7 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$5 = (id, fn) => {
+const set$8 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$2 = id => {
@@ -546,7 +546,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$5(id, resolve);
+  set$8(id, resolve);
   return {
     id,
     promise
@@ -626,7 +626,8 @@ const splitLines = lines => {
   return lines.split(NewLine$1);
 };
 const getCurrentStack = () => {
-  const currentStack = joinLines(splitLines(new Error().stack || '').slice(2));
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
 const getNewLineIndex$1 = (string, startIndex = undefined) => {
@@ -890,13 +891,19 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke$1 = (ipc, method, ...params) => {
+const invoke$4 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$3 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
 const commands = Object.create(null);
 const register = commandMap => {
   Object.assign(commands, commandMap);
@@ -907,7 +914,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -923,10 +930,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke$1(ipc, method, ...params);
+      return invoke$4(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$3(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1012,9 +1019,30 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$4
 };
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    return command(...params);
+  };
+  const mockRpc = {
+    invoke,
+    invokeAndTransfer: invoke,
+    invocations
+  };
+  return mockRpc;
+};
 
+const toCommandId = key => {
+  const dotIndex = key.indexOf('.');
+  return key.slice(dotIndex + 1);
+};
 const create$2 = () => {
   const states = Object.create(null);
+  const commandMapRef = {};
   return {
     get(uid) {
       return states[uid];
@@ -1055,6 +1083,15 @@ const create$2 = () => {
       };
       return wrapped;
     },
+    wrapGetter(fn) {
+      const wrapped = (uid, ...args) => {
+        const {
+          newState
+        } = states[uid];
+        return fn(newState, ...args);
+      };
+      return wrapped;
+    },
     diff(uid, modules, numbers) {
       const {
         oldState,
@@ -1068,6 +1105,14 @@ const create$2 = () => {
         }
       }
       return diffResult;
+    },
+    getCommandIds() {
+      const keys = Object.keys(commandMapRef);
+      const ids = keys.map(toCommandId);
+      return ids;
+    },
+    registerCommands(commandMap) {
+      Object.assign(commandMapRef, commandMap);
     }
   };
 };
@@ -1075,11 +1120,109 @@ const terminate = () => {
   globalThis.close();
 };
 
+const clear$1 = state => {
+  return {
+    ...state,
+    references: [],
+    displayReferences: [],
+    message: 'No Results'
+  };
+};
+
+const getBaseName = uri => {
+  if (!uri) {
+    return '';
+  }
+  return uri.slice(uri.lastIndexOf('/') + 1);
+};
+
+const Leaf = 1;
+const Expanded = 2;
+const Collapsed = 3;
+
+const getDisplayReferences = (references, icons, collapsedUris) => {
+  const displayReferences = [];
+  let currentUri = '';
+  let outerPosInSet = 1;
+  let innerPosInSet = 1;
+  let index = 0;
+  for (const reference of references) {
+    if (reference.uri === currentUri) {
+      displayReferences.push({
+        depth: 2,
+        posInSet: innerPosInSet++,
+        setSize: 1,
+        type: Leaf,
+        uri: '',
+        name: '',
+        lineText: reference.lineText || '',
+        icon: '',
+        index: index++,
+        startOffset: reference.startColumnIndex || reference.startOffset,
+        endOffset: reference.endColumnIndex || reference.endOffset
+      });
+    } else {
+      currentUri = reference.uri;
+      innerPosInSet = 1;
+      const name = getBaseName(reference.uri);
+      const relativeIndex = references.indexOf(reference);
+      const icon = icons[relativeIndex];
+      displayReferences.push({
+        depth: 1,
+        posInSet: outerPosInSet++,
+        setSize: 1,
+        type: Expanded,
+        uri: reference.uri,
+        name,
+        lineText: '',
+        icon,
+        index: index++,
+        startOffset: 0,
+        endOffset: 0
+      });
+      if (!collapsedUris.includes(reference.uri)) {
+        displayReferences.push({
+          depth: 2,
+          posInSet: innerPosInSet++,
+          setSize: 1,
+          type: Leaf,
+          uri: '',
+          name: '',
+          lineText: reference.lineText || '',
+          icon: '',
+          index: index++,
+          startOffset: reference.startColumnIndex || reference.startOffset,
+          endOffset: reference.endColumnIndex || reference.endOffset
+        });
+      }
+    }
+  }
+  return displayReferences;
+};
+
+const getUri$3 = reference => {
+  return reference.uri;
+};
+const collapseAll$1 = async state => {
+  const {
+    references
+  } = state;
+  const uris = references.map(getUri$3);
+  const displayReferences = getDisplayReferences(references, [], uris);
+  return {
+    ...state,
+    collapsedUris: uris,
+    displayReferences
+  };
+};
+
 const {
   get: get$1,
-  set: set$4,
+  set: set$7,
   wrapCommand,
-  dispose: dispose$1
+  dispose: dispose$4,
+  registerCommands,
+  getCommandIds
 } = create$2();
 
 const create$1 = (id, uri, x, y, width, height) => {
@@ -1092,9 +1235,10 @@ const create$1 = (id, uri, x, y, width, height) => {
     fileIconCache: {},
     offset: -1,
     uri: '',
-    languageId: ''
+    languageId: '',
+    collapsedUris: []
   };
-  set$4(id, state, state);
+  set$7(id, state, state);
 };
 
 const RenderItems = 1;
@@ -1127,8 +1271,8 @@ const diff2 = uid => {
   return diffResult;
 };
 
-const dispose = async uid => {
-  dispose$1(uid);
+const dispose$3 = async uid => {
+  dispose$4(uid);
 };
 
 const focusIndex = (state, index) => {
@@ -1177,40 +1321,27 @@ const focusPrevious = state => {
   return focusIndex(state, prevIndex);
 };
 
-const commandIds = ['create', 'dispose', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusPrevious', 'getKeyBindings', 'handleClickReference', 'restoreState', 'saveState', 'selectIndex', 'terminate'];
+const None = 'none';
+const Status = 'status';
+const Tree = 'tree';
 
-const getCommandIds = () => {
-  return commandIds;
-};
+const Button$1 = 1;
+const Div = 4;
+const Span = 8;
+const Text = 12;
+const Img = 17;
 
-const Status = 'status';
-const Tree$1 = 'tree';
-const AriaRoles = {
-  __proto__: null,
-  Status,
-  Tree: Tree$1};
 const Enter = 3;
 const End = 255;
 const Home = 12;
 const UpArrow = 14;
 const DownArrow = 16;
-const KeyCode = {
-  __proto__: null,
-  DownArrow,
-  End,
-  Enter,
-  Home,
-  UpArrow
-};
-const Div = 4;
-const Span = 8;
-const Text = 12;
-const Img = 17;
-const VirtualDomElements = {
-  __proto__: null,
-  Div,
-  Img,
-  Span};
+
+const DebugWorker = 55;
+const EditorWorker$1 = 99;
+const ExtensionHostWorker = 44;
+const RendererWorker$1 = 1;
+
 const text = data => {
   return {
     type: Text,
@@ -1221,34 +1352,30 @@ const text = data => {
 
 const FocusLocationList = 17;
 
-const getKeyBindings = () => {
+const getKeyBindings$1 = () => {
   return [{
-    key: KeyCode.DownArrow,
+    key: DownArrow,
     command: 'References.focusNext',
     when: FocusLocationList
   }, {
-    key: KeyCode.UpArrow,
+    key: UpArrow,
     command: 'References.focusPrevious',
     when: FocusLocationList
   }, {
-    key: KeyCode.Home,
+    key: Home,
     command: 'References.focusFirst',
     when: FocusLocationList
   }, {
-    key: KeyCode.End,
+    key: End,
     command: 'References.focusLast',
     when: FocusLocationList
   }, {
-    key: KeyCode.Enter,
+    key: Enter,
     command: 'References.selectCurrent',
     when: FocusLocationList
   }];
 };
 
-const Leaf = 1;
-const Expanded = 2;
-const Collapsed = 3;
-
 const selectIndexCollapsed = (state, index) => {
   // TODO collapse
 
@@ -1272,15 +1399,13 @@ const getUri$2 = (state, index) => {
 };
 
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set$6 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
 const create = rpcId => {
   return {
     // @ts-ignore
@@ -1296,7 +1421,7 @@ const create = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$g(rpcId, rpc);
+      set$6(rpcId, rpc);
     },
     async dispose() {
       const rpc = get(rpcId);
@@ -1304,83 +1429,497 @@ const create = rpcId => {
     }
   };
 };
-const EditorWorker$1 = 99;
-const ExtensionHostWorker = 44;
-const RendererWorker$1 = 1;
+
 const {
-  invoke: invoke$c,
-  set: set$c} = create(EditorWorker$1);
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
+  set: set$5,
+  dispose: dispose$2
+} = create(EditorWorker$1);
+const sendMessagePortToExtensionHostWorker$3 = async port => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer$2(
+  // @ts-ignore
+  'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, 0);
+};
+// TODO add tests for this
+const activateByEvent$2 = async event => {
+  // @ts-ignore
+  await invoke$3('ActivateByEvent.activateByEvent', event);
+};
+const applyEdit = async (editorUid, changes) => {
+  // @ts-ignore
+  await invoke$3('Editor.applyEdit2', editorUid, changes);
+};
+const applyWorkspaceEdit = async (editorUid, changes) => {
+  // @ts-ignore
+  await invoke$3('Editor.applyWorkspaceEdit', editorUid, changes);
+};
+const closeWidget$1 = async (editorUid, widgetId, widgetName, focusId) => {
+  // @ts-ignore
+  await invoke$3('Editor.closeWidget2', editorUid, widgetId, widgetName, focusId);
+};
+const getWordAt = async (uid, rowIndex, columnIndex) => {
+  // @ts-ignore
+  const word = await invoke$3('Editor.getWordAt2', uid, rowIndex, columnIndex);
+  return word;
+};
+const getLines = async editorUid => {
+  const lines = await invoke$3('Editor.getLines2', editorUid);
+  return lines;
+};
 const getPositionAtCursor$1 = async parentUid => {
-  const position = await invoke$c('Editor.getPositionAtCursor', parentUid);
+  const position = await invoke$3('Editor.getPositionAtCursor', parentUid);
   return position;
 };
 const getOffsetAtCursor$1 = async editorId => {
   // @ts-ignore
-  return await invoke$c('Editor.getOffsetAtCursor', editorId);
+  return await invoke$3('Editor.getOffsetAtCursor', editorId);
+};
+const getSelections = async editorUid => {
+  const selections = await invoke$3('Editor.getSelections2', editorUid);
+  return selections;
+};
+const getWordAtOffset2 = async editorUid => {
+  return invoke$3('Editor.getWordAtOffset2', editorUid);
+};
+const getWordBefore = async (editorUid, rowIndex, columnIndex) => {
+  return invoke$3('Editor.getWordBefore2', editorUid, rowIndex, columnIndex);
+};
+const updateDebugInfo = async info => {
+  await invoke$3('Editor.updateDebugInfo', info);
 };
 const getUri$1 = async editorUid => {
   // @ts-ignore
-  return invoke$c('Editor.getUri', editorUid);
+  return invoke$3('Editor.getUri', editorUid);
 };
 const getLanguageId$1 = async editorUid => {
   // @ts-ignore
-  return invoke$c('Editor.getLanguageId', editorUid);
+  return invoke$3('Editor.getLanguageId', editorUid);
 };
+const getProblems = async () => {
+  // @ts-ignore
+  return invoke$3('Editor.getProblems');
+};
+const registerMockRpc$2 = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$5(mockRpc);
+  return mockRpc;
+};
+
 const EditorWorker = {
   __proto__: null,
+  activateByEvent: activateByEvent$2,
+  applyEdit,
+  applyWorkspaceEdit,
+  closeWidget: closeWidget$1,
+  dispose: dispose$2,
   getLanguageId: getLanguageId$1,
+  getLines,
   getOffsetAtCursor: getOffsetAtCursor$1,
   getPositionAtCursor: getPositionAtCursor$1,
+  getProblems,
+  getSelections,
   getUri: getUri$1,
-  set: set$c};
+  getWordAt,
+  getWordAtOffset2,
+  getWordBefore,
+  invoke: invoke$3,
+  invokeAndTransfer: invokeAndTransfer$2,
+  registerMockRpc: registerMockRpc$2,
+  sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$3,
+  set: set$5,
+  updateDebugInfo
+};
+
 const {
-  invoke: invoke$9,
-  set: set$9} = create(ExtensionHostWorker);
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
+  set: set$4,
+  dispose: dispose$1
+} = create(ExtensionHostWorker);
+const executeReferenceProvider = async (id, offset) => {
+  // @ts-ignore
+  return invoke$2('ExtensionHostReference.executeReferenceProvider', id, offset);
+};
+const executeFileReferenceProvider = async id => {
+  // @ts-ignore
+  return invoke$2('ExtensionHostReference.executeFileReferenceProvider', id);
+};
+const getRuntimeStatus = async extensionId => {
+  // @ts-ignore
+  return invoke$2('ExtensionHost.getRuntimeStatus', extensionId);
+};
+const registerMockRpc$1 = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$4(mockRpc);
+  return mockRpc;
+};
+
 const ExtensionHost = {
   __proto__: null,
-  invoke: invoke$9,
-  set: set$9
+  dispose: dispose$1,
+  executeFileReferenceProvider,
+  executeReferenceProvider,
+  getRuntimeStatus,
+  invoke: invoke$2,
+  invokeAndTransfer: invokeAndTransfer$1,
+  registerMockRpc: registerMockRpc$1,
+  set: set$4
 };
+
 const {
-  invoke: invoke$3,
-  invokeAndTransfer: invokeAndTransfer$3,
-  set: set$3} = create(RendererWorker$1);
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$3,
+  dispose
+} = create(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke$1('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke$1('FileSystemHandle.getFilePathElectron', file);
+};
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke$1('ContextMenu.show', x, y, id, ...args);
+};
+const getElectronVersion = async () => {
+  return invoke$1('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke$1('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke$1(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke$1('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke$1('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke$1('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke$1('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke$1('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke$1('WebView.unregisterInterceptor', id);
+};
 const sendMessagePortToEditorWorker$2 = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+const sendMessagePortToErrorWorker = async (port, rpcId) => {
+  const command = 'Errors.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = 'Markdown.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
 };
 const readFile$2 = async uri => {
-  return invoke$3('FileSystem.readFile', uri);
+  return invoke$1('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke$1('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke$1('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke$1('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke$1('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  // @ts-ignore
+  return invoke$1('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke$1('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke$1('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke$1('IconTheme.getFolderIcon', options);
+};
+const closeWidget = async widgetId => {
+  return invoke$1('Viewlet.closeWidget', widgetId);
 };
 const sendMessagePortToExtensionHostWorker$2 = async (port, rpcId = 0) => {
   const command = 'HandleMessagePort.handleMessagePort2';
-  await invokeAndTransfer$3('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const confirm = async (message, options) => {
+  // @ts-ignore
+  const result = await invoke$1('ConfirmPrompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened = async () => {
+  return invoke$1(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings = async () => {
+  return invoke$1('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke$1('ClipBoard.writeText', /* text */text);
+};
+const writeClipBoardImage = async blob => {
+  // @ts-ignore
+  await invoke$1('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke$1('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke$1('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke$1('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke$1('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke$1('Viewlet.openWidget', name);
 };
 const getIcons$1 = async requests => {
-  const icons = await invoke$3('IconTheme.getIcons', requests);
+  const icons = await invoke$1('IconTheme.getIcons', requests);
   return icons;
 };
 const activateByEvent$1 = event => {
-  return invoke$3('ExtensionHostManagement.activateByEvent', event);
+  return invoke$1('ExtensionHostManagement.activateByEvent', event);
+};
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke$1('Focus.setAdditionalFocus', focusKey);
 };
 const getActiveEditorId$1 = () => {
   // @ts-ignore
-  return invoke$3('GetActiveEditor.getActiveEditorId');
+  return invoke$1('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke$1('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const getPreference = async key => {
+  return await invoke$1('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke$1('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke$1('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke$1('Run And Debug.handlePaused', params);
 };
 const openUri$1 = async (uri, focus, options) => {
-  await invoke$3('Main.openUri', uri, focus, options);
+  await invoke$1('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer(
+  // @ts-ignore
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+const handleDebugScriptParsed = async script => {
+  await invoke$1('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke$1('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke$1('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke$1('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke$1('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  // @ts-ignore
+  return await invoke$1('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke$1('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke$1('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke$1('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke$1('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke$1('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke$1('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke$1('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke$1('Extensions.handleInput', searchValue);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke$1('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke$1('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke$1('Preferences.getAll');
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke$1('FilePicker.showSaveFilePicker');
+};
+const getLogsDir = async () => {
+  // @ts-ignore
+  return invoke$1('PlatformPaths.getLogsDir');
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$3(mockRpc);
+  return mockRpc;
 };
+
 const RendererWorker = {
   __proto__: null,
   activateByEvent: activateByEvent$1,
+  applyBulkReplacement,
+  closeWidget,
+  confirm,
+  disableExtension,
+  dispose,
+  enableExtension,
   getActiveEditorId: getActiveEditorId$1,
+  getAllExtensions,
+  getAllPreferences,
+  getBlob,
+  getChromeVersion,
+  getColorThemeNames,
+  getElectronVersion,
+  getExtension,
+  getExtensionCommands,
+  getFileHandles,
+  getFileIcon,
+  getFilePathElectron,
+  getFolderIcon,
+  getFolderSize,
   getIcons: getIcons$1,
+  getKeyBindings,
+  getLogsDir,
+  getMarkdownDom,
+  getNodeVersion,
+  getPreference,
+  getRecentlyOpened,
+  getV8Version,
+  getWebViewSecret,
+  getWindowId,
+  getWorkspacePath,
+  handleDebugChange,
+  handleDebugPaused,
+  handleDebugResumed,
+  handleDebugScriptParsed,
+  installExtension,
+  invoke: invoke$1,
+  invokeAndTransfer,
+  openExtensionSearch,
+  openExternal,
+  openNativeFolder,
   openUri: openUri$1,
+  openUrl,
+  openWidget,
   readFile: readFile$2,
+  registerMockRpc,
+  registerWebViewInterceptor,
+  renderMarkdown,
+  rerenderEditor,
+  searchFileFetch,
+  searchFileHtml,
+  searchFileMemory,
   sendMessagePortToEditorWorker: sendMessagePortToEditorWorker$2,
+  sendMessagePortToErrorWorker,
   sendMessagePortToExtensionHostWorker: sendMessagePortToExtensionHostWorker$2,
-  set: set$3};
+  sendMessagePortToFileSystemWorker,
+  sendMessagePortToMarkdownWorker,
+  sendMessagePortToRendererProcess,
+  sendMessagePortToSearchProcess,
+  sendMessagePortToSyntaxHighlightingWorker,
+  set: set$3,
+  setAdditionalFocus,
+  setColorTheme,
+  setExtensionsSearchValue,
+  setFocus,
+  setWebViewPort,
+  setWorkspacePath,
+  showContextMenu,
+  showErrorDialog,
+  showMessageBox,
+  showSaveFilePicker,
+  uninstallExtension,
+  unregisterWebViewInterceptor,
+  writeClipBoardImage,
+  writeClipBoardText
+};
 
 const {
   set: set$2,
@@ -1531,71 +2070,6 @@ const restoreState = input => {
   };
 };
 
-const getBaseName = uri => {
-  if (!uri) {
-    return '';
-  }
-  return uri.slice(uri.lastIndexOf('/') + 1);
-};
-
-const getDisplayReferences = (references, icons) => {
-  const displayReferences = [];
-  let currentUri = '';
-  let outerPosInSet = 1;
-  let innerPosInSet = 1;
-  let index = 0;
-  for (const reference of references) {
-    if (reference.uri === currentUri) {
-      displayReferences.push({
-        depth: 2,
-        posInSet: innerPosInSet++,
-        setSize: 1,
-        type: Leaf,
-        uri: '',
-        name: '',
-        lineText: reference.lineText || '',
-        icon: '',
-        index: index++,
-        startOffset: reference.startColumnIndex || reference.startOffset,
-        endOffset: reference.endColumnIndex || reference.endOffset
-      });
-    } else {
-      currentUri = reference.uri;
-      innerPosInSet = 1;
-      const name = getBaseName(reference.uri);
-      const relativeIndex = references.indexOf(reference);
-      const icon = icons[relativeIndex];
-      displayReferences.push({
-        depth: 1,
-        posInSet: outerPosInSet++,
-        setSize: 1,
-        type: Expanded,
-        uri: reference.uri,
-        name,
-        lineText: '',
-        icon,
-        index: index++,
-        startOffset: 0,
-        endOffset: 0
-      });
-      displayReferences.push({
-        depth: 2,
-        posInSet: innerPosInSet++,
-        setSize: 1,
-        type: Leaf,
-        uri: '',
-        name: '',
-        lineText: reference.lineText || '',
-        icon: '',
-        index: index++,
-        startOffset: reference.startColumnIndex || reference.startOffset,
-        endOffset: reference.endColumnIndex || reference.endOffset
-      });
-    }
-  }
-  return displayReferences;
-};
-
 const getUniqueObjectCount = (objects, key) => {
   array(objects);
   string(key);
@@ -1654,7 +2128,7 @@ const manyResultsInManyFiles = (resultCount, fileCount) => {
     PH2: fileCount
   });
 };
-const refresh = () => {
+const refresh$1 = () => {
   return i18nString(Refresh$1);
 };
 const clear = () => {
@@ -1780,7 +2254,8 @@ const requestFileIcons = async references => {
 const updateReferences = async (state, uri, languageId, offset, position) => {
   const references = await getReferences2(uri, languageId, offset, position);
   const icons = await requestFileIcons(references);
-  const displayReferences = getDisplayReferences(references, icons);
+  const collapseduris = [];
+  const displayReferences = getDisplayReferences(references, icons, collapseduris);
   const fileCount = getFileCount(references);
   const message = getMessage(references.length, fileCount);
   return {
@@ -1809,6 +2284,9 @@ const getAndUpdateReferences = async state => {
   return updateReferences(state, uri, languageId, offset, position);
 };
 
+const isMemory = uri => {
+  return uri.startsWith('memfs://');
+};
 const loadContent = async (state, savedState) => {
   try {
     const {
@@ -1817,7 +2295,7 @@ const loadContent = async (state, savedState) => {
       languageId,
       position
     } = restoreState(savedState);
-    if (uri) {
+    if (uri && !isMemory(uri)) {
       return updateReferences(state, uri, languageId, offset, position);
     }
     return getAndUpdateReferences(state);
@@ -1830,12 +2308,17 @@ const loadContent = async (state, savedState) => {
   }
 };
 
+const refresh = async state => {
+  return state;
+};
+
 const FileIcon = 'FileIcon';
 const Highlight = 'Highlight';
 const Label = 'Label';
 const LocationList = 'LocationList';
 const LocationsMessage = 'LocationsMessage';
 const TreeItem = 'TreeItem';
+const IconButton = 'IconButton';
 
 const HandleClickReference = 'handleClickReference';
 
@@ -1845,7 +2328,7 @@ const getCollapsedVirtualDom = location => {
     name
   } = location;
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: TreeItem,
     ariaExpanded: false,
     id: `Reference-${index}`,
@@ -1862,7 +2345,7 @@ const getExpandedVirtualDom = location => {
     icon
   } = location;
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: TreeItem,
     ariaExpanded: true,
     id: `Reference-${index}`,
@@ -1871,7 +2354,7 @@ const getExpandedVirtualDom = location => {
     childCount: 2,
     paddingLeft: '1rem'
   }, {
-    type: VirtualDomElements.Img,
+    type: Img,
     className: FileIcon,
     src: icon
   }, text(name)];
@@ -1882,11 +2365,11 @@ const getLabelDomHighlight = (lineText, startOffset, endOffset) => {
   const middle = lineText.slice(startOffset, endOffset);
   const end = lineText.slice(endOffset);
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: Label,
     childCount: 3
   }, text(before), {
-    type: VirtualDomElements.Span,
+    type: Span,
     className: Highlight,
     childCount: 1
   }, text(middle), text(end)];
@@ -1894,7 +2377,7 @@ const getLabelDomHighlight = (lineText, startOffset, endOffset) => {
 
 const getLabelDomNoHighlight = lineText => {
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: Label,
     childCount: 1
   }, text(lineText || '(empty line)')];
@@ -1917,7 +2400,7 @@ const getLeafVirtualDom = location => {
     index
   } = location;
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: TreeItem,
     id: `Reference-${index}`,
     'data-index': index,
@@ -1945,20 +2428,20 @@ const getLocationVirtualDom = location => {
 
 const getLocationsVirtualDom = (locations$1, message) => {
   return [{
-    type: VirtualDomElements.Div,
+    type: Div,
     className: 'Viewlet Locations',
     onMouseDown: HandleClickReference,
     childCount: 2
   }, {
-    type: VirtualDomElements.Div,
+    type: Div,
     className: LocationsMessage,
     id: 'LocationsMessage',
-    role: AriaRoles.Status,
+    role: Status,
     childCount: 1
   }, text(message), {
-    type: VirtualDomElements.Div,
+    type: Div,
     className: LocationList,
-    role: AriaRoles.Tree,
+    role: Tree,
     ariaLabel: locations(),
     tabIndex: 0,
     ariaDescribedBy: 'LocationsMessage',
@@ -1994,35 +2477,67 @@ const render2 = (uid, diffResult) => {
     oldState,
     newState
   } = get$1(uid);
-  set$4(uid, newState, newState);
+  set$7(uid, newState, newState);
   const commands = applyRender(oldState, newState, diffResult);
   return commands;
 };
 
 const Button = 1;
 
+const getIconVirtualDom = (icon, type = Div) => {
+  return {
+    type,
+    className: `MaskIcon MaskIcon${icon}`,
+    role: None,
+    childCount: 0
+  };
+};
+
+const getActionButtonVirtualDom = action => {
+  const {
+    id,
+    icon,
+    command
+  } = action;
+  return [{
+    type: Button$1,
+    className: IconButton,
+    title: id,
+    'data-command': command,
+    childCount: 1
+  }, getIconVirtualDom(icon || '')];
+};
+
 const ClearAll = 'ClearAll';
 const CollapseAll = 'CollapseAll';
 const Refresh = 'Refresh';
 
-const renderActions = () => {
+const getActionButtons = () => {
   return [{
     type: Button,
-    id: refresh(),
+    id: refresh$1(),
     icon: Refresh,
-    command: 'References.refresh'
+    command: 'refresh'
   }, {
     type: Button,
     id: clear(),
     icon: ClearAll,
-    command: 'References.clear'
+    command: 'clear'
   }, {
     type: Button,
     id: collapseAll(),
     icon: CollapseAll,
-    command: 'References.collapseAll'
+    command: 'collapseAll'
   }];
 };
+const renderActions = () => {
+  const buttons = getActionButtons();
+  return [{
+    type: Div,
+    className: 'Actions',
+    childCount: buttons.length
+  }, ...buttons.flatMap(getActionButtonVirtualDom)];
+};
 
 const renderEventListeners = () => {
   return [{
@@ -2052,20 +2567,23 @@ const saveState = id => {
 };
 
 const commandMap = {
+  'References.clear': wrapCommand(clear$1),
   'References.create': create$1,
   'References.diff2': diff2,
-  'References.dispose': dispose,
+  'References.dispose': dispose$3,
   'References.focusFirst': wrapCommand(focusFirst),
   'References.focusIndex': wrapCommand(focusIndex),
   'References.focusLast': wrapCommand(focusLast),
   'References.focusNext': wrapCommand(focusNext),
   'References.focusPrevious': wrapCommand(focusPrevious),
   'References.getCommandIds': getCommandIds,
-  'References.getKeyBindings': getKeyBindings,
+  'References.getKeyBindings': getKeyBindings$1,
   'References.handleClickReference': wrapCommand(handleClickReference),
   'References.initialize': initialize,
   'References.loadContent': wrapCommand(loadContent),
+  'References.refresh': wrapCommand(refresh),
   'References.render2': render2,
+  'References.collapseAll': wrapCommand(collapseAll$1),
   'References.renderActions': renderActions,
   'References.renderEventListeners': renderEventListeners,
   'References.restoreState': restoreState,
@@ -2075,6 +2593,7 @@ const commandMap = {
 };
 
 const listen = async () => {
+  registerCommands(commandMap);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap
   });