@lvce-editor/static-server 0.69.2 → 0.69.4

package/static/{5f26f20 → 7250be5}/packages/file-search-worker/dist/fileSearchWorkerMain.js

@@ -429,6 +429,100 @@ const IpcChildWithModuleWorkerAndMessagePort$1 = {
   listen: listen$6,
   wrap: wrap$e
 };
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
+  const {
+    resolve,
+    promise
+  } = Promise.withResolvers();
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        type,
+        event
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
+};
+const Message$1 = 3;
+const create$5$1 = async ({
+  messagePort,
+  isMessagePortOpen
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
+  }
+  if (isMessagePortOpen) {
+    return messagePort;
+  }
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    type,
+    event
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
+  }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    this._rawIpc.close();
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+  }
+  onClose(callback) {}
+}
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
+};
+const IpcParentWithMessagePort$1 = {
+  __proto__: null,
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
+};
 
 const Two = '2.0';
 const create$4$1 = (method, params) => {
@@ -449,11 +543,11 @@ const remove = id => {
   delete callbacks[id];
 };
 let id = 0;
-const create$3$1 = () => {
+const create$3$2 = () => {
   return ++id;
 };
 const registerPromise = () => {
-  const id = create$3$1();
+  const id = create$3$2();
   const {
     resolve,
     promise
@@ -553,7 +647,7 @@ const getParentStack = error => {
   return parentStack;
 };
 const MethodNotFound = -32601;
-const Custom$1 = -32001;
+const Custom$2 = -32001;
 const restoreJsonRpcError = error => {
   const currentStack = getCurrentStack();
   if (error && error instanceof Error) {
@@ -662,7 +756,7 @@ const getErrorProperty = (error, prettyError) => {
     };
   }
   return {
-    code: Custom$1,
+    code: Custom$2,
     message: prettyError.message,
     data: {
       stack: getStack(prettyError),
@@ -686,7 +780,7 @@ const getErrorResponse = (id, error, preparePrettyError, logError) => {
   const errorProperty = getErrorProperty(error, prettyError);
   return create$1$1(id, errorProperty);
 };
-const create$5 = (message, result) => {
+const create$6 = (message, result) => {
   return {
     jsonrpc: Two,
     id: message.id,
@@ -695,14 +789,14 @@ const create$5 = (message, result) => {
 };
 const getSuccessResponse = (message, result) => {
   const resultProperty = result ?? null;
-  return create$5(message, resultProperty);
+  return create$6(message, resultProperty);
 };
 const getErrorResponseSimple = (id, error) => {
   return {
     jsonrpc: Two,
     id,
     error: {
-      code: Custom$1,
+      code: Custom$2,
       // @ts-ignore
       message: error.message,
       data: error
@@ -823,7 +917,7 @@ const register$1 = commandMap => {
 const getCommand = key => {
   return commands[key];
 };
-const execute$1 = (command, ...args) => {
+const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
     throw new CommandNotFoundError(command);
@@ -864,7 +958,7 @@ const logError = () => {
 };
 const handleMessage = event => {
   const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
-  const actualExecute = event?.target?.execute || execute$1;
+  const actualExecute = event?.target?.execute || execute;
   return handleJsonRpcMessage(event.target, event.data, actualExecute, resolve, preparePrettyError, logError, actualRequiresSocket);
 };
 const handleIpc = ipc => {
@@ -883,6 +977,40 @@ const listen$1 = async (module, options) => {
   const ipc = module.wrap(rawIpc);
   return ipc;
 };
+const create$5 = async ({
+  commandMap,
+  messagePort
+}) => {
+  // TODO create a commandMap per rpc instance
+  register$1(commandMap);
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    messagePort,
+    isMessagePortOpen: true
+  });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  messagePort.start();
+  return rpc;
+};
+const create$3$1 = async ({
+  commandMap,
+  send
+}) => {
+  const {
+    port1,
+    port2
+  } = new MessageChannel();
+  await send(port1);
+  return create$5({
+    commandMap,
+    messagePort: port2
+  });
+};
+const TransferMessagePortRpcParent = {
+  __proto__: null,
+  create: create$3$1
+};
 const create$4 = async ({
   commandMap
 }) => {
@@ -897,25 +1025,6 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$4
 };
-const createMockRpc = ({
-  commandMap
-}) => {
-  const invocations = [];
-  const invoke = (method, ...params) => {
-    invocations.push([method, ...params]);
-    const command = commandMap[method];
-    if (!command) {
-      throw new Error(`command ${method} not found`);
-    }
-    return command(...params);
-  };
-  const mockRpc = {
-    invoke,
-    invokeAndTransfer: invoke,
-    invocations
-  };
-  return mockRpc;
-};
 
 const Div = 4;
 const Input = 6;
@@ -923,8 +1032,10 @@ const Span = 8;
 const Text = 12;
 const Img = 17;
 
-const DebugWorker = 55;
-const RendererWorker$1 = 1;
+const EditorWorker = 99;
+const RendererWorker = 1;
+
+const FocusQuickPickInput = 20;
 
 const rpcs = Object.create(null);
 const set$3 = (id, rpc) => {
@@ -960,369 +1071,44 @@ const create$3 = rpcId => {
 
 const {
   invoke: invoke$2,
-  invokeAndTransfer,
-  set: set$2,
-  dispose: dispose$2
-} = create$3(RendererWorker$1);
-const searchFileHtml = async uri => {
-  return invoke$2('ExtensionHost.searchFileWithHtml', uri);
-};
-const getFilePathElectron = async file => {
-  return invoke$2('FileSystemHandle.getFilePathElectron', file);
-};
-const showContextMenu = async (x, y, id, ...args) => {
-  return invoke$2('ContextMenu.show', x, y, id, ...args);
-};
-const getElectronVersion = async () => {
-  return invoke$2('Process.getElectronVersion');
-};
-const applyBulkReplacement = async bulkEdits => {
-  await invoke$2('BulkReplacement.applyBulkReplacement', bulkEdits);
-};
-const setColorTheme$1 = async id => {
-  // @ts-ignore
-  return invoke$2(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
-};
-const getNodeVersion = async () => {
-  return invoke$2('Process.getNodeVersion');
-};
-const getChromeVersion = async () => {
-  return invoke$2('Process.getChromeVersion');
-};
-const getV8Version = async () => {
-  return invoke$2('Process.getV8Version');
-};
-const getFileHandles = async fileIds => {
-  const files = await invoke$2('FileSystemHandle.getFileHandles', fileIds);
-  return files;
-};
-const setWorkspacePath = async path => {
-  await invoke$2('Workspace.setPath', path);
-};
-const registerWebViewInterceptor = async (id, port) => {
-  await invokeAndTransfer('WebView.registerInterceptor', id, port);
-};
-const unregisterWebViewInterceptor = async id => {
-  await invoke$2('WebView.unregisterInterceptor', id);
+  set: set$2} = create$3(EditorWorker);
+const getLines = async editorUid => {
+  const lines = await invoke$2('Editor.getLines2', editorUid);
+  return lines;
 };
+
+const {
+  invoke: invoke$1,
+  invokeAndTransfer,
+  set: set$1} = create$3(RendererWorker);
 const sendMessagePortToEditorWorker = async (port, rpcId) => {
   const command = 'HandleMessagePort.handleMessagePort';
   // @ts-ignore
   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 sendMessagePortToIconThemeWorker = async (port, rpcId) => {
-  const command = 'IconTheme.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
-};
-const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
-  const command = 'FileSystem.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
-};
-const readFile = async uri => {
-  return invoke$2('FileSystem.readFile', uri);
-};
-const getWebViewSecret = async key => {
-  // @ts-ignore
-  return invoke$2('WebView.getSecret', key);
+const setFocus = key => {
+  return invoke$1('Focus.setFocus', key);
 };
-const setWebViewPort = async (uid, port, origin, portType) => {
-  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+const getFileIcon = async options => {
+  return invoke$1('IconTheme.getFileIcon', options);
 };
-const setFocus$2 = key => {
-  return invoke$2('Focus.setFocus', key);
+const getFolderIcon = async options => {
+  return invoke$1('IconTheme.getFolderIcon', options);
 };
-const getFileIcon$1 = async options => {
-  return invoke$2('IconTheme.getFileIcon', options);
-};
-const getColorThemeNames$1 = async () => {
-  return invoke$2('ColorTheme.getColorThemeNames');
-};
-const disableExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.disable', id);
-};
-const enableExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.enable', id);
-};
-const handleDebugChange = async params => {
-  // @ts-ignore
-  return invoke$2('Run And Debug.handleChange', params);
-};
-const getFolderIcon$1 = async options => {
-  return invoke$2('IconTheme.getFolderIcon', options);
-};
-const closeWidget$2 = async widgetId => {
-  return invoke$2('Viewlet.closeWidget', widgetId);
-};
-const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
-  const command = 'HandleMessagePort.handleMessagePort2';
-  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$2('ConfirmPrompt.prompt', message, options);
-  return result;
-};
-const getRecentlyOpened$1 = async () => {
-  return invoke$2(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
-};
-const getKeyBindings$1 = async () => {
-  return invoke$2('KeyBindingsInitial.getKeyBindings');
-};
-const writeClipBoardText = async text => {
-  await invoke$2('ClipBoard.writeText', /* text */text);
-};
-const writeClipBoardImage = async blob => {
-  // @ts-ignore
-  await invoke$2('ClipBoard.writeImage', /* text */blob);
-};
-const searchFileMemory = async uri => {
-  // @ts-ignore
-  return invoke$2('ExtensionHost.searchFileWithMemory', uri);
-};
-const searchFileFetch = async uri => {
-  return invoke$2('ExtensionHost.searchFileWithFetch', uri);
-};
-const showMessageBox = async options => {
-  return invoke$2('ElectronDialog.showMessageBox', options);
-};
-const handleDebugResumed = async params => {
-  await invoke$2('Run And Debug.handleResumed', params);
-};
-const openWidget = async name => {
-  await invoke$2('Viewlet.openWidget', name);
-};
-const getIcons = async requests => {
-  const icons = await invoke$2('IconTheme.getIcons', requests);
-  return icons;
-};
-const activateByEvent = event => {
-  return invoke$2('ExtensionHostManagement.activateByEvent', event);
-};
-const setAdditionalFocus = focusKey => {
-  // @ts-ignore
-  return invoke$2('Focus.setAdditionalFocus', focusKey);
+const closeWidget$1 = async widgetId => {
+  return invoke$1('Viewlet.closeWidget', widgetId);
 };
 const getActiveEditorId = () => {
   // @ts-ignore
-  return invoke$2('GetActiveEditor.getActiveEditorId');
-};
-const getWorkspacePath$1 = () => {
-  return invoke$2('Workspace.getPath');
-};
-const sendMessagePortToRendererProcess = async port => {
-  const command = 'HandleMessagePort.handleMessagePort';
-  // @ts-ignore
-  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+  return invoke$1('GetActiveEditor.getActiveEditorId');
 };
-const getPreference = async key => {
-  return await invoke$2('Preferences.get', key);
-};
-const getAllExtensions = async () => {
-  return invoke$2('ExtensionManagement.getAllExtensions');
-};
-const rerenderEditor = async key => {
-  // @ts-ignore
-  return invoke$2('Editor.rerender', key);
-};
-const handleDebugPaused = async params => {
-  await invoke$2('Run And Debug.handlePaused', params);
-};
-const openUri$2 = async (uri, focus, options) => {
-  await invoke$2('Main.openUri', uri, focus, options);
-};
-const sendMessagePortToSyntaxHighlightingWorker = async port => {
-  await invokeAndTransfer(
-  // @ts-ignore
-  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
-};
-const handleDebugScriptParsed = async script => {
-  await invoke$2('Run And Debug.handleScriptParsed', script);
-};
-const getWindowId = async () => {
-  return invoke$2('GetWindowId.getWindowId');
-};
-const getBlob = async uri => {
-  // @ts-ignore
-  return invoke$2('FileSystem.getBlob', uri);
-};
-const getExtensionCommands = async () => {
-  return invoke$2('ExtensionHost.getCommands');
-};
-const showErrorDialog$2 = async errorInfo => {
-  // @ts-ignore
-  await invoke$2('ErrorHandling.showErrorDialog', errorInfo);
+const openUri$1 = async (uri, focus, options) => {
+  await invoke$1('Main.openUri', uri, focus, options);
 };
-const getFolderSize = async uri => {
+const showErrorDialog$1 = async errorInfo => {
   // @ts-ignore
-  return await invoke$2('FileSystem.getFolderSize', uri);
+  await invoke$1('ErrorHandling.showErrorDialog', errorInfo);
 };
-const getExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.getExtension', id);
-};
-const getMarkdownDom = async html => {
-  // @ts-ignore
-  return invoke$2('Markdown.getVirtualDom', html);
-};
-const renderMarkdown = async (markdown, options) => {
-  // @ts-ignore
-  return invoke$2('Markdown.renderMarkdown', markdown, options);
-};
-const openNativeFolder = async uri => {
-  // @ts-ignore
-  await invoke$2('OpenNativeFolder.openNativeFolder', uri);
-};
-const uninstallExtension = async id => {
-  return invoke$2('ExtensionManagement.uninstall', id);
-};
-const installExtension = async id => {
-  // @ts-ignore
-  return invoke$2('ExtensionManagement.install', id);
-};
-const openExtensionSearch = async () => {
-  // @ts-ignore
-  return invoke$2('SideBar.openViewlet', 'Extensions');
-};
-const setExtensionsSearchValue = async searchValue => {
-  // @ts-ignore
-  return invoke$2('Extensions.handleInput', searchValue);
-};
-const openExternal = async uri => {
-  // @ts-ignore
-  await invoke$2('Open.openExternal', uri);
-};
-const openUrl = async uri => {
-  // @ts-ignore
-  await invoke$2('Open.openUrl', uri);
-};
-const getAllPreferences = async () => {
-  // @ts-ignore
-  return invoke$2('Preferences.getAll');
-};
-const showSaveFilePicker = async () => {
-  // @ts-ignore
-  return invoke$2('FilePicker.showSaveFilePicker');
-};
-const getLogsDir = async () => {
-  // @ts-ignore
-  return invoke$2('PlatformPaths.getLogsDir');
-};
-const registerMockRpc = commandMap => {
-  const mockRpc = createMockRpc({
-    commandMap
-  });
-  set$2(mockRpc);
-  return mockRpc;
-};
-
-const RendererWorker = {
-  __proto__: null,
-  activateByEvent,
-  applyBulkReplacement,
-  closeWidget: closeWidget$2,
-  confirm,
-  disableExtension,
-  dispose: dispose$2,
-  enableExtension,
-  getActiveEditorId,
-  getAllExtensions,
-  getAllPreferences,
-  getBlob,
-  getChromeVersion,
-  getColorThemeNames: getColorThemeNames$1,
-  getElectronVersion,
-  getExtension,
-  getExtensionCommands,
-  getFileHandles,
-  getFileIcon: getFileIcon$1,
-  getFilePathElectron,
-  getFolderIcon: getFolderIcon$1,
-  getFolderSize,
-  getIcons,
-  getKeyBindings: getKeyBindings$1,
-  getLogsDir,
-  getMarkdownDom,
-  getNodeVersion,
-  getPreference,
-  getRecentlyOpened: getRecentlyOpened$1,
-  getV8Version,
-  getWebViewSecret,
-  getWindowId,
-  getWorkspacePath: getWorkspacePath$1,
-  handleDebugChange,
-  handleDebugPaused,
-  handleDebugResumed,
-  handleDebugScriptParsed,
-  installExtension,
-  invoke: invoke$2,
-  invokeAndTransfer,
-  openExtensionSearch,
-  openExternal,
-  openNativeFolder,
-  openUri: openUri$2,
-  openUrl,
-  openWidget,
-  readFile,
-  registerMockRpc,
-  registerWebViewInterceptor,
-  renderMarkdown,
-  rerenderEditor,
-  searchFileFetch,
-  searchFileHtml,
-  searchFileMemory,
-  sendMessagePortToEditorWorker,
-  sendMessagePortToErrorWorker,
-  sendMessagePortToExtensionHostWorker,
-  sendMessagePortToFileSystemWorker,
-  sendMessagePortToIconThemeWorker,
-  sendMessagePortToMarkdownWorker,
-  sendMessagePortToRendererProcess,
-  sendMessagePortToSearchProcess,
-  sendMessagePortToSyntaxHighlightingWorker,
-  set: set$2,
-  setAdditionalFocus,
-  setColorTheme: setColorTheme$1,
-  setExtensionsSearchValue,
-  setFocus: setFocus$2,
-  setWebViewPort,
-  setWorkspacePath,
-  showContextMenu,
-  showErrorDialog: showErrorDialog$2,
-  showMessageBox,
-  showSaveFilePicker,
-  uninstallExtension,
-  unregisterWebViewInterceptor,
-  writeClipBoardImage,
-  writeClipBoardText
-};
-
-const {
-  invoke: invoke$1,
-  set: set$1,
-  setFocus: setFocus$1,
-  closeWidget: closeWidget$1,
-  showErrorDialog: showErrorDialog$1,
-  openUri: openUri$1,
-  getFileIcon,
-  getFolderIcon
-} = RendererWorker;
 
 const closeWidget = async id => {
   // @ts-ignore
@@ -1375,10 +1161,11 @@ const create$2 = () => {
     wrapCommand(fn) {
       const wrapped = async (uid, ...args) => {
         const {
+          oldState,
           newState
         } = states[uid];
         const newerState = await fn(newState, ...args);
-        if (newState === newerState) {
+        if (oldState === newerState || newState === newerState) {
           return;
         }
         const latest = states[uid];
@@ -1424,32 +1211,34 @@ const create$2 = () => {
 };
 
 const {
+  dispose: dispose$1,
   get,
+  getCommandIds,
+  registerCommands,
   set,
-  dispose: dispose$1,
   wrapCommand
 } = create$2();
 
 const create$1 = ({
-  itemHeight,
   headerHeight = 0,
+  itemHeight,
   minimumSliderSize = 20
 }) => {
   return {
     deltaY: 0,
-    minLineY: 0,
-    maxLineY: 0,
     finalDeltaY: 0,
-    itemHeight,
+    focusedIndex: -1,
     headerHeight,
+    itemHeight,
     items: [],
+    maxLineY: 0,
     minimumSliderSize,
-    focusedIndex: -1,
-    touchOffsetY: 0,
-    touchTimeStamp: 0,
-    touchDifference: 0,
+    minLineY: 0,
+    scrollBarActive: false,
     scrollBarHeight: 0,
-    scrollBarActive: false
+    touchDifference: 0,
+    touchOffsetY: 0,
+    touchTimeStamp: 0
   };
 };
 const getListHeight$1 = (height, headerHeight) => {
@@ -1462,10 +1251,10 @@ const setDeltaY = (state, deltaY) => {
   object(state);
   number(deltaY);
   const {
-    itemHeight,
-    items,
+    headerHeight,
     height,
-    headerHeight
+    itemHeight,
+    items
   } = state;
   const listHeight = getListHeight$1(height, headerHeight);
   const itemsLength = items.length;
@@ -1485,8 +1274,8 @@ const setDeltaY = (state, deltaY) => {
   return {
     ...state,
     deltaY,
-    minLineY,
-    maxLineY
+    maxLineY,
+    minLineY
   };
 };
 const handleWheel = (state, deltaMode, deltaY) => {
@@ -1498,32 +1287,32 @@ const handleWheel = (state, deltaMode, deltaY) => {
 
 const create = (uid, uri, listItemHeight, x, y, width, height, platform, args, workspaceUri) => {
   const state = {
-    workspaceUri,
-    uid,
+    cursorOffset: 0,
+    height: 300,
     icons: [],
-    state: Default$1,
+    maxVisibleItems: 10,
     picks: [],
-    recentPicks: [],
     recentPickIds: Object.create(null),
+    recentPicks: [],
+    state: Default$1,
+    top: 50,
+    uid,
+    uri,
     versionId: 0,
     warned: [],
-    maxVisibleItems: 10,
-    uri,
-    cursorOffset: 0,
-    height: 300,
-    top: 50,
     width: 600,
+    workspaceUri,
     ...create$1({
-      itemHeight: listItemHeight,
       headerHeight: 38,
+      itemHeight: listItemHeight,
       minimumSliderSize: minimumSliderSize
     }),
-    inputSource: User,
     args,
+    fileIconCache: Object.create(null),
     focused: false,
+    inputSource: User,
     platform,
-    value: '',
-    fileIconCache: Object.create(null)
+    value: ''
   };
   set(uid, state, state);
 };
@@ -1576,8 +1365,8 @@ const diff = (oldState, newState) => {
 
 const diff2 = uid => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   return diff(oldState, newState);
 };
@@ -1591,33 +1380,36 @@ const setColorTheme = id => {
 };
 
 const focusPick$1 = async pick => {
-  const label = pick.label;
-  await setColorTheme(/* colorThemeId */label);
+  const {
+    label
+  } = pick;
+  await setColorTheme(label);
 };
 
 const ColorTheme$1 = 0;
 const Commands$1 = 1;
-const Custom = 2;
+const Custom$1 = 2;
 const File$2 = 3;
-const GoToLine$2 = 4;
-const Help$2 = 5;
-const Recent$1 = 6;
-const Symbol$2 = 7;
-const View$3 = 8;
-const WorkspaceSymbol$2 = 9;
+const GoToColumn$1 = 4;
+const GoToLine$2 = 5;
+const Help$2 = 6;
+const Recent$1 = 7;
+const Symbol$2 = 8;
+const View$3 = 9;
+const WorkspaceSymbol$2 = 10;
 const EveryThing$1 = 100;
 
-const noop$2 = async () => {};
-const getFn$3 = id => {
+const noop$1 = async () => {};
+const getFn$2 = id => {
   switch (id) {
     case ColorTheme$1:
       return focusPick$1;
     default:
-      return noop$2;
+      return noop$1;
   }
 };
 const focusPick = (id, pick) => {
-  const fn = getFn$3(id);
+  const fn = getFn$2(id);
   return fn(pick);
 };
 
@@ -1633,9 +1425,9 @@ const getMissingIconRequests = (dirents, fileIconCache) => {
     }
     if (!(dirent.path in fileIconCache)) {
       missingRequests.push({
-        type: dirent.type,
         name: dirent.name,
-        path: dirent.path
+        path: dirent.path,
+        type: dirent.type
       });
     }
   }
@@ -1681,9 +1473,9 @@ const getPath = dirent => {
 };
 const toDirent = pick => {
   const dirent = {
-    type: pick.direntType,
     name: pick.label,
-    path: pick.uri
+    path: pick.uri,
+    type: pick.direntType
   };
   return dirent;
 };
@@ -1702,12 +1494,12 @@ const getQuickPickFileIcons = async (items, fileIconCache) => {
 
 const focusIndex = async (state, index) => {
   const {
-    providerId,
-    maxVisibleItems,
+    fileIconCache,
     items,
-    minLineY,
     maxLineY,
-    fileIconCache
+    maxVisibleItems,
+    minLineY,
+    providerId
   } = state;
   await focusPick(providerId, items[index]);
   if (index < minLineY + 1) {
@@ -1715,18 +1507,18 @@ const focusIndex = async (state, index) => {
     const maxLineY = Math.min(index + maxVisibleItems, items.length - 1);
     const sliced = items.slice(minLineY, maxLineY);
     const {
-      newFileIconCache,
-      icons
+      icons,
+      newFileIconCache
     } = await getQuickPickFileIcons(sliced, fileIconCache);
 
     // TODO need to scroll up
     return {
       ...state,
-      minLineY,
-      maxLineY,
+      fileIconCache: newFileIconCache,
       focusedIndex: index,
       icons,
-      fileIconCache: newFileIconCache
+      maxLineY,
+      minLineY
     };
   }
   if (index >= maxLineY - 1) {
@@ -1735,27 +1527,27 @@ const focusIndex = async (state, index) => {
     const minLineY = Math.max(maxLineY - maxVisibleItems, 0);
     const sliced = items.slice(minLineY, maxLineY);
     const {
-      newFileIconCache,
-      icons
+      icons,
+      newFileIconCache
     } = await getQuickPickFileIcons(sliced, fileIconCache);
     return {
       ...state,
-      minLineY,
-      maxLineY,
-      focusedIndex: index,
       fileIconCache: newFileIconCache,
-      icons
+      focusedIndex: index,
+      icons,
+      maxLineY,
+      minLineY
     };
   }
   const sliced = items.slice(minLineY, maxLineY);
   const {
-    newFileIconCache,
-    icons
+    icons,
+    newFileIconCache
   } = await getQuickPickFileIcons(sliced, fileIconCache);
   return {
     ...state,
-    focusedIndex: index,
     fileIconCache: newFileIconCache,
+    focusedIndex: index,
     icons
   };
 };
@@ -1786,8 +1578,8 @@ const focusLast = state => {
 
 const focusNext = state => {
   const {
-    items,
-    focusedIndex
+    focusedIndex,
+    items
   } = state;
   const nextIndex = next(items, focusedIndex);
   return focusIndex(state, nextIndex);
@@ -1795,19 +1587,13 @@ const focusNext = state => {
 
 const focusPrevious = state => {
   const {
-    items,
-    focusedIndex
+    focusedIndex,
+    items
   } = state;
   const previousIndex = previous(items, focusedIndex);
   return focusIndex(state, previousIndex);
 };
 
-const commandIds = ['close', 'dispose', 'focusFirst', 'focusIndex', 'focusLast', 'focusNext', 'focusPrevious', 'handleBeforeInput', 'handleBlur', 'handleClickAt', 'diff2', 'handleFocus', 'handleInput', 'handleWheel', 'renderEventListeners', 'selectCurrentIndex', 'selectIndex', 'selectItem', 'setValue'];
-
-const getCommandIds = () => {
-  return commandIds;
-};
-
 const Enter = 3;
 const Escape = 8;
 const PageUp = 10;
@@ -1815,33 +1601,31 @@ const PageDown = 11;
 const UpArrow = 14;
 const DownArrow = 16;
 
-const FocusQuickPickInput = 20;
-
 const getKeyBindings = () => {
   return [{
-    key: Escape,
-    command: 'Viewlet.closeWidget',
     args: ['QuickPick'],
+    command: 'Viewlet.closeWidget',
+    key: Escape,
     when: FocusQuickPickInput
   }, {
-    key: UpArrow,
     command: 'QuickPick.focusPrevious',
+    key: UpArrow,
     when: FocusQuickPickInput
   }, {
-    key: DownArrow,
     command: 'QuickPick.focusNext',
+    key: DownArrow,
     when: FocusQuickPickInput
   }, {
-    key: PageUp,
     command: 'QuickPick.focusFirst',
+    key: PageUp,
     when: FocusQuickPickInput
   }, {
-    key: PageDown,
     command: 'QuickPick.focusLast',
+    key: PageDown,
     when: FocusQuickPickInput
   }, {
-    key: Enter,
     command: 'QuickPick.selectCurrentIndex',
+    key: Enter,
     when: FocusQuickPickInput
   }];
 };
@@ -1852,15 +1636,15 @@ const getNewValueDeleteContentBackward = (value, selectionStart, selectionEnd, d
     const before = value.slice(0, selectionStart - 1);
     const newValue = before + after;
     return {
-      newValue,
-      cursorOffset: before.length
+      cursorOffset: before.length,
+      newValue
     };
   }
   const before = value.slice(0, selectionStart);
   const newValue = before + after;
   return {
-    newValue,
-    cursorOffset: selectionStart
+    cursorOffset: selectionStart,
+    newValue
   };
 };
 
@@ -1870,15 +1654,15 @@ const getNewValueDeleteContentForward = (value, selectionStart, selectionEnd, da
     const after = value.slice(selectionEnd + 1);
     const newValue = before + after;
     return {
-      newValue,
-      cursorOffset: selectionStart
+      cursorOffset: selectionStart,
+      newValue
     };
   }
   const after = value.slice(selectionEnd);
   const newValue = before + after;
   return {
-    newValue,
-    cursorOffset: selectionStart
+    cursorOffset: selectionStart,
+    newValue
   };
 };
 
@@ -1897,15 +1681,15 @@ const getNewValueDeleteWordBackward = (value, selectionStart, selectionEnd, data
     const before = value.slice(0, startIndex);
     const newValue = before + after;
     return {
-      newValue,
-      cursorOffset: before.length
+      cursorOffset: before.length,
+      newValue
     };
   }
   const before = value.slice(0, selectionStart);
   const newValue = before + after;
   return {
-    newValue,
-    cursorOffset: selectionStart
+    cursorOffset: selectionStart,
+    newValue
   };
 };
 
@@ -1919,15 +1703,15 @@ const getNewValueDeleteWordForward = (value, selectionStart, selectionEnd, data)
     const after = value.slice(startIndex);
     const newValue = before + after;
     return {
-      newValue,
-      cursorOffset: before.length
+      cursorOffset: before.length,
+      newValue
     };
   }
   const after = value.slice(selectionEnd);
   const newValue = before + after;
   return {
-    newValue,
-    cursorOffset: selectionStart
+    cursorOffset: selectionStart,
+    newValue
   };
 };
 
@@ -1935,16 +1719,16 @@ const getNewValueInsertText = (value, selectionStart, selectionEnd, data) => {
   if (selectionStart === value.length) {
     const newValue = value + data;
     return {
-      newValue,
-      cursorOffset: newValue.length
+      cursorOffset: newValue.length,
+      newValue
     };
   }
   const before = value.slice(0, selectionStart);
   const after = value.slice(selectionEnd);
   const newValue = before + data + after;
   return {
-    newValue,
-    cursorOffset: selectionStart + data.length
+    cursorOffset: selectionStart + data.length,
+    newValue
   };
 };
 
@@ -1954,8 +1738,8 @@ const getNewValueInsertCompositionText = (value, selectionStart, selectionEnd, d
 
 const getNewValueInsertLineBreak = (value, selectionStart, selectionEnd, data) => {
   return {
-    newValue: value,
-    cursorOffset: selectionEnd
+    cursorOffset: selectionEnd,
+    newValue: value
   };
 };
 
@@ -1970,21 +1754,21 @@ const InsertFromPaste = 'insertFromPaste';
 
 const getNewValueFunction = inputType => {
   switch (inputType) {
-    case InsertFromPaste:
-    case InsertText:
-      return getNewValueInsertText;
     case DeleteContentBackward:
       return getNewValueDeleteContentBackward;
     case DeleteContentForward:
       return getNewValueDeleteContentForward;
-    case DeleteWordForward:
-      return getNewValueDeleteWordForward;
     case DeleteWordBackward:
       return getNewValueDeleteWordBackward;
-    case InsertLineBreak:
-      return getNewValueInsertLineBreak;
+    case DeleteWordForward:
+      return getNewValueDeleteWordForward;
     case InsertCompositionText:
       return getNewValueInsertCompositionText;
+    case InsertFromPaste:
+    case InsertText:
+      return getNewValueInsertText;
+    case InsertLineBreak:
+      return getNewValueInsertLineBreak;
     default:
       throw new Error(`unsupported input type ${inputType}`);
   }
@@ -2179,6 +1963,7 @@ const GoToLine$1 = ':';
 const View$2 = 'view ';
 const None$1 = '';
 const Help$1 = '?';
+const GoToColumn = '::';
 
 const getQuickPickPrefix = value => {
   if (value.startsWith(Command)) {
@@ -2190,6 +1975,9 @@ const getQuickPickPrefix = value => {
   if (value.startsWith(WorkspaceSymbol$1)) {
     return WorkspaceSymbol$1;
   }
+  if (value.startsWith(GoToColumn)) {
+    return GoToColumn;
+  }
   if (value.startsWith(GoToLine$1)) {
     return GoToLine$1;
   }
@@ -2199,7 +1987,7 @@ const getQuickPickPrefix = value => {
   return None$1;
 };
 
-const noop$1 = value => {
+const noop = value => {
   return value;
 };
 const getFilterValueEverything = value => {
@@ -2207,16 +1995,32 @@ const getFilterValueEverything = value => {
   const prefixLength = prefix.length;
   return value.slice(prefixLength).trim();
 };
-const getFn$2 = id => {
+const getValueGoToColumn = value => {
+  return '';
+};
+const getValueGoToLine = value => {
+  return '';
+};
+const getFn$1 = id => {
   switch (id) {
     case EveryThing$1:
       return getFilterValueEverything;
+    case GoToColumn$1:
+      return getValueGoToColumn;
+    case GoToLine$2:
+      return getValueGoToLine;
     default:
-      return noop$1;
+      return noop;
   }
 };
-const getFilterValue = (id, value) => {
-  const fn = getFn$2(id);
+const getFilterValue = (id, subId, value) => {
+  if (subId === GoToColumn$1) {
+    return getValueGoToColumn();
+  }
+  if (subId === GoToLine$2) {
+    return getValueGoToLine();
+  }
+  const fn = getFn$1(id);
   const filterValue = fn(value);
   return filterValue;
 };
@@ -2242,21 +2046,21 @@ const getColorThemeNames = async () => {
   return invoke$1(/* Ajax.getJson */'ColorTheme.getColorThemeNames');
 };
 
-const toProtoVisibleItem$2 = name => {
+const toProtoVisibleItem$3 = name => {
   const pick = {
-    label: name,
     description: '',
+    direntType: 0,
     fileIcon: '',
     icon: '',
+    label: name,
     matches: [],
-    direntType: 0,
     uri: ''
   };
   return pick;
 };
 const getPicks$c = async searchValue => {
   const colorThemeNames = await getColorThemeNames();
-  const picks = colorThemeNames.map(toProtoVisibleItem$2);
+  const picks = colorThemeNames.map(toProtoVisibleItem$3);
   return picks;
 };
 
@@ -2264,15 +2068,23 @@ const handleError = async (error, notify = true, prefix = '') => {
   console.error(error);
 };
 const showErrorDialog = async error => {
-  const code = error.code;
-  const message = error.message;
-  const stack = error.stack;
-  const name = error.name;
+  const {
+    code
+  } = error;
+  const {
+    message
+  } = error;
+  const {
+    stack
+  } = error;
+  const {
+    name
+  } = error;
   const errorInfo = {
     code,
     message,
-    stack,
-    name
+    name,
+    stack
   };
   await showErrorDialog$1(errorInfo);
 };
@@ -2330,18 +2142,19 @@ const getExtensionPicks = async () => {
     return [];
   }
 };
-const toProtoVisibleItem$1 = item => {
+const toProtoVisibleItem$2 = item => {
   const pick = {
-    label: item.label,
+    // @ts-ignore
+    args: item.args,
     description: '',
+    direntType: 0,
     fileIcon: '',
     icon: '',
-    matches: [],
-    direntType: 0,
-    uri: '',
     // @ts-ignore
     id: item.id,
-    args: item.args
+    label: item.label,
+    matches: [],
+    uri: ''
   };
   // @ts-ignore
   return pick;
@@ -2351,17 +2164,28 @@ const getPicks$b = async () => {
   const builtinPicks = await getBuiltinPicks();
   const extensionPicks = await getExtensionPicks();
   const allPicks = [...builtinPicks, ...extensionPicks];
-  const converted = allPicks.map(toProtoVisibleItem$1);
+  const converted = allPicks.map(toProtoVisibleItem$2);
   return converted;
 };
 
-const state$1 = {
-  args: []
+const toProtoVisibleItem$1 = item => {
+  const {
+    label
+  } = item;
+  return {
+    description: '',
+    direntType: 0,
+    fileIcon: '',
+    icon: '',
+    label,
+    matches: [],
+    uri: ''
+  };
 };
-
-const getPicks$a = async searchValue => {
-  const items = state$1.args[1] || [];
-  return items;
+const getPicks$a = async (searchValue, args) => {
+  const items = args[1] || [];
+  const mapped = items.map(toProtoVisibleItem$1);
+  return mapped;
 };
 
 const emptyMatches = [];
@@ -2379,18 +2203,21 @@ const getProtocol = uri => {
   return '';
 };
 
-const state = Object.create(null);
+const state$1 = Object.create(null);
 const register = modules => {
-  Object.assign(state, modules);
+  Object.assign(state$1, modules);
 };
-const getFn$1 = protocol => {
-  return state[protocol];
+const getFn = protocol => {
+  return state$1[protocol];
 };
 
 const searchFile$5 = async (path, value, prepare, assetDir) => {
   const protocol = getProtocol(path);
   // TODO call different providers depending on protocol
-  const fn = getFn$1(protocol);
+  const fn = getFn(protocol);
+  if (!fn) {
+    throw new Error(`No search handler registered for protocol: ${protocol}`);
+  }
   const result = await fn(path, value, prepare, assetDir);
   return result;
 };
@@ -2444,64 +2271,42 @@ const getPicks$9 = async searchValue => {
   return picks;
 };
 
-const getPicks$8 = async () => {
-  const picks = [{
-    label: '1',
-    description: '',
-    icon: '',
-    fileIcon: '',
-    matches: [],
-    direntType: None$2,
-    uri: ''
-  }, {
-    label: '2',
-    description: '',
-    icon: '',
-    fileIcon: '',
-    matches: [],
-    direntType: None$2,
-    uri: ''
-  }, {
-    label: '3',
-    description: '',
-    icon: '',
-    fileIcon: '',
-    matches: [],
-    direntType: None$2,
-    uri: ''
-  }, {
-    label: '4',
-    description: '',
-    icon: '',
-    fileIcon: '',
-    matches: [],
-    direntType: None$2,
-    uri: ''
-  }, {
-    label: '5',
+const getText = async () => {
+  // TODO
+  const id = await getActiveEditorId();
+  const lines = await getLines(id);
+  return lines.join('\n');
+};
+
+const getPicksGoToColumnBase = async () => {
+  const text = await getText();
+  return [{
     description: '',
-    icon: '',
+    direntType: 0,
     fileIcon: '',
-    matches: [],
-    direntType: None$2,
-    uri: ''
-  }, {
-    label: '6',
-    description: '',
     icon: '',
-    fileIcon: '',
+    label: `Type a character position to go to (from 1 to ${text.length})`,
     matches: [],
-    direntType: None$2,
     uri: ''
   }];
-  return picks;
 };
 
-const DotDotDot = '...';
-const Colon = ':';
-const Percent = '%';
-const AngleBracket = '>';
-const View$1 = 'view';
+const getPosition = (text, wantedColumn) => {
+  let row = 0;
+  let column = 0;
+  for (let i = 0; i < wantedColumn; i++) {
+    if (text[i] === '\n') {
+      row++;
+      column = 0;
+    } else {
+      column++;
+    }
+  }
+  return {
+    column,
+    row
+  };
+};
 
 const emptyObject = {};
 const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
@@ -2524,7 +2329,14 @@ const QuickOpen = 'Quick open';
 const SearchForText = 'Search for text';
 const ShowAndRunCommands = 'Show And Run Commands';
 const TypeNameOfCommandToRun = 'Type the name of a command to run.';
+const PressEnterToGoToLine = `Press 'Enter' to go to line {PH1} column {PH2}`;
 
+const pressEnterToGoToLine = (row, column) => {
+  return i18nString(PressEnterToGoToLine, {
+    PH1: row,
+    PH2: column
+  });
+};
 const typeNameofCommandToRun = () => {
   return i18nString(TypeNameOfCommandToRun);
 };
@@ -2553,6 +2365,84 @@ const openView = () => {
   return i18nString(OpenView);
 };
 
+const getPicksGoToColumn = async value => {
+  if (value === GoToColumn) {
+    return getPicksGoToColumnBase();
+  }
+  if (value.startsWith(GoToColumn)) {
+    const columnString = value.slice(GoToColumn.length);
+    const wantedColumn = Number.parseInt(columnString, 10);
+    if (Number.isNaN(wantedColumn)) {
+      return getPicksGoToColumnBase();
+    }
+    const text = await getText();
+    const position = getPosition(text, wantedColumn);
+    return [{
+      description: '',
+      direntType: 0,
+      fileIcon: '',
+      icon: '',
+      label: pressEnterToGoToLine(position.row, position.column),
+      matches: [],
+      uri: ''
+    }];
+  }
+  return [];
+};
+
+const splitLines = lines => {
+  if (!lines) {
+    return [];
+  }
+  return lines.split('\n');
+};
+
+const getPicksGoToLineBase = async () => {
+  const text = await getText();
+  const lines = splitLines(text);
+  const lineCount = lines.length;
+  return [{
+    description: '',
+    direntType: 0,
+    fileIcon: '',
+    icon: '',
+    label: `Type a line number to go to (from 1 to ${lineCount})`,
+    matches: [],
+    uri: ''
+  }];
+};
+
+const getPicks$8 = async value => {
+  if (value === GoToLine$1) {
+    return getPicksGoToLineBase();
+  }
+  if (value.startsWith(GoToLine$1)) {
+    const lineString = value.slice(GoToLine$1.length);
+    const wantedLine = Number.parseInt(lineString, 10);
+    if (Number.isNaN(wantedLine)) {
+      return getPicksGoToLineBase();
+    }
+    const rowIndex = wantedLine - 1;
+    const columnIndex = 0;
+    return [{
+      description: '',
+      direntType: 0,
+      fileIcon: '',
+      icon: '',
+      label: pressEnterToGoToLine(rowIndex, columnIndex),
+      matches: [],
+      uri: ''
+    }];
+  }
+  return [];
+};
+
+const DotDotDot = '...';
+const Colon = ':';
+const Percent = '%';
+const AngleBracket = '>';
+const View$1 = 'view';
+
 const getPicks$7 = async () => {
   return [{
     description: goToFile(),
@@ -2617,12 +2507,12 @@ const getLabel = uri => {
 };
 const toProtoVisibleItem = uri => {
   return {
-    label: getLabel(uri),
     description: '',
+    direntType: Directory,
     fileIcon: '',
     icon: '',
+    label: getLabel(uri),
     matches: [],
-    direntType: Directory,
     uri
   };
 };
@@ -2659,7 +2549,10 @@ const selectPick$9 = async pick => {
 
 const hideIds = ['AutoUpdater.checkForUpdates'];
 const shouldHide = item => {
-  if (hideIds.includes(item.id) || item.id === 'Viewlet.openWidget' && item.args[0] === 'QuickPick') {
+  if (hideIds.includes(item.id)) {
+    return false;
+  }
+  if (item.id === 'Viewlet.openWidget' && item.args?.[0] === 'QuickPick') {
     return false;
   }
   return true;
@@ -2692,19 +2585,25 @@ const selectPickExtension = async item => {
 };
 const selectPick$8 = async item => {
   // @ts-ignore
-  const id = item.id;
+  const {
+    id
+  } = item;
   if (id.startsWith('ext.')) {
     return selectPickExtension(item);
   }
   return selectPickBuiltin(item);
 };
 
+const state = {
+  args: []
+};
+
 const selectPick$7 = async pick => {
   const {
     args
-  } = state$1;
-  const resolve = args[2];
-  resolve(pick);
+  } = state;
+  const resolveId = args[2];
+  await invoke$1(`QuickPick.executeCallback`, resolveId, pick);
   return {
     command: Hide
   };
@@ -2715,7 +2614,9 @@ const openUri = async uri => {
 };
 
 const selectPick$6 = async pick => {
-  const description = pick.description;
+  const {
+    description
+  } = pick;
   const fileName = pick.label;
   const workspace = await getWorkspacePath();
   const absolutePath = `${workspace}/${description}/${fileName}`;
@@ -2725,18 +2626,42 @@ const selectPick$6 = async pick => {
   };
 };
 
-const execute = async (method, ...params) => {
-  // TODO
+const setCursor = async (rowIndex, columnIndex) => {
+  await invoke$1('Editor.cursorSet', rowIndex, columnIndex);
 };
 
-const selectPick$5 = async item => {
-  const rowIndex = Number.parseInt(item.label);
-  const position = {
-    rowIndex,
-    columnIndex: 5
+const goToPositionAndFocus = async (rowIndex, columnIndex) => {
+  await setCursor(rowIndex, columnIndex);
+  await invoke$1('Editor.handleFocus');
+};
+
+const selectPickGoToColumn = async (item, value) => {
+  if (value.startsWith(GoToColumn)) {
+    const columnString = value.slice(2);
+    const wantedColumn = Number.parseInt(columnString, 10);
+    const text = await getText();
+    const position = getPosition(text, wantedColumn);
+    await goToPositionAndFocus(position.row, position.column);
+    return {
+      command: Hide
+    };
+  }
+  return {
+    command: Hide
   };
-  await execute(/* EditorSetCursor.editorSetCursor */'TODO', /* position */position);
-  // TODO put cursor onto that line
+};
+
+const selectPick$5 = async (item, value) => {
+  if (value.startsWith(GoToLine$1)) {
+    const lineString = value.slice(GoToLine$1.length);
+    const wantedLine = Number.parseInt(lineString, 10);
+    const rowIndex = wantedLine - 1;
+    const columnIndex = 0;
+    await goToPositionAndFocus(rowIndex, columnIndex);
+    return {
+      command: Hide
+    };
+  }
   return {
     command: Hide
   };
@@ -2783,8 +2708,8 @@ const selectPick = async item => {
   };
 };
 
-const selectPicks = [selectPick$9, selectPick$8, selectPick$7, selectPick$6, selectPick$5, selectPick$4, selectPick$3, selectPick$2, selectPick$1, selectPick];
-const getPicks$2 = [getPicks$c, getPicks$b, getPicks$a, getPicks$9, getPicks$8, getPicks$7, getPicks$6, getPicks$5, getPicks$4, getPicks$3];
+const selectPicks = [selectPick$9, selectPick$8, selectPick$7, selectPick$6, selectPickGoToColumn, selectPick$5, selectPick$4, selectPick$3, selectPick$2, selectPick$1, selectPick];
+const getPicks$2 = [getPicks$c, getPicks$b, getPicks$a, getPicks$9, getPicksGoToColumn, getPicks$8, getPicks$7, getPicks$6, getPicks$5, getPicks$4, getPicks$3];
 
 const select = selectPicks;
 const getPick$1 = getPicks$2;
@@ -2797,9 +2722,9 @@ const getSelect = id => {
   return fn;
 };
 
-const getPicks = (id, searchValue) => {
+const getPicks = (id, searchValue, args) => {
   const fn = getPicks$1(id);
-  return fn(searchValue);
+  return fn(searchValue, args);
 };
 
 const getQuickPickSubProviderId = (id, prefix) => {
@@ -2809,16 +2734,18 @@ const getQuickPickSubProviderId = (id, prefix) => {
   switch (prefix) {
     case Command:
       return Commands$1;
-    case Symbol$1:
-      return Symbol$2;
-    case WorkspaceSymbol$1:
-      return WorkspaceSymbol$2;
+    case GoToColumn:
+      return GoToColumn$1;
     case GoToLine$1:
       return GoToLine$2;
-    case View$2:
-      return View$3;
     case Help$1:
       return Help$2;
+    case Symbol$1:
+      return Symbol$2;
+    case View$2:
+      return View$3;
+    case WorkspaceSymbol$1:
+      return WorkspaceSymbol$2;
     default:
       return File$2;
   }
@@ -2827,47 +2754,52 @@ const getQuickPickSubProviderId = (id, prefix) => {
 // TODO when user types letters -> no need to query provider again -> just filter existing results
 const setValue = async (state, newValue) => {
   const {
-    providerId,
-    value,
-    minLineY,
-    maxLineY,
+    args,
     fileIconCache,
+    height,
     itemHeight,
-    height
+    maxLineY,
+    minLineY,
+    providerId,
+    value
   } = state;
   if (value === newValue) {
     return state;
   }
   const prefix = getQuickPickPrefix(newValue);
   const subId = getQuickPickSubProviderId(providerId, prefix);
-  const newPicks = await getPicks(subId, newValue);
-  const filterValue = getFilterValue(providerId, newValue);
+  const newPicks = await getPicks(subId, newValue, args);
+  const filterValue = getFilterValue(providerId, subId, newValue);
   const items = filterQuickPickItems(newPicks, filterValue);
   const focusedIndex = items.length === 0 ? -1 : 0;
   const sliced = items.slice(minLineY, maxLineY);
   const {
-    newFileIconCache,
-    icons
+    icons,
+    newFileIconCache
   } = await getQuickPickFileIcons(sliced, fileIconCache);
   const listHeight = getListHeight(items.length, itemHeight, height);
   const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, items.length);
   return {
     ...state,
-    picks: newPicks,
-    items,
+    fileIconCache: newFileIconCache,
+    finalDeltaY,
     focusedIndex,
-    inputSource: Script,
-    value: newValue,
     icons,
-    fileIconCache: newFileIconCache,
-    finalDeltaY
+    inputSource: Script,
+    items,
+    picks: newPicks,
+    value: newValue
   };
 };
 
 // TODO when user types letters -> no need to query provider again -> just filter existing results
 const handleInput = async (state, newValue, cursorOffset, inputSource = Script) => {
   if (state.value === newValue) {
-    return state;
+    return {
+      ...state,
+      cursorOffset,
+      inputSource
+    };
   }
   const newState = await setValue(state, newValue);
   return {
@@ -2885,8 +2817,8 @@ const handleBeforeInput = (state, inputType, data, selectionStart, selectionEnd)
     value
   } = state;
   const {
-    newValue,
-    cursorOffset
+    cursorOffset,
+    newValue
   } = getNewValue(value, inputType, data, selectionStart, selectionEnd);
   return handleInput(state, newValue, cursorOffset, User);
 };
@@ -2919,10 +2851,10 @@ const getPick = (items, index) => {
 
 const selectIndex = async (state, index, button = /* left */0) => {
   const {
-    minLineY,
     items,
-    value,
-    providerId
+    minLineY,
+    providerId,
+    value
   } = state;
   const actualIndex = index + minLineY;
   const pick = getPick(items, actualIndex);
@@ -2932,7 +2864,7 @@ const selectIndex = async (state, index, button = /* left */0) => {
   const prefix = getQuickPickPrefix(value);
   const subId = getQuickPickSubProviderId(providerId, prefix);
   const fn = getSelect(subId);
-  const selectPickResult = await fn(pick);
+  const selectPickResult = await fn(pick, value);
   object(selectPickResult);
   string(selectPickResult.command);
   const {
@@ -2959,16 +2891,14 @@ const selectIndex = async (state, index, button = /* left */0) => {
 
 const handleClickAt = (state, x, y) => {
   const {
-    top,
     headerHeight,
-    itemHeight
+    itemHeight,
+    top
   } = state;
   const index = getIndex(top, headerHeight, itemHeight, y);
   return selectIndex(state, index);
 };
 
-const setFocus = setFocus$1;
-
 const handleFocus = async state => {
   // TODO fix virtual dom diffing so that input isn't destroyed and loses focus when rerendering
   await setFocus(FocusQuickPickInput);
@@ -2976,6 +2906,17 @@ const handleFocus = async state => {
   return state;
 };
 
+const initialize = async () => {
+  // TODO
+  const rpc = await TransferMessagePortRpcParent.create({
+    commandMap: {},
+    async send(port) {
+      await sendMessagePortToEditorWorker(port, 0);
+    }
+  });
+  set$2(rpc);
+};
+
 const getDefaultValue = id => {
   switch (id) {
     case EveryThing$1:
@@ -2993,20 +2934,23 @@ const Symbol = 'quickPick://symbol';
 const View = 'quickPick://view';
 const Help = 'quickPick://help';
 const WorkspaceSymbol = 'quickPick://workspace-symbol';
+const Custom = 'quickPick://custom';
 const GoToLine = 'quickPick://go-to-line';
 
 const getQuickPickProviderId = prefix => {
   switch (prefix) {
+    case ColorTheme:
+      return ColorTheme$1;
     case Commands:
-    case Symbol:
-    case WorkspaceSymbol:
     case EveryThing:
     case GoToLine:
-    case View:
     case Help:
+    case Symbol:
+    case View:
+    case WorkspaceSymbol:
       return EveryThing$1;
-    case ColorTheme:
-      return ColorTheme$1;
+    case Custom:
+      return Custom$1;
     case Recent:
       return Recent$1;
     default:
@@ -3014,65 +2958,48 @@ const getQuickPickProviderId = prefix => {
   }
 };
 
-const noop = args => {};
-const setArgsCustom = args => {
-  state$1.args = args;
-};
-const getFn = id => {
-  switch (id) {
-    case Custom:
-      return setArgsCustom;
-    default:
-      return noop;
-  }
-};
-const setArgs = (id, args) => {
-  const fn = getFn(id);
-  return fn(args);
-};
-
 const loadContent = async state => {
   const {
-    uri,
     args,
     fileIconCache,
+    height,
     itemHeight,
-    height
+    uri
   } = state;
   const id = getQuickPickProviderId(uri);
   const value = getDefaultValue(id);
   const prefix = getQuickPickPrefix(value);
   const subId = getQuickPickSubProviderId(id, prefix);
-  setArgs(subId, args);
-  const newPicks = await getPicks(subId, value);
+  const newPicks = await getPicks(subId, value, args);
   array(newPicks);
-  const filterValue = getFilterValue(id, value);
+  const filterValue = getFilterValue(id, subId, value);
   const items = filterQuickPickItems(newPicks, filterValue);
   const minLineY = 0;
   const maxLineY = Math.min(minLineY + state.maxVisibleItems, newPicks.length);
   const sliced = newPicks.slice(minLineY, maxLineY);
   const {
-    newFileIconCache,
-    icons
+    icons,
+    newFileIconCache
   } = await getQuickPickFileIcons(sliced, fileIconCache);
   const listHeight = getListHeight(items.length, itemHeight, height);
   const finalDeltaY = getFinalDeltaY(listHeight, itemHeight, items.length);
   return {
     ...state,
-    picks: newPicks,
-    items,
-    focusedIndex: 0,
-    state: Finished,
-    minLineY,
-    maxLineY,
-    value,
+    args,
     cursorOffset: value.length,
-    inputSource: Script,
-    focused: true,
     fileIconCache: newFileIconCache,
+    finalDeltaY,
+    focused: true,
+    focusedIndex: 0,
     icons,
+    inputSource: Script,
+    items,
+    maxLineY,
+    minLineY,
+    picks: newPicks,
     providerId: id,
-    finalDeltaY
+    state: Finished,
+    value
   };
 };
 
@@ -3135,10 +3062,10 @@ const getVisible = (setSize, protoVisibleItems, minLineY, focusedIndex) => {
     const sections = getHighlightSections(highlights, visibleItem.label);
     return {
       ...visibleItem,
-      posInSet: minLineY + i + 1,
-      setSize,
+      highlights: sections,
       isActive: i === focusedIndex,
-      highlights: sections
+      posInSet: minLineY + i + 1,
+      setSize
     };
   });
   return visibleItems;
@@ -3157,12 +3084,12 @@ const createQuickPickViewModel = (oldState, newState) => {
   const newFocusedIndex = newState.focusedIndex - newState.minLineY;
   const itemCount = newState.items.length;
   const {
-    itemHeight,
     deltaY,
     finalDeltaY,
-    minimumSliderSize,
     headerHeight,
-    height
+    height,
+    itemHeight,
+    minimumSliderSize
   } = newState;
   const listHeight = getListHeight(itemCount, itemHeight, height);
   const contentHeight = itemCount * itemHeight;
@@ -3170,16 +3097,16 @@ const createQuickPickViewModel = (oldState, newState) => {
   const scrollBarY = getScrollBarY(deltaY, finalDeltaY, height - headerHeight, scrollBarHeight);
   const roundedScrollBarY = Math.round(scrollBarY);
   return {
-    visibleItems,
-    value: newState.value,
     cursorOffset: newState.cursorOffset,
     focused: newState.focused,
     height,
-    oldFocusedIndex,
     newFocusedIndex,
-    uid: newState.uid,
+    oldFocusedIndex,
     scrollBarHeight,
-    scrollBarTop: roundedScrollBarY
+    scrollBarTop: roundedScrollBarY,
+    uid: newState.uid,
+    value: newState.value,
+    visibleItems
   };
 };
 
@@ -3267,53 +3194,53 @@ const QuickPickItemActive = 'QuickPickItemActive';
 const getQuickPickInputVirtualDom = () => {
   const ariaLabel = typeNameofCommandToRun();
   return {
-    type: Input,
-    className: InputBox,
-    spellcheck: false,
+    ariaAutoComplete: 'list',
+    ariaExpanded: true,
+    ariaLabel: ariaLabel,
     autocapitalize: 'off',
-    inputType: 'text',
+    autocomplete: 'off',
     childCount: 0,
-    role: ComboBox,
+    className: InputBox,
+    inputType: 'text',
     name: QuickPickInput,
     onBeforeInput: HandleBeforeInput,
     onBlur: HandleBlur,
-    onInput: HandleInput,
     onFocus: HandleFocus,
-    ariaLabel: ariaLabel,
-    ariaAutoComplete: 'list',
-    ariaExpanded: true,
-    autocomplete: 'off'
+    onInput: HandleInput,
+    role: ComboBox,
+    spellcheck: false,
+    type: Input
   };
 };
 
 const getQuickPickHeaderVirtualDom = () => {
   return [{
-    type: Div,
+    childCount: 1,
     className: QuickPickHeader,
-    childCount: 1
+    type: Div
   }, getQuickPickInputVirtualDom()];
 };
 
 const getFileIconVirtualDom = icon => {
   return {
-    type: Img,
+    childCount: 0,
     className: FileIcon,
-    src: icon,
     role: None,
-    childCount: 0
+    src: icon,
+    type: Img
   };
 };
 
 const quickPickHighlight = {
-  type: Span,
+  childCount: 1,
   className: QuickPickHighlight,
-  childCount: 1
+  type: Span
 };
 const getHighlights = (sections, label) => {
   const labelDom = {
-    type: Div,
+    childCount: 0,
     className: QuickPickItemLabel,
-    childCount: 0
+    type: Div
   };
   const nodes = [labelDom];
   if (sections.length === 0) {
@@ -3335,26 +3262,25 @@ const getHighlights = (sections, label) => {
 
 const getQuickPickItemVirtualDom = visibleItem => {
   const {
-    posInSet,
-    label,
-    setSize,
-    isActive,
     description,
-    icon,
+    fileIcon,
     highlights,
-    fileIcon
+    icon,
+    isActive,
+    label,
+    posInSet,
+    setSize
   } = visibleItem;
   const dom = [{
-    type: Div,
-    className: QuickPickItem,
-    role: Option,
     ariaPosInSet: posInSet,
     ariaSetSize: setSize,
-    childCount: 1
+    childCount: 1,
+    className: QuickPickItem,
+    role: Option,
+    type: Div
   }];
   const parent = dom[0];
   if (isActive) {
-    // @ts-ignore
     parent.id = QuickPickItemActive;
     parent.className += ' ' + QuickPickItemActive$1;
   }
@@ -3364,9 +3290,9 @@ const getQuickPickItemVirtualDom = visibleItem => {
   } else if (icon) {
     parent.childCount++;
     dom.push({
-      type: Div,
+      childCount: 0,
       className: mergeClassNames(QuickPickMaskIcon, MaskIcon, `MaskIcon${icon}`),
-      childCount: 0
+      type: Div
     });
   }
   const highlightDom = getHighlights(highlights, label);
@@ -3374,9 +3300,9 @@ const getQuickPickItemVirtualDom = visibleItem => {
   if (description) {
     parent.childCount++;
     dom.push({
-      type: Div,
+      childCount: 1,
       className: QuickPickItemDescription,
-      childCount: 1
+      type: Div
     }, text(description));
   }
   return dom;
@@ -3385,13 +3311,13 @@ const getQuickPickItemVirtualDom = visibleItem => {
 const getQuickPickNoResultsVirtualDom = () => {
   const noResults$1 = noResults();
   return [{
-    type: Div,
+    childCount: 1,
     className: mergeClassNames(QuickPickItem, QuickPickItemActive$1, QuickPickStatus),
-    childCount: 1
+    type: Div
   }, {
-    type: Div,
+    childCount: 1,
     className: Label,
-    childCount: 1
+    type: Div
   }, text(noResults$1)];
 };
 
@@ -3411,15 +3337,15 @@ const getScrollBarVirtualDom = (scrollBarHeight, scrollBarTop) => {
   const heightString = px(scrollBarHeight);
   const translateString = position(0, scrollBarTop);
   return [{
-    type: Div,
+    childCount: 1,
     className: mergeClassNames(ScrollBar, ScrollBarSmall),
-    childCount: 1
+    type: Div
   }, {
-    type: Div,
-    className: ScrollBarThumb,
     childCount: 0,
+    className: ScrollBarThumb,
     height: heightString,
-    translate: translateString
+    translate: translateString,
+    type: Div
   }];
 };
 
@@ -3427,24 +3353,24 @@ const getQuickPickVirtualDom = (visibleItems, scrollBarHeight, scrollBarTop) =>
   const quickOpen$1 = quickOpen();
   const shouldShowScrollbar = scrollBarHeight > 0;
   return [{
-    type: Div,
-    className: mergeClassNames(Viewlet, QuickPick$1),
+    ariaLabel: quickOpen$1,
     childCount: 2,
+    className: mergeClassNames(Viewlet, QuickPick$1),
     id: QuickPick,
-    ariaLabel: quickOpen$1
+    type: Div
   }, ...getQuickPickHeaderVirtualDom(), {
-    type: Div,
+    ariaActivedescendant: QuickPickItemActive,
+    childCount: shouldShowScrollbar ? 2 : 1,
     className: mergeClassNames(List, ContainContent),
     id: QuickPickItems,
-    role: ListBox,
-    ariaActivedescendant: QuickPickItemActive,
-    onWheel: HandleWheel,
     onPointerDown: HandlePointerDown,
-    childCount: shouldShowScrollbar ? 2 : 1
+    onWheel: HandleWheel,
+    role: ListBox,
+    type: Div
   }, {
-    type: Div,
+    childCount: visibleItems.length,
     className: mergeClassNames(ListItems, ContainContent),
-    childCount: visibleItems.length
+    type: Div
   }, ...getQuickPickItemsVirtualDom(visibleItems), ...getScrollBarVirtualDom(scrollBarHeight, scrollBarTop)];
 };
 
@@ -3459,18 +3385,18 @@ const renderValue = newState => {
 
 const getRenderer = diffType => {
   switch (diffType) {
-    case RenderValue:
-      return renderValue;
-    case RenderCursorOffset:
-      return renderCursorOffset;
-    case RenderItems:
-      return renderItems;
-    case RenderFocusedIndex:
-      return renderFocusedIndex;
     case Height:
       return renderHeight;
+    case RenderCursorOffset:
+      return renderCursorOffset;
     case RenderFocus:
       return renderFocus;
+    case RenderFocusedIndex:
+      return renderFocusedIndex;
+    case RenderItems:
+      return renderItems;
+    case RenderValue:
+      return renderValue;
     default:
       throw new Error('unknown renderer');
   }
@@ -3494,8 +3420,8 @@ const applyRender = (oldState, newState, diffResult) => {
 
 const render2 = (uid, diffResult) => {
   const {
-    oldState,
-    newState
+    newState,
+    oldState
   } = get(uid);
   if (oldState === newState) {
     return [];
@@ -3570,6 +3496,7 @@ const commandMap = {
   'QuickPick.handleFocus': wrapCommand(handleFocus),
   'QuickPick.handleInput': wrapCommand(handleInput),
   'QuickPick.handleWheel': wrapCommand(handleWheel),
+  'QuickPick.initialize': initialize,
   'QuickPick.loadContent': wrapCommand(loadContent),
   'QuickPick.render2': render2,
   'QuickPick.renderEventListeners': renderEventListeners,
@@ -3610,21 +3537,14 @@ const invoke = (method, ...params) => {
   return invoke$1('SearchProcess.invoke', method, ...params);
 };
 
-const splitLines = lines => {
-  if (!lines) {
-    return [];
-  }
-  return lines.split('\n');
-};
-
 // TODO create direct connection from electron to file search worker using message ports
 
 const searchFile = async (path, value, prepare) => {
   const ripGrepArgs = getFileSearchRipGrepArgs();
   const options = {
+    limit: 9_999_999,
     ripGrepArgs,
-    searchPath: path,
-    limit: 9_999_999
+    searchPath: path
   };
   const stdout = await invoke('SearchFile.searchFile', options);
   const lines = splitLines(stdout);
@@ -3632,14 +3552,15 @@ const searchFile = async (path, value, prepare) => {
 };
 
 const searchModules = {
-  [Memfs]: searchFile$3,
+  [Default]: searchFile,
   [Fetch]: searchFile$2,
-  [Html]: searchFile$1,
   [File]: searchFile,
-  [Default]: searchFile
+  [Html]: searchFile$1,
+  [Memfs]: searchFile$3
 };
 
 const listen = async () => {
+  registerCommands(commandMap);
   register(searchModules);
   const rpc = await WebWorkerRpcClient.create({
     commandMap: commandMap