@lvce-editor/static-server 0.41.0 → 0.41.1

package/static/{7b4acfa → 89cea5f}/packages/text-search-worker/dist/textSearchWorkerMain.js

@@ -184,14 +184,14 @@ const NewLine$1 = '\n';
 const joinLines$1 = lines => {
   return lines.join(NewLine$1);
 };
-const splitLines$2 = lines => {
+const splitLines$1 = lines => {
   return lines.split(NewLine$1);
 };
 const isModuleNotFoundMessage = line => {
   return line.includes('[ERR_MODULE_NOT_FOUND]');
 };
 const getModuleNotFoundError = stderr => {
-  const lines = splitLines$2(stderr);
+  const lines = splitLines$1(stderr);
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
@@ -215,7 +215,7 @@ const isMessageCodeBlockEndIndex = line => {
   return RE_MESSAGE_CODE_BLOCK_END.test(line);
 };
 const getMessageCodeBlock = stderr => {
-  const lines = splitLines$2(stderr);
+  const lines = splitLines$1(stderr);
   const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
   const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
   const relevantLines = lines.slice(startIndex, endIndex);
@@ -279,7 +279,7 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
   if (isModuleNotFoundError(stderr)) {
     return getModuleNotFoundError(stderr);
   }
-  const lines = splitLines$2(stderr);
+  const lines = splitLines$1(stderr);
   const {
     actualMessage,
     rest
@@ -320,14 +320,14 @@ const readyMessage = 'ready';
 const getData$2 = event => {
   return event.data;
 };
-const listen$6 = () => {
+const listen$7 = () => {
   // @ts-ignore
   if (typeof WorkerGlobalScope === 'undefined') {
     throw new TypeError('module is not in web worker scope');
   }
   return globalThis;
 };
-const signal$6 = global => {
+const signal$7 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithModuleWorker extends Ipc {
@@ -353,7 +353,7 @@ class IpcChildWithModuleWorker extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 }
-const wrap$d = global => {
+const wrap$e = global => {
   return new IpcChildWithModuleWorker(global);
 };
 const withResolvers = () => {
@@ -378,10 +378,10 @@ const waitForFirstMessage = async port => {
   // @ts-ignore
   return event.data;
 };
-const listen$5 = async () => {
-  const parentIpcRaw = listen$6();
-  signal$6(parentIpcRaw);
-  const parentIpc = wrap$d(parentIpcRaw);
+const listen$6 = async () => {
+  const parentIpcRaw = listen$7();
+  signal$7(parentIpcRaw);
+  const parentIpc = wrap$e(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError('unexpected first message');
@@ -426,13 +426,13 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$c = port => {
+const wrap$d = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
   __proto__: null,
-  listen: listen$5,
-  wrap: wrap$c
+  listen: listen$6,
+  wrap: wrap$d
 };
 const Open = 1;
 const Close = 2;
@@ -576,13 +576,13 @@ class IpcParentWithWebSocket extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 }
-const wrap$1 = webSocket => {
+const wrap = webSocket => {
   return new IpcParentWithWebSocket(webSocket);
 };
 const IpcParentWithWebSocket$1 = {
   __proto__: null,
   create: create$7,
-  wrap: wrap$1
+  wrap
 };
 
 const Two = '2.0';
@@ -714,14 +714,14 @@ const joinLines = lines => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines$1 = lines => {
+const splitLines = lines => {
   return lines.split(NewLine);
 };
 const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
     return error;
   }
-  const currentStack = joinLines(splitLines$1(new Error().stack || '').slice(1));
+  const currentStack = joinLines(splitLines(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
@@ -1078,21 +1078,21 @@ const clearSearchResults$1 = state => {
   };
 };
 
-const state$3 = {
+const state$2 = {
   rpc: undefined
 };
 const invoke$2 = (method, ...params) => {
-  const rpc = state$3.rpc;
+  const rpc = state$2.rpc;
   // @ts-ignore
   return rpc.invoke(method, ...params);
 };
 const invokeAndTransfer = (method, ...params) => {
-  const rpc = state$3.rpc;
+  const rpc = state$2.rpc;
   // @ts-ignore
   return rpc.invokeAndTransfer(method, ...params);
 };
 const setRpc = rpc => {
-  state$3.rpc = rpc;
+  state$2.rpc = rpc;
 };
 
 const copy = async state => {
@@ -1217,13 +1217,6 @@ const lastIndex = array => {
 const remove = (array, index, deleteCount) => {
   return array.toSpliced(index, deleteCount);
 };
-const fromAsync = async asyncIterable => {
-  const children = [];
-  for await (const value of asyncIterable) {
-    children.push(value);
-  }
-  return children;
-};
 
 const emptyObject = {};
 const RE_PLACEHOLDER = /\{(PH\d+)\}/g;
@@ -1237,143 +1230,133 @@ const i18nString = (key, placeholders = emptyObject) => {
   return key.replaceAll(RE_PLACEHOLDER, replacer);
 };
 
-/**
- * @enum {string}
- */
-const UiStrings = {
-  ClearSearchResults: 'Clear Search Results',
-  CollapseAll: 'Collapse All',
-  ConfirmReplaceAll: 'Replace All?',
-  ConfirmReplaceManyOccurrencesInManyFiles: "Replace {PH1} occurrences across {PH2} files with '{PH3}'",
-  ConfirmReplaceManyOccurrencesInManyFilesNoValue: 'Replace {PH1} occurrences across {PH2} files',
-  ConfirmReplaceManyOccurrencesInOneFile: "Replace {PH1} occurrences across 1 file with '{PH2}'",
-  ConfirmReplaceManyOccurrencesInOneFileNoValue: 'Replace {PH1} occurrences across 1 file',
-  ConfirmReplaceOneOccurrenceInOneFile: "Replace 1 occurrence across 1 file with '{PH1}'",
-  ConfirmReplaceOneOccurrenceInOneFileNoValue: 'Replace 1 occurrence across 1 file',
-  CopyPath: 'Copy Path',
-  Dismiss: 'Dismiss',
-  ManyResultsInManyFiles: '{PH1} results in {PH2} files',
-  ManyResultsInOneFile: '{PH1} results in 1 file',
-  MatchCase: 'Match Case',
-  MatchWholeWord: 'Match Whole Word',
-  NoResults: 'No results found',
-  Oneresult: '1 result in 1 file',
-  OpenNewSearchEditor: 'Open New Search Editor',
-  PreserveCase: 'Preserve Case',
-  Refresh: 'Refresh',
-  Replace: 'Replace',
-  ReplaceAll: 'Replace All',
-  ReplacedManyOccurrencesInManyFiles: "Replaced {PH1} occurrences across {PH2} files with '{PH3}'",
-  ReplacedManyOccurrencesInOneFile: "Replaced {PH1} occurrences across 1 file with '{PH2}'",
-  ReplacedOneOccurrenceInOneFile: "Replaced 1 occurrence across 1 file with '{PH1}'",
-  ToggleReplace: 'Toggle Replace',
-  UseRegularExpression: 'Use Regular Expression',
-  ViewAsTree: 'View as Tree',
-  FilesToInclude: 'Files to Include',
-  FilesToExclude: 'Files to Exclude',
-  ToggleSearchDetails: 'Toggle Search Details',
-  SearchOnlyOpenEditors: 'Search Only Open Editors',
-  UseExcludeSettings: 'Use Exclude Settings'
-};
+const ClearSearchResults = 'Clear Search Results';
+const CollapseAll$1 = 'Collapse All';
+const ConfirmReplaceManyOccurrencesInManyFiles = "Replace {PH1} occurrences across {PH2} files with '{PH3}'";
+const ConfirmReplaceManyOccurrencesInManyFilesNoValue = 'Replace {PH1} occurrences across {PH2} files';
+const ConfirmReplaceManyOccurrencesInOneFile = "Replace {PH1} occurrences across 1 file with '{PH2}'";
+const ConfirmReplaceManyOccurrencesInOneFileNoValue = 'Replace {PH1} occurrences across 1 file';
+const ConfirmReplaceOneOccurrenceInOneFile = "Replace 1 occurrence across 1 file with '{PH1}'";
+const ConfirmReplaceOneOccurrenceInOneFileNoValue = 'Replace 1 occurrence across 1 file';
+const ManyResultsInManyFiles = '{PH1} results in {PH2} files';
+const ManyResultsInOneFile = '{PH1} results in 1 file';
+const MatchCase$2 = 'Match Case';
+const MatchWholeWord$2 = 'Match Whole Word';
+const NoResults = 'No results found';
+const Oneresult = '1 result in 1 file';
+const OpenNewSearchEditor = 'Open New Search Editor';
+const PreserveCase$2 = 'Preserve Case';
+const Refresh$1 = 'Refresh';
+const Replace = 'Replace';
+const ReplaceAll$1 = 'Replace All';
+const ToggleReplace$1 = 'Toggle Replace';
+const UseRegularExpression$2 = 'Use Regular Expression';
+const ViewAsTree = 'View as Tree';
+const FilesToInclude$1 = 'Files to Include';
+const FilesToExclude$1 = 'Files to Exclude';
+const ToggleSearchDetails$1 = 'Toggle Search Details';
+const SearchOnlyOpenEditors$1 = 'Search Only Open Editors';
+const UseExcludeSettings$1 = 'Use Exclude Settings';
+
 const noResults = () => {
-  return i18nString(UiStrings.NoResults);
+  return i18nString(NoResults);
 };
 const oneResult = () => {
-  return i18nString(UiStrings.Oneresult);
+  return i18nString(Oneresult);
 };
 const toggleReplace$1 = () => {
-  return i18nString(UiStrings.ToggleReplace);
+  return i18nString(ToggleReplace$1);
 };
 const matchCase = () => {
-  return i18nString(UiStrings.MatchCase);
+  return i18nString(MatchCase$2);
 };
 const preserveCase = () => {
-  return i18nString(UiStrings.PreserveCase);
+  return i18nString(PreserveCase$2);
 };
 const matchWholeWord = () => {
-  return i18nString(UiStrings.MatchWholeWord);
+  return i18nString(MatchWholeWord$2);
 };
 const toggleSearchDetails = () => {
-  return i18nString(UiStrings.ToggleSearchDetails);
+  return i18nString(ToggleSearchDetails$1);
 };
 const useRegularExpression = () => {
-  return i18nString(UiStrings.UseRegularExpression);
+  return i18nString(UseRegularExpression$2);
 };
 const manyResultsInOneFile = resultCount => {
-  return i18nString(UiStrings.ManyResultsInOneFile, {
+  return i18nString(ManyResultsInOneFile, {
     PH1: resultCount
   });
 };
 const manyResultsInManyFiles = (resultCount, fileResultCount) => {
-  return i18nString(UiStrings.ManyResultsInManyFiles, {
+  return i18nString(ManyResultsInManyFiles, {
     PH1: resultCount,
     PH2: fileResultCount
   });
 };
 const confirmReplaceOneOccurrenceInOneFile = replacement => {
-  return i18nString(UiStrings.ConfirmReplaceOneOccurrenceInOneFile, {
+  return i18nString(ConfirmReplaceOneOccurrenceInOneFile, {
     PH1: replacement
   });
 };
 const confirmReplaceOneOccurrenceInOneFileNoValue = () => {
-  return i18nString(UiStrings.ConfirmReplaceOneOccurrenceInOneFileNoValue);
+  return i18nString(ConfirmReplaceOneOccurrenceInOneFileNoValue);
 };
 const confirmReplaceManyOccurrencesInOneFile = (matchCount, replacement) => {
-  return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInOneFile, {
+  return i18nString(ConfirmReplaceManyOccurrencesInOneFile, {
     PH1: matchCount,
     PH2: replacement
   });
 };
 const confirmReplaceManyOccurrencesInOneFileNoValue = matchCount => {
-  return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInOneFileNoValue, {
+  return i18nString(ConfirmReplaceManyOccurrencesInOneFileNoValue, {
     PH1: matchCount
   });
 };
 const confirmReplaceManyOccurrencesInManyFiles = (matchCount, fileCount, replacement) => {
-  return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInManyFiles, {
+  return i18nString(ConfirmReplaceManyOccurrencesInManyFiles, {
     PH1: matchCount,
     PH2: fileCount,
     PH3: replacement
   });
 };
 const confirmReplaceManyOccurrencesInManyFilesNoValue = (matchCount, fileCount) => {
-  return i18nString(UiStrings.ConfirmReplaceManyOccurrencesInManyFilesNoValue, {
+  return i18nString(ConfirmReplaceManyOccurrencesInManyFilesNoValue, {
     PH1: matchCount,
     PH2: fileCount
   });
 };
 const replaceAll$1 = () => {
-  return i18nString(UiStrings.ReplaceAll);
+  return i18nString(ReplaceAll$1);
 };
 const replace = () => {
-  return i18nString(UiStrings.Replace);
+  return i18nString(Replace);
 };
 const refresh$1 = () => {
-  return i18nString(UiStrings.Refresh);
+  return i18nString(Refresh$1);
 };
 const clearSearchResults = () => {
-  return i18nString(UiStrings.ClearSearchResults);
+  return i18nString(ClearSearchResults);
 };
 const openNewSearchEditor = () => {
-  return i18nString(UiStrings.OpenNewSearchEditor);
+  return i18nString(OpenNewSearchEditor);
 };
 const viewAsTree = () => {
-  return i18nString(UiStrings.ViewAsTree);
+  return i18nString(ViewAsTree);
 };
 const collapseAll = () => {
-  return i18nString(UiStrings.CollapseAll);
+  return i18nString(CollapseAll$1);
 };
 const filesToInclude = () => {
-  return i18nString(UiStrings.FilesToInclude);
+  return i18nString(FilesToInclude$1);
 };
 const filesToExclude = () => {
-  return i18nString(UiStrings.FilesToExclude);
+  return i18nString(FilesToExclude$1);
 };
 const searchOnlyOpenEditors = () => {
-  return i18nString(UiStrings.SearchOnlyOpenEditors);
+  return i18nString(SearchOnlyOpenEditors$1);
 };
 const useExcludeSettings = () => {
-  return i18nString(UiStrings.UseExcludeSettings);
+  return i18nString(UseExcludeSettings$1);
 };
 
 const getStatusMessage = (resultCount, fileResultCount) => {
@@ -1389,13 +1372,13 @@ const getStatusMessage = (resultCount, fileResultCount) => {
   return manyResultsInManyFiles(resultCount, fileResultCount);
 };
 
-const File$1 = 1;
+const File = 1;
 const Match = 2;
 
 const getSetSize = (items, index) => {
   let setSize = 0;
   for (let i = index + 1; i < items.length; i++) {
-    if (items[i].type === File$1) {
+    if (items[i].type === File) {
       break;
     }
     setSize++;
@@ -1414,7 +1397,7 @@ const getRemoveIndicesFile = (items, item, index, matchCount, fileCount) => {
 };
 const getRemoveIndicesMatch = (items, index, matchCount, fileCount) => {
   for (let i = index; i >= 0; i--) {
-    if (items[i].type === File$1) {
+    if (items[i].type === File) {
       const setSize = getSetSize(items, i);
       if (setSize === 1) {
         return {
@@ -1439,7 +1422,7 @@ const getRemoveIndicesMatch = (items, index, matchCount, fileCount) => {
 const getRemoveIndices = (items, index, matchCount, fileCount) => {
   const item = items[index];
   switch (item.type) {
-    case File$1:
+    case File:
       return getRemoveIndicesFile(items, item, index, matchCount, fileCount);
     case Match:
       return getRemoveIndicesMatch(items, index, matchCount, fileCount);
@@ -1915,13 +1898,13 @@ const getDisplayResult = (result, fileIcons, fileIconIndex, itemHeight, i, setSi
   const top = i * itemHeight;
   const focused = i === focusedIndex;
   switch (type) {
-    case File$1:
+    case File:
       const path = text;
       const absolutePath = getAbsolutePath(path);
       const baseName = pathBaseName(path);
       return {
         title: absolutePath,
-        type: File$1,
+        type: File,
         text: baseName,
         icon: fileIcons[fileIconIndex],
         posInSet,
@@ -1969,7 +1952,7 @@ const getDisplayResults = (results, itemHeight, resultCount, searchTerm, minLine
     const result = results[i];
     const displayResult = getDisplayResult(result, fileIcons, fileIconIndex, itemHeight, i, setSize, searchTermLength, replacement, focusedIndex);
     displayResults.push(displayResult);
-    if (result.type === File$1) {
+    if (result.type === File) {
       fileResult = displayResult;
       fileIconIndex++;
     } else {
@@ -2325,13 +2308,13 @@ const getSearchResultVirtualDom = rowInfo => {
     treeItem.className += ' ' + TreeItemActive;
   }
   switch (type) {
-    case File$1:
+    case File:
       treeItem.ariaExpanded = 'true';
       break;
   }
   const dom = [];
   dom.push(treeItem);
-  if (type === File$1) {
+  if (type === File) {
     treeItem.childCount += 2;
     dom.push(chevronDownVirtualDom, getFileIconVirtualDom(icon));
   }
@@ -2379,7 +2362,7 @@ const handleError = error => {
 };
 
 const isFile = match => {
-  return match.type === File$1;
+  return match.type === File;
 };
 const getFiles = matches => {
   return matches.filter(isFile);
@@ -2410,7 +2393,7 @@ const getTextSearchResultCounts = results => {
   let fileCount = 0;
   for (const result of results) {
     switch (result.type) {
-      case File$1:
+      case File:
         fileCount++;
         break;
       case Match:
@@ -2480,474 +2463,12 @@ const textSearch$5 = async (scheme, root, query) => {
   return result;
 };
 
-const getJson = async url => {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(response.statusText);
-    }
-    const json = await response.json();
-    return json;
-  } catch (error) {
-    throw new VError(error, `Failed to get json`);
-  }
-};
-
-const getText = async url => {
-  try {
-    const response = await fetch(url);
-    if (!response.ok) {
-      throw new Error(response.statusText);
-    }
-    const text = await response.text();
-    return text;
-  } catch (error) {
-    throw new VError(error, `Failed to get text`);
-  }
-};
-
-const splitLines = lines => {
-  return lines.split('\n');
-};
-
-const textSearchInText = (file, content, query) => {
-  const results = [];
-  const lines = splitLines(content);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const index = line.indexOf(query);
-    if (index !== -1) {
-      results.push({
-        type: Match,
-        text: line,
-        start: index,
-        end: index + query.length,
-        lineNumber: i
-      });
-    }
-  }
-  if (results.length > 0) {
-    results.unshift({
-      type: File$1,
-      text: file,
-      start: 0,
-      end: 0,
-      lineNumber: 0
-    });
-  }
-  return results;
-};
-
 const textSearch$4 = async (scheme, root, query, options, assetDir) => {
-  string(scheme);
-  string(root);
-  string(query);
-  const fetchUri = `${assetDir}/config/fileMap.json`;
-  const fileList = await getJson(fetchUri);
-  const allResults = [];
-  const relativeRoot = root.slice('fetch://'.length);
-  for (const uri of fileList) {
-    const fetchUri = `${assetDir}${uri}`;
-    const content = await getText(fetchUri);
-    const relativeUri = uri.slice(relativeRoot.length + 1);
-    const results = textSearchInText(relativeUri, content, query);
-    allResults.push(...results);
-  }
-  return allResults;
-};
-
-class FileNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'FileNotFoundError';
-  }
-}
-
-const Directory = 'directory';
-const File = 'file';
-
-const getChildHandles$1 = async handle => {
-  object(handle);
-  // @ts-ignore
-  const childHandles = handle.values();
-  const handles = await fromAsync(childHandles);
-  return handles;
-};
-
-const getChildHandles = async handle => {
-  try {
-    return await getChildHandles$1(handle);
-  } catch (error) {
-    throw new VError(error, 'failed to get child handles');
-  }
-};
-
-const dirname = (pathSeparator, path) => {
-  const index = path.lastIndexOf(pathSeparator);
-  if (index === -1) {
-    return path;
-  }
-  return path.slice(0, index);
-};
-
-const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
-let idbProxyableTypes;
-let cursorAdvanceMethods;
-// This is a function to prevent it throwing up in node environments.
-function getIdbProxyableTypes() {
-  return idbProxyableTypes || (idbProxyableTypes = [IDBDatabase, IDBObjectStore, IDBIndex, IDBCursor, IDBTransaction]);
-}
-// This is a function to prevent it throwing up in node environments.
-function getCursorAdvanceMethods() {
-  return cursorAdvanceMethods || (cursorAdvanceMethods = [IDBCursor.prototype.advance, IDBCursor.prototype.continue, IDBCursor.prototype.continuePrimaryKey]);
-}
-const transactionDoneMap = new WeakMap();
-const transformCache = new WeakMap();
-const reverseTransformCache = new WeakMap();
-function promisifyRequest(request) {
-  const promise = new Promise((resolve, reject) => {
-    const unlisten = () => {
-      request.removeEventListener('success', success);
-      request.removeEventListener('error', error);
-    };
-    const success = () => {
-      resolve(wrap(request.result));
-      unlisten();
-    };
-    const error = () => {
-      reject(request.error);
-      unlisten();
-    };
-    request.addEventListener('success', success);
-    request.addEventListener('error', error);
-  });
-  // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
-  // is because we create many promises from a single IDBRequest.
-  reverseTransformCache.set(promise, request);
-  return promise;
-}
-function cacheDonePromiseForTransaction(tx) {
-  // Early bail if we've already created a done promise for this transaction.
-  if (transactionDoneMap.has(tx)) return;
-  const done = new Promise((resolve, reject) => {
-    const unlisten = () => {
-      tx.removeEventListener('complete', complete);
-      tx.removeEventListener('error', error);
-      tx.removeEventListener('abort', error);
-    };
-    const complete = () => {
-      resolve();
-      unlisten();
-    };
-    const error = () => {
-      reject(tx.error || new DOMException('AbortError', 'AbortError'));
-      unlisten();
-    };
-    tx.addEventListener('complete', complete);
-    tx.addEventListener('error', error);
-    tx.addEventListener('abort', error);
-  });
-  // Cache it for later retrieval.
-  transactionDoneMap.set(tx, done);
-}
-let idbProxyTraps = {
-  get(target, prop, receiver) {
-    if (target instanceof IDBTransaction) {
-      // Special handling for transaction.done.
-      if (prop === 'done') return transactionDoneMap.get(target);
-      // Make tx.store return the only store in the transaction, or undefined if there are many.
-      if (prop === 'store') {
-        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
-      }
-    }
-    // Else transform whatever we get back.
-    return wrap(target[prop]);
-  },
-  set(target, prop, value) {
-    target[prop] = value;
-    return true;
-  },
-  has(target, prop) {
-    if (target instanceof IDBTransaction && (prop === 'done' || prop === 'store')) {
-      return true;
-    }
-    return prop in target;
-  }
-};
-function replaceTraps(callback) {
-  idbProxyTraps = callback(idbProxyTraps);
-}
-function wrapFunction(func) {
-  // Due to expected object equality (which is enforced by the caching in `wrap`), we
-  // only create one new func per func.
-  // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
-  // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
-  // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
-  // with real promises, so each advance methods returns a new promise for the cursor object, or
-  // undefined if the end of the cursor has been reached.
-  if (getCursorAdvanceMethods().includes(func)) {
-    return function (...args) {
-      // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-      // the original object.
-      func.apply(unwrap(this), args);
-      return wrap(this.request);
-    };
-  }
-  return function (...args) {
-    // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
-    // the original object.
-    return wrap(func.apply(unwrap(this), args));
-  };
-}
-function transformCachableValue(value) {
-  if (typeof value === 'function') return wrapFunction(value);
-  // This doesn't return, it just creates a 'done' promise for the transaction,
-  // which is later returned for transaction.done (see idbObjectHandler).
-  if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value);
-  if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps);
-  // Return the same value back if we're not going to transform it.
-  return value;
-}
-function wrap(value) {
-  // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
-  // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
-  if (value instanceof IDBRequest) return promisifyRequest(value);
-  // If we've already transformed this value before, reuse the transformed value.
-  // This is faster, but it also provides object equality.
-  if (transformCache.has(value)) return transformCache.get(value);
-  const newValue = transformCachableValue(value);
-  // Not all types are transformed.
-  // These may be primitive types, so they can't be WeakMap keys.
-  if (newValue !== value) {
-    transformCache.set(value, newValue);
-    reverseTransformCache.set(newValue, value);
-  }
-  return newValue;
-}
-const unwrap = value => reverseTransformCache.get(value);
-
-/**
- * Open a database.
- *
- * @param name Name of the database.
- * @param version Schema version.
- * @param callbacks Additional callbacks.
- */
-function openDB(name, version, {
-  blocked,
-  upgrade,
-  blocking,
-  terminated
-} = {}) {
-  const request = indexedDB.open(name, version);
-  const openPromise = wrap(request);
-  if (upgrade) {
-    request.addEventListener('upgradeneeded', event => {
-      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
-    });
-  }
-  if (blocked) {
-    request.addEventListener('blocked', event => blocked(
-    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
-    event.oldVersion, event.newVersion, event));
-  }
-  openPromise.then(db => {
-    if (terminated) db.addEventListener('close', () => terminated());
-    if (blocking) {
-      db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event));
-    }
-  }).catch(() => {});
-  return openPromise;
-}
-const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
-const writeMethods = ['put', 'add', 'delete', 'clear'];
-const cachedMethods = new Map();
-function getMethod(target, prop) {
-  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === 'string')) {
-    return;
-  }
-  if (cachedMethods.get(prop)) return cachedMethods.get(prop);
-  const targetFuncName = prop.replace(/FromIndex$/, '');
-  const useIndex = prop !== targetFuncName;
-  const isWrite = writeMethods.includes(targetFuncName);
-  if (
-  // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
-  !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
-    return;
-  }
-  const method = async function (storeName, ...args) {
-    // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
-    const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
-    let target = tx.store;
-    if (useIndex) target = target.index(args.shift());
-    // Must reject if op rejects.
-    // If it's a write operation, must reject if tx.done rejects.
-    // Must reject with op rejection first.
-    // Must resolve with op value.
-    // Must handle both promises (no unhandled rejections)
-    return (await Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0];
-  };
-  cachedMethods.set(prop, method);
-  return method;
-}
-replaceTraps(oldTraps => ({
-  ...oldTraps,
-  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
-  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
-}));
-const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
-const methodMap = {};
-const advanceResults = new WeakMap();
-const ittrProxiedCursorToOriginalProxy = new WeakMap();
-const cursorIteratorTraps = {
-  get(target, prop) {
-    if (!advanceMethodProps.includes(prop)) return target[prop];
-    let cachedFunc = methodMap[prop];
-    if (!cachedFunc) {
-      cachedFunc = methodMap[prop] = function (...args) {
-        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
-      };
-    }
-    return cachedFunc;
-  }
-};
-async function* iterate(...args) {
-  // tslint:disable-next-line:no-this-assignment
-  let cursor = this;
-  if (!(cursor instanceof IDBCursor)) {
-    cursor = await cursor.openCursor(...args);
-  }
-  if (!cursor) return;
-  cursor = cursor;
-  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
-  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
-  // Map this double-proxy back to the original, so other cursor methods work.
-  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
-  while (cursor) {
-    yield proxiedCursor;
-    // If one of the advancing methods was not called, call continue().
-    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
-    advanceResults.delete(proxiedCursor);
-  }
-}
-function isIteratorProp(target, prop) {
-  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
-}
-replaceTraps(oldTraps => ({
-  ...oldTraps,
-  get(target, prop, receiver) {
-    if (isIteratorProp(target, prop)) return iterate;
-    return oldTraps.get(target, prop, receiver);
-  },
-  has(target, prop) {
-    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
-  }
-}));
-
-const state$2 = {
-  databases: Object.create(null),
-  eventId: 0,
-  dbVersion: 1,
-  cachedDb: undefined
-};
-
-// TODO high memory usage in idb because of transactionDoneMap
-
-const getHandleDb = async () => {
-  // @ts-ignore
-  const db = await openDB('handle', state$2.dbVersion, {
-    async upgrade(db) {
-      if (!db.objectStoreNames.contains('file-handles-store')) {
-        await db.createObjectStore('file-handles-store', {});
-      }
-    }
-  });
-  return db;
-};
-
-const getHandle$1 = async uri => {
-  const handleDb = await getHandleDb();
-  const handle = await handleDb.get('file-handles-store', uri);
-  return handle;
-};
-
-const getHandle = async uri => {
-  try {
-    // TODO retrieve handle from state or from indexeddb
-    // TODO if not found, throw error
-    const handle = await getHandle$1(uri);
-    return handle;
-  } catch (error) {
-    throw new VError(error, 'Failed to get handle');
-  }
+  return invoke$2('ExtensionHostTextSearch.textSearchFetch', scheme, root, query, options, assetDir);
 };
 
-const getDirectoryHandle = async uri => {
-  const handle = await getHandle(uri);
-  if (handle) {
-    return handle;
-  }
-  const dirname$1 = dirname('/', uri);
-  if (uri === dirname$1) {
-    return undefined;
-  }
-  return getDirectoryHandle(dirname$1);
-};
-
-const NotReadableError = 'NotReadableError';
-
-const isNotReadableError = error => {
-  return error && error.name === NotReadableError;
-};
-
-const getFile = handle => {
-  return handle.getFile();
-};
-
-const textSearchInFile = async (all, handle, absolutePath, query) => {
-  try {
-    const file = await getFile(handle);
-    const content = await file.text();
-    const results = textSearchInText(absolutePath, content, query);
-    push(all, results);
-  } catch (error) {
-    if (isNotReadableError(error)) {
-      // ignore
-      return;
-    }
-    throw error;
-  }
-};
-
-const textSearchRecursively = async (all, parent, handle, query) => {
-  const childHandles = await getChildHandles(handle);
-  const promises = [];
-  for (const childHandle of childHandles) {
-    const absolutePath = parent + '/' + childHandle.name;
-    switch (childHandle.kind) {
-      case Directory:
-        promises.push(textSearchRecursively(all, absolutePath, childHandle, query));
-        break;
-      case File:
-        // @ts-ignore
-        promises.push(textSearchInFile(all, childHandle, absolutePath, query));
-        break;
-    }
-  }
-  await Promise.all(promises);
-};
 const textSearch$3 = async (scheme, root, query) => {
-  string(scheme);
-  string(root);
-  string(query);
-  const relativeRoot = root.slice('html://'.length);
-  const handle = await getDirectoryHandle(relativeRoot);
-  if (!handle) {
-    throw new FileNotFoundError(`Folder not found: ${relativeRoot}`);
-  }
-  const all = [];
-  await textSearchRecursively(all, '', handle, query);
-  return all;
+  return invoke$2('ExtensionHostTextSearch.textSearchHtml', scheme, root, query);
 };
 
 const getRipGrepArgs = ({
@@ -3442,7 +2963,7 @@ const getFilteredResults = (results, collapsedPaths) => {
   const filteredResults = [];
   let isExcluded = false;
   for (const result of results) {
-    if (result.type === File$1) {
+    if (result.type === File) {
       if (collapsedPaths.includes(result.text)) {
         isExcluded = true;
       } else {
@@ -3485,7 +3006,7 @@ const openUri = async (path, focus = true, props = {}) => {
 const getFileIndex = (items, index) => {
   for (let i = index; i >= 0; i--) {
     const item = items[i];
-    if (item.type === File$1) {
+    if (item.type === File) {
       return i;
     }
   }
@@ -3528,7 +3049,7 @@ const selectIndex = async (state, index) => {
   } = state;
   const searchResult = items[index];
   switch (searchResult.type) {
-    case File$1:
+    case File:
       return selectIndexFile(state, searchResult, index);
     case Match:
       return selectIndexPreview(state, searchResult, index);
@@ -3840,7 +3361,7 @@ const getBulkReplacementEdits = (workspacePath, matches) => {
       text
     } = match;
     switch (type) {
-      case File$1:
+      case File:
         ranges.push(currentRanges.length);
         push(ranges, currentRanges);
         const absolutePath = `${workspacePath}/${text.slice(2)}`;