@lvce-editor/static-server 0.43.2 → 0.43.3

package/static/{c4f5462 → 6c4895a}/packages/extension-host-worker/dist/extensionHostWorkerMain.js

@@ -4,13 +4,13 @@ const Function = 3;
 const Variable = 4;
 const Keyword = 5;
 const Folder = 6;
-const File$3 = 7;
+const File$4 = 7;
 const Field = 8;
 
 const EditorCompletionType = {
   __proto__: null,
   Field,
-  File: File$3,
+  File: File$4,
   Folder,
   Function,
   Keyword,
@@ -89,7 +89,7 @@ const fn = value => {
   }
 };
 
-const state$b = {
+const state$c = {
   /** @type{any[]} */
   onDidOpenEditorListeners: [],
   /** @type{any[]} */
@@ -101,19 +101,19 @@ const state$b = {
   textDocuments: Object.create(null)
 };
 const setDocument = (textDocumentId, textDocument) => {
-  state$b.textDocuments[textDocumentId] = textDocument;
+  state$c.textDocuments[textDocumentId] = textDocument;
 };
 const getDidOpenListeners = () => {
-  return state$b.onDidSaveTextDocumentListeners;
+  return state$c.onDidSaveTextDocumentListeners;
 };
 const getWillChangeListeners = () => {
-  return state$b.onWillChangeEditorListeners;
+  return state$c.onWillChangeEditorListeners;
 };
 const getDidChangeListeners = () => {
-  return state$b.onDidChangeTextDocumentListeners;
+  return state$c.onDidChangeTextDocumentListeners;
 };
 const getDocument = textDocumentId => {
-  return state$b.textDocuments[textDocumentId];
+  return state$c.textDocuments[textDocumentId];
 };
 
 const getOffset$1 = (textDocument, position) => {
@@ -675,7 +675,7 @@ const executeOrganizeImports = async uid => {
   return edits;
 };
 
-const state$a = {
+const state$b = {
   commands: Object.create(null)
 };
 const getCommandDisplay = command => {
@@ -698,10 +698,10 @@ const registerCommand = command => {
     if (!command.execute) {
       throw new Error('command is missing execute function');
     }
-    if (command.id in state$a.commands) {
+    if (command.id in state$b.commands) {
       throw new Error(`command cannot be registered multiple times`);
     }
-    state$a.commands[command.id] = command;
+    state$b.commands[command.id] = command;
   } catch (error) {
     const commandDisplayId = getCommandDisplay(command);
     throw new VError(error, `Failed to register command${commandDisplayId}`);
@@ -709,7 +709,7 @@ const registerCommand = command => {
 };
 const executeCommand = async (id, ...args) => {
   try {
-    const command = state$a.commands[id];
+    const command = state$b.commands[id];
     if (!command) {
       throw new Error(`command ${id} not found`);
     }
@@ -748,40 +748,40 @@ const {
   }]
 });
 
-const state$9 = {
+const state$a = {
   configuration: Object.create(null)
 };
 const getConfiguration = key => {
-  return state$9.configuration[key] ?? '';
+  return state$a.configuration[key] ?? '';
 };
 const setConfigurations = preferences => {
-  state$9.configuration = preferences;
+  state$a.configuration = preferences;
 };
 
-const state$8 = {
+const state$9 = {
   rpc: undefined
 };
 const invoke$2 = (method, ...params) => {
-  const rpc = state$8.rpc;
+  const rpc = state$9.rpc;
   return rpc.invoke(method, ...params);
 };
 const send$1 = (method, ...params) => {
-  const rpc = state$8.rpc;
+  const rpc = state$9.rpc;
   return rpc.send(method, ...params);
 };
 const invokeAndTransfer$1 = (method, ...params) => {
-  const rpc = state$8.rpc;
+  const rpc = state$9.rpc;
   return rpc.invokeAndTransfer(method, ...params);
 };
 const setRpc = rpc => {
-  state$8.rpc = rpc;
+  state$9.rpc = rpc;
 };
 
-const state$7 = {
+const state$8 = {
   debugProviderMap: Object.create(null)
 };
 const getDebugProvider = id => {
-  const provider = state$7.debugProviderMap[id];
+  const provider = state$8.debugProviderMap[id];
   if (!provider) {
     // @ts-ignore
     throw new VError(`no debug provider "${id}" found`);
@@ -792,7 +792,7 @@ const registerDebugProvider = debugProvider => {
   if (!debugProvider.id) {
     throw new Error('Failed to register debug system provider: missing id');
   }
-  state$7.debugProviderMap[debugProvider.id] = debugProvider;
+  state$8.debugProviderMap[debugProvider.id] = debugProvider;
 };
 const start = async (protocol, path) => {
   try {
@@ -969,7 +969,7 @@ const registerFileSystemProvider = fileSystemProvider => {
   }
   set$4(fileSystemProvider.id, fileSystemProvider);
 };
-const readDirWithFileTypes = async (protocol, path) => {
+const readDirWithFileTypes$2 = async (protocol, path) => {
   try {
     const provider = get$5(protocol);
     return await provider.readDirWithFileTypes(path);
@@ -977,7 +977,7 @@ const readDirWithFileTypes = async (protocol, path) => {
     throw new VError(error, 'Failed to execute file system provider');
   }
 };
-const readFile = async (protocol, path) => {
+const readFile$2 = async (protocol, path) => {
   try {
     const provider = get$5(protocol);
     return await provider.readFile(path);
@@ -1005,7 +1005,7 @@ const readDirWithFileTypesExternal = async path => {
   const content = await invoke$2('FileSystem.readDirWithFileTypes', path);
   return content;
 };
-const writeFile = async (protocol, uri, content) => {
+const writeFile$2 = async (protocol, uri, content) => {
   try {
     const provider = get$5(protocol);
     return await provider.writeFile(uri, content);
@@ -1651,7 +1651,7 @@ const set$3 = (id, fn) => {
 const get$4 = id => {
   return callbacks[id];
 };
-const remove = id => {
+const remove$2 = id => {
   delete callbacks[id];
 };
 let id = 0;
@@ -1828,7 +1828,7 @@ const resolve = (id, response) => {
     return;
   }
   fn(response);
-  remove(id);
+  remove$2(id);
 };
 const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
 const getErrorType = prettyError => {
@@ -2398,7 +2398,7 @@ const {
 });
 
 const getExtensionHostSubWorkerUrl = () => {
-  return '/c4f5462/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
+  return '/6c4895a/packages/extension-host-sub-worker/dist/extensionHostSubWorkerMain.js';
 };
 const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
@@ -2551,17 +2551,17 @@ const {
   }
 });
 
-const state$6 = {
+const state$7 = {
   providers: Object.create(null)
 };
 const registerSourceControlProvider = provider => {
-  state$6.providers[provider.id] = provider;
+  state$7.providers[provider.id] = provider;
 };
 const getFilesFromProvider = provider => {
   return provider.getChangedFiles();
 };
 const getChangedFiles = async providerId => {
-  const provider = state$6.providers[providerId];
+  const provider = state$7.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -2572,7 +2572,7 @@ const getChangedFiles = async providerId => {
 const getFileBefore = async (providerId, uri) => {
   string(providerId);
   string(uri);
-  const provider = state$6.providers[providerId];
+  const provider = state$7.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -2594,7 +2594,7 @@ const getGroupsFromProvider = async (provider, cwd) => {
   throw new Error('source control provider is missing required function getGroups');
 };
 const getGroups = async (providerId, cwd) => {
-  const provider = state$6.providers[providerId];
+  const provider = state$7.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -2602,14 +2602,14 @@ const getGroups = async (providerId, cwd) => {
   return groups;
 };
 const acceptInput = async (providerId, value) => {
-  const provider = state$6.providers[providerId];
+  const provider = state$7.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
   await provider.acceptInput(value);
 };
 const add = async path => {
-  const provider = Object.values(state$6.providers)[0];
+  const provider = Object.values(state$7.providers)[0];
   if (!provider) {
     return;
   }
@@ -2617,7 +2617,7 @@ const add = async path => {
   await provider.add(path);
 };
 const discard = async path => {
-  const provider = Object.values(state$6.providers)[0];
+  const provider = Object.values(state$7.providers)[0];
   if (!provider) {
     return;
   }
@@ -2627,7 +2627,7 @@ const discard = async path => {
 const getEnabledProviderIds = async (scheme, root) => {
   string(scheme);
   string(root);
-  const providers = Object.values(state$6.providers);
+  const providers = Object.values(state$7.providers);
   const enabledIds = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -2656,7 +2656,7 @@ const {
   }
 });
 
-const state$5 = {
+const state$6 = {
   textSearchProviders: Object.create(null)
 };
 const registerTextSearchProvider = textSearchProvider => {
@@ -2667,14 +2667,14 @@ const registerTextSearchProvider = textSearchProvider => {
     if (!textSearchProvider.scheme) {
       throw new Error('textSearchProvider is missing scheme');
     }
-    state$5.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+    state$6.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
   } catch (error) {
     throw new VError(error, 'Failed to register text search provider');
   }
 };
 const executeTextSearchProvider = async (scheme, query) => {
   try {
-    const textSearchProvider = state$5.textSearchProviders[scheme];
+    const textSearchProvider = state$6.textSearchProviders[scheme];
     if (!textSearchProvider) {
       throw new Error(`No text search provider for ${scheme} found`);
     }
@@ -2864,14 +2864,14 @@ const createWorker = async ({
   return rpc;
 };
 
-const state$4 = {
+const state$5 = {
   workspacePath: ''
 };
 const setWorkspacePath = path => {
-  state$4.workspacePath = path;
+  state$5.workspacePath = path;
 };
 const getWorkspaceFolder = path => {
-  return state$4.workspacePath;
+  return state$5.workspacePath;
 };
 
 class FormattingError extends Error {
@@ -2883,12 +2883,12 @@ class FormattingError extends Error {
   }
 }
 
-const File$2 = 1;
+const File$3 = 1;
 const Match = 2;
 
 const TextSearchResultType = {
   __proto__: null,
-  File: File$2,
+  File: File$3,
   Match
 };
 
@@ -3024,7 +3024,7 @@ const handleUnhandledRejection = event => {
   console.error(output);
 };
 
-const state$3 = {
+const state$4 = {
   /**
    * @type {any[]}
    */
@@ -3032,10 +3032,10 @@ const state$3 = {
 };
 const addError = error => {
   // @ts-ignore
-  state$3.errors.push(error);
+  state$4.errors.push(error);
 };
 const hasRecentErrors = () => {
-  return state$3.errors.length > 0;
+  return state$4.errors.length > 0;
 };
 const getRecentError = () => {
 };
@@ -3075,11 +3075,20 @@ const setup = ({
   global.vscode = api;
 };
 
+const applyBulkReplacement = async (files, ranges, replacement) => {
+  console.log({
+    files,
+    ranges,
+    replacement
+  });
+  throw new Error('not implemented');
+};
+
 const getAssetDir = () => {
   // @ts-ignore
-  if (typeof '/c4f5462' !== 'undefined') {
+  if (typeof '/6c4895a' !== 'undefined') {
     // @ts-ignore
-    return '/c4f5462';
+    return '/6c4895a';
   }
   if (platform === Electron) {
     return '../../../../..';
@@ -3103,11 +3112,11 @@ const getConfiguredIframeWorkerUrl = async () => {
   return configuredWorkerUrl;
 };
 
-const state$2 = {
+const state$3 = {
   id: 0
 };
 const create$1 = () => {
-  return ++state$2.id;
+  return ++state$3.id;
 };
 
 const commandMap$1 = {
@@ -3399,7 +3408,7 @@ const CallExpression = 'CallExpression';
 const ExportAllDeclaration = 'ExportAllDeclaration';
 const ExportNamedDeclaration = 'ExportNamedDeclaration';
 const ExpressionStatement = 'ExpressionStatement';
-const File$1 = 'File';
+const File$2 = 'File';
 const Import = 'Import';
 const ImportDeclaration = 'ImportDeclaration';
 const Program = 'Program';
@@ -3419,7 +3428,7 @@ const walk = (node, visitor) => {
   }
   visitor(node);
   switch (node.type) {
-    case File$1:
+    case File$2:
       walk(node.program, visitor);
       break;
     case Program:
@@ -3715,7 +3724,7 @@ const mockRpc = () => {
 };
 
 const getStatusBarItems = async () => {
-  const providers = Object.values(state$6.providers);
+  const providers = Object.values(state$7.providers);
   const statusBarItems = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -3730,6 +3739,288 @@ const registerChangeListener = () => {
   // TODO
 };
 
+const Directory$1 = 3;
+const File$1 = 7;
+
+const fileMapUrl = `${assetDir}/config/fileMap.json`;
+
+const getBlob$2 = async url => {
+  try {
+    const response = await fetch(url);
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
+    const text = await response.blob();
+    return text;
+  } catch (error) {
+    throw new VError(error, `Failed to request blob for ${url}`);
+  }
+};
+
+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 Slash = '/';
+
+// TODO move all of this to an extension
+
+const readFile$1 = async uri => {
+  const fetchUri = `${assetDir}${uri}`;
+  const text = await getText(fetchUri);
+  return text;
+};
+const writeFile$1 = () => {
+  throw new Error('not implemented');
+};
+const mkdir$1 = () => {
+  throw new Error('not implemented');
+};
+const remove$1 = () => {
+  throw new Error('not implemented');
+};
+const readDirWithFileTypes$1 = async uri => {
+  const fileList = await getJson(fileMapUrl);
+  const dirents = [];
+  for (const fileUri of fileList) {
+    if (fileUri.startsWith(uri)) {
+      const rest = fileUri.slice(uri.length + 1);
+      if (rest.includes(Slash)) {
+        const name = rest.slice(0, rest.indexOf(Slash));
+        if (dirents.some(dirent => dirent.name === name)) {
+          continue;
+        }
+        dirents.push({
+          type: Directory$1,
+          name
+        });
+      } else {
+        dirents.push({
+          type: File$1,
+          name: rest
+        });
+      }
+    }
+  }
+  return dirents;
+};
+const chmod$1 = () => {
+  throw new Error('[memfs] chmod not implemented');
+};
+const getBlob$1 = async (uri, type) => {
+  const fetchUri = `${assetDir}${uri}`;
+  const blob = getBlob$2(fetchUri);
+  return blob;
+};
+
+class FileNotFoundError extends Error {
+  constructor(uri) {
+    super(`File not found: ${uri}`);
+    this.code = 'ENOENT';
+  }
+}
+
+const ApplicationJson = 'application/json';
+const AudioMpeg = 'audio/mpeg';
+const FontTtf = 'font/ttf';
+const ImagePng = 'image/png';
+const ImageSvgXml = 'image/svg+xml';
+const TextCss = 'text/css';
+const TextHtml = 'text/html';
+const TextJavaScript = 'text/javascript';
+const TextPlain = 'text/plain';
+const VideoWebm = 'video/webm';
+
+const getMimeType = fileExtension => {
+  switch (fileExtension) {
+    case '.html':
+      return TextHtml;
+    case '.css':
+      return TextCss;
+    case '.ttf':
+      return FontTtf;
+    case '.js':
+    case '.mjs':
+    case '.ts':
+      return TextJavaScript;
+    case '.svg':
+      return ImageSvgXml;
+    case '.png':
+      return ImagePng;
+    case '.json':
+    case '.map':
+      return ApplicationJson;
+    case '.mp3':
+      return AudioMpeg;
+    case '.webm':
+      return VideoWebm;
+    case '.txt':
+      return TextPlain;
+    default:
+      return '';
+  }
+};
+
+const dirname = (pathSeparator, path) => {
+  const index = path.lastIndexOf(pathSeparator);
+  if (index === -1) {
+    return path;
+  }
+  return path.slice(0, index);
+};
+const extname = path => {
+  const index = path.lastIndexOf('.');
+  if (index === -1) {
+    return '';
+  }
+  return path.slice(index);
+};
+
+const getContentType = uri => {
+  const extension = extname(uri);
+  const mime = getMimeType(extension);
+  return mime;
+};
+
+// TODO move this to an extension?
+
+const state$2 = {
+  files: Object.create(null)
+};
+const getDirent = uri => {
+  return state$2.files[uri];
+};
+const readFile = uri => {
+  const dirent = getDirent(uri);
+  if (!dirent) {
+    throw new FileNotFoundError(uri);
+  }
+  if (dirent.type !== File$1) {
+    throw new Error('file is a directory');
+  }
+  return dirent.content;
+};
+const ensureParentDir = uri => {
+  const startIndex = 0;
+  let endIndex = uri.indexOf(Slash);
+  while (endIndex >= 0) {
+    const part = uri.slice(startIndex, endIndex + 1);
+    state$2.files[part] = {
+      type: Directory$1,
+      content: ''
+    };
+    endIndex = uri.indexOf(Slash, endIndex + 1);
+  }
+};
+const writeFile = (uri, content) => {
+  const dirent = getDirent(uri);
+  if (dirent) {
+    // TODO create new dirent
+    // @ts-ignore
+    dirent.content = content;
+  } else {
+    ensureParentDir(uri);
+    state$2.files[uri] = {
+      type: File$1,
+      content
+    };
+  }
+};
+const mkdir = uri => {
+  if (!uri.endsWith(Slash)) {
+    uri += Slash;
+  }
+  ensureParentDir(uri);
+  state$2.files[uri] = {
+    type: Directory$1,
+    content: ''
+  };
+};
+const remove = uri => {
+  const toDelete = [];
+  for (const key of Object.keys(state$2.files)) {
+    if (key.startsWith(uri)) {
+      toDelete.push(key);
+    }
+  }
+  for (const key of toDelete) {
+    delete state$2.files[key];
+  }
+};
+const readDirWithFileTypes = uri => {
+  if (!uri.endsWith(Slash)) {
+    uri += Slash;
+  }
+  const dirents = [];
+  for (const [key, value] of Object.entries(state$2.files)) {
+    if (key.startsWith(uri)) {
+      // @ts-ignore
+      switch (value.type) {
+        case Directory$1:
+          if (!key.slice(0, -1).includes(Slash, uri.length) && key !== `${uri}/` && key !== uri) {
+            dirents.push({
+              // @ts-ignore
+              type: value.type,
+              name: key.slice(uri.length, -1)
+            });
+          }
+          break;
+        case File$1:
+          if (!key.includes(Slash, uri.length + 1)) {
+            dirents.push({
+              // @ts-ignore
+              type: value.type,
+              name: key.slice(uri.length)
+            });
+          }
+          break;
+      }
+    }
+  }
+  return dirents;
+};
+const getBlob = (uri, type) => {
+  const content = readFile(uri);
+  const contentType = type || getContentType(uri);
+  const blob = new Blob([content], {
+    type: contentType
+  });
+  return blob;
+};
+const getBlobUrl = (uri, type) => {
+  const blob = getBlob(uri, type);
+  const url = URL.createObjectURL(blob);
+  return url;
+};
+const chmod = () => {
+  throw new Error('[memfs] chmod not implemented');
+};
+const getFiles = () => {
+  return state$2.files;
+};
+
 const getRpcInfo = rpcId => {
   const info = get$3(rpcId);
   if (!info) {
@@ -4194,21 +4485,6 @@ const saveState = async () => {
   return all;
 };
 
-const fileMapUrl = `${assetDir}/config/fileMap.json`;
-
-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 removeLeadingSlash = path => {
   if (path.startsWith('/')) {
     return path.slice(1);
@@ -4266,14 +4542,6 @@ const getChildHandles$1 = async handle => {
   return handles;
 };
 
-const dirname = (pathSeparator, path) => {
-  const index = path.lastIndexOf(pathSeparator);
-  if (index === -1) {
-    return path;
-  }
-  return path.slice(0, index);
-};
-
 const getHandle = async uri => {
   try {
     // TODO retrieve handle from state or from indexeddb
@@ -4328,19 +4596,6 @@ const searchFile = async uri => {
   return all;
 };
 
-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');
 };
@@ -4363,7 +4618,7 @@ const textSearchInText = (file, content, query) => {
   }
   if (results.length > 0) {
     results.unshift({
-      type: File$2,
+      type: File$3,
       text: file,
       start: 0,
       end: 0,
@@ -4373,7 +4628,7 @@ const textSearchInText = (file, content, query) => {
   return results;
 };
 
-const textSearch$1 = async (scheme, root, query, options, assetDir) => {
+const textSearch$2 = async (scheme, root, query, options, assetDir) => {
   string(scheme);
   string(root);
   string(query);
@@ -4391,13 +4646,6 @@ const textSearch$1 = async (scheme, root, query, options, assetDir) => {
   return allResults;
 };
 
-class FileNotFoundError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'FileNotFoundError';
-  }
-}
-
 const getChildHandles = async handle => {
   try {
     return await getChildHandles$1(handle);
@@ -4460,24 +4708,73 @@ const textSearchRecursively = async (all, parent, handle, query) => {
   }
   await Promise.all(promises);
 };
-const textSearch = async (scheme, root, query) => {
+const textSearch$1 = 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}`);
+    throw new FileNotFoundError(relativeRoot);
   }
   const all = [];
   await textSearchRecursively(all, '', handle, query);
   return all;
 };
 
+const matchesUri = (uri, relativeRoot, include, exclude) => {
+  if (!uri.startsWith(relativeRoot)) {
+    return false;
+  }
+  if (include && typeof include === 'string' && !uri.includes(include)) {
+    return false;
+  }
+  if (exclude && typeof exclude === 'string' && uri.includes(exclude)) {
+    return false;
+  }
+  return true;
+};
+const textSearch = async (scheme, root, query, options, assetDir) => {
+  string(scheme);
+  string(root);
+  string(query);
+  const files = getFiles();
+  const relativeRoot = root.slice('memfs://'.length);
+  const allResults = [];
+  for (const [key, value] of Object.entries(files)) {
+    if (!matchesUri(key, relativeRoot, options.include, options.exclude)) {
+      continue;
+    }
+    if (value.type === File$1) {
+      const relativeUri = key.slice(relativeRoot.length + 1);
+      const results = textSearchInText(relativeUri, value.content, query);
+      allResults.push(...results);
+    }
+  }
+  return allResults;
+};
+
 const commandMap = {
+  'BulkReplacement.applyBulkReplacement': applyBulkReplacement,
   'ExtensionHost.launchIframeWorker': launchIframeWorker,
   'ExtensionHostRename.executeprepareRenameProvider': executeprepareRenameProvider,
   'ExtensionHostRename.executeRenameProvider': executeRenameProvider,
+  'FileSystemFetch.chmod': chmod$1,
+  'FileSystemFetch.getBlob': getBlob$1,
+  'FileSystemFetch.mkdir': mkdir$1,
+  'FileSystemFetch.readDirWithFileTypes': readDirWithFileTypes$1,
+  'FileSystemFetch.readFile': readFile$1,
+  'FileSystemFetch.remove': remove$1,
+  'FileSystemFetch.writeFile': writeFile$1,
+  'FileSystemMemory.chmod': chmod,
+  'FileSystemMemory.getBlob': getBlob,
+  'FileSystemMemory.getBlobUrl': getBlobUrl,
+  'FileSystemMemory.getFiles': getFiles,
+  'FileSystemMemory.mkdir': mkdir,
+  'FileSystemMemory.readDirWithFileTypes': readDirWithFileTypes,
+  'FileSystemMemory.readFile': readFile,
+  'FileSystemMemory.remove': remove,
+  'FileSystemMemory.writeFile': writeFile,
   'IndexedDb.addHandle': addHandle,
   'IndexedDb.get': get,
   'IndexedDb.getHandle': getHandle$1,
@@ -4487,8 +4784,9 @@ const commandMap = {
   'IndexedDb.set': set,
   'SearchFileWithFetch.searchFileWithFetch': searchFile$1,
   'SearchFileWithHtml.searchFileWithHtml': searchFile,
-  'TextSearchFetch.textSearch': textSearch$1,
-  'TextSearchHtml.textSearch': textSearch,
+  'TextSearchFetch.textSearch': textSearch$2,
+  'TextSearchHtml.textSearch': textSearch$1,
+  'TextSearchMemory.textSearch': textSearch,
   'WebView.create3': createWebView3,
   'WebView.createWebViewWorkerRpc': createWebViewWorkerRpc,
   'WebView.getRpcInfo': getRpcInfo,
@@ -4520,9 +4818,9 @@ const commandMap = {
   [DiagnosticExecuteDiagnosticProvider]: executeDiagnosticProvider,
   [ExtensionActivate]: activate,
   [FileSystemGetPathSeparator]: getPathSeparator,
-  [FileSystemReadDirWithFileTypes]: readDirWithFileTypes,
-  [FileSystemReadFile]: readFile,
-  [FileSystemWriteFile]: writeFile,
+  [FileSystemReadDirWithFileTypes]: readDirWithFileTypes$2,
+  [FileSystemReadFile]: readFile$2,
+  [FileSystemWriteFile]: writeFile$2,
   [FormattingExecuteFormmattingProvider]: executeFormattingProvider,
   [HoverExecute]: executeHoverProvider,
   [ImplementationExecuteImplementationProvider]: executeImplementationProvider,