@lvce-editor/extension-host-worker 1.13.0 → 1.15.0

package/dist/extensionHostWorkerMain.js

@@ -4,13 +4,13 @@ const Function = 3;
 const Variable = 4;
 const Keyword = 5;
 const Folder = 6;
-const File$2 = 7;
+const File$3 = 7;
 const Field = 8;
 
 const EditorCompletionType = {
   __proto__: null,
   Field,
-  File: File$2,
+  File: File$3,
   Folder,
   Function,
   Keyword,
@@ -89,7 +89,7 @@ const fn = value => {
   }
 };
 
-const state$9 = {
+const state$a = {
   /** @type{any[]} */
   onDidOpenEditorListeners: [],
   /** @type{any[]} */
@@ -101,19 +101,19 @@ const state$9 = {
   textDocuments: Object.create(null)
 };
 const setDocument = (textDocumentId, textDocument) => {
-  state$9.textDocuments[textDocumentId] = textDocument;
+  state$a.textDocuments[textDocumentId] = textDocument;
 };
 const getDidOpenListeners = () => {
-  return state$9.onDidSaveTextDocumentListeners;
+  return state$a.onDidSaveTextDocumentListeners;
 };
 const getWillChangeListeners = () => {
-  return state$9.onWillChangeEditorListeners;
+  return state$a.onWillChangeEditorListeners;
 };
 const getDidChangeListeners = () => {
-  return state$9.onDidChangeTextDocumentListeners;
+  return state$a.onDidChangeTextDocumentListeners;
 };
 const getDocument = textDocumentId => {
-  return state$9.textDocuments[textDocumentId];
+  return state$a.textDocuments[textDocumentId];
 };
 
 const getOffset$1 = (textDocument, position) => {
@@ -303,7 +303,7 @@ const syncIncremental = (textDocumentId, changes) => {
   textDocument.text = before + syntheticChange.inserted + after;
   runListenersSafe(getDidChangeListeners(), textDocument, syntheticChanges);
 };
-const get$5 = textDocumentId => {
+const get$6 = textDocumentId => {
   const textDocument = getDocument(textDocumentId);
   return textDocument;
 };
@@ -535,7 +535,7 @@ const registerMethod = ({
 }) => {
   context[`execute${name}Provider`] = async function (textDocumentId, ...params) {
     try {
-      const textDocument = get$5(textDocumentId);
+      const textDocument = get$6(textDocumentId);
       if (!textDocument) {
         throw new Error(`textDocument with id ${textDocumentId} not found`);
       }
@@ -670,12 +670,12 @@ const executeOrganizeImports = async uid => {
   if (!organizeImportsAction) {
     return [];
   }
-  const textDocument = get$5(uid);
+  const textDocument = get$6(uid);
   const edits = await organizeImportsAction.execute(textDocument);
   return edits;
 };
 
-const state$8 = {
+const state$9 = {
   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$8.commands) {
+    if (command.id in state$9.commands) {
       throw new Error(`command cannot be registered multiple times`);
     }
-    state$8.commands[command.id] = command;
+    state$9.commands[command.id] = command;
   } catch (error) {
     const commandDisplayId = getCommandDisplay(command);
     throw new VError$1(error, `Failed to register command${commandDisplayId}`);
@@ -709,7 +709,7 @@ const registerCommand = command => {
 };
 const executeCommand = async (id, ...args) => {
   try {
-    const command = state$8.commands[id];
+    const command = state$9.commands[id];
     if (!command) {
       throw new Error(`command ${id} not found`);
     }
@@ -748,14 +748,14 @@ const {
   }]
 });
 
-const state$7 = {
+const state$8 = {
   configuration: Object.create(null)
 };
 const getConfiguration = key => {
-  return state$7.configuration[key] ?? '';
+  return state$8.configuration[key] ?? '';
 };
 const setConfigurations = preferences => {
-  state$7.configuration = preferences;
+  state$8.configuration = preferences;
 };
 
 const Two = '2.0';
@@ -767,10 +767,10 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$4 = (id, fn) => {
+const set$5 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$4 = id => {
+const get$5 = id => {
   return callbacks[id];
 };
 const remove = id => {
@@ -789,14 +789,14 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$4(id, resolve);
+  set$5(id, resolve);
   return {
     id,
     promise
   };
 };
 const resolve = (id, response) => {
-  const fn = get$4(id);
+  const fn = get$5(id);
   if (!fn) {
     console.log(response);
     warn(`callback ${id} may already be disposed`);
@@ -887,14 +887,14 @@ const joinLines$1 = lines => {
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
-const splitLines$1 = lines => {
+const splitLines$2 = lines => {
   return lines.split(NewLine$2);
 };
 const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
     return error;
   }
-  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(1));
+  const currentStack = joinLines$1(splitLines$2(new Error().stack || '').slice(1));
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
@@ -1136,41 +1136,41 @@ const handleIpc = ipc => {
   ipc.addEventListener('message', handleMessage);
 };
 
-const state$6 = {
+const state$7 = {
   /**
    * @type {any}
    */
   ipc: undefined
 };
-const get$3 = () => {
-  return state$6.ipc;
+const get$4 = () => {
+  return state$7.ipc;
 };
-const set$3 = ipc => {
-  state$6.ipc = ipc;
+const set$4 = ipc => {
+  state$7.ipc = ipc;
 };
 
 const send = (method, ...params) => {
-  const ipc = get$3();
+  const ipc = get$4();
   send$1(ipc, method, ...params);
 };
 const invoke = (method, ...params) => {
-  const ipc = get$3();
+  const ipc = get$4();
   return invoke$1(ipc, method, ...params);
 };
 const invokeAndTransfer = (method, ...params) => {
-  const ipc = get$3();
+  const ipc = get$4();
   return invokeAndTransfer$1(ipc, method, ...params);
 };
 const listen$4 = ipc => {
   handleIpc(ipc);
-  set$3(ipc);
+  set$4(ipc);
 };
 
-const state$5 = {
+const state$6 = {
   debugProviderMap: Object.create(null)
 };
 const getDebugProvider = id => {
-  const provider = state$5.debugProviderMap[id];
+  const provider = state$6.debugProviderMap[id];
   if (!provider) {
     // @ts-ignore
     throw new VError$1(`no debug provider "${id}" found`);
@@ -1181,7 +1181,7 @@ const registerDebugProvider = debugProvider => {
   if (!debugProvider.id) {
     throw new Error('Failed to register debug system provider: missing id');
   }
-  state$5.debugProviderMap[debugProvider.id] = debugProvider;
+  state$6.debugProviderMap[debugProvider.id] = debugProvider;
 };
 const start = async (protocol, path) => {
   try {
@@ -1337,7 +1337,7 @@ const exec = async (command, args, options) => {
 };
 
 const fileSystemProviderMap = Object.create(null);
-const get$2 = protocol => {
+const get$3 = protocol => {
   const provider = fileSystemProviderMap[protocol];
   if (!provider) {
     // @ts-ignore
@@ -1345,7 +1345,7 @@ const get$2 = protocol => {
   }
   return provider;
 };
-const set$2 = (id, provider) => {
+const set$3 = (id, provider) => {
   if (!id) {
     throw new Error('Failed to register file system provider: missing id');
   }
@@ -1356,11 +1356,11 @@ const registerFileSystemProvider = fileSystemProvider => {
   if (!fileSystemProvider.id) {
     throw new Error('Failed to register file system provider: missing id');
   }
-  set$2(fileSystemProvider.id, fileSystemProvider);
+  set$3(fileSystemProvider.id, fileSystemProvider);
 };
 const readDirWithFileTypes = async (protocol, path) => {
   try {
-    const provider = get$2(protocol);
+    const provider = get$3(protocol);
     return await provider.readDirWithFileTypes(path);
   } catch (error) {
     throw new VError$1(error, 'Failed to execute file system provider');
@@ -1368,7 +1368,7 @@ const readDirWithFileTypes = async (protocol, path) => {
 };
 const readFile = async (protocol, path) => {
   try {
-    const provider = get$2(protocol);
+    const provider = get$3(protocol);
     return await provider.readFile(path);
   } catch (error) {
     throw new VError$1(error, 'Failed to execute file system provider');
@@ -1396,7 +1396,7 @@ const readDirWithFileTypesExternal = async path => {
 };
 const writeFile = async (protocol, uri, content) => {
   try {
-    const provider = get$2(protocol);
+    const provider = get$3(protocol);
     return await provider.writeFile(uri, content);
   } catch (error) {
     throw new VError$1(error, 'Failed to execute file system provider');
@@ -1404,7 +1404,7 @@ const writeFile = async (protocol, uri, content) => {
 };
 const getPathSeparator = protocol => {
   try {
-    const provider = get$2(protocol);
+    const provider = get$3(protocol);
     return provider.pathSeparator;
   } catch (error) {
     throw new VError$1(error, 'Failed to execute file system provider');
@@ -1654,7 +1654,7 @@ const getExtensionHostSubWorkerUrl = () => {
 };
 const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
-const set$1 = async (url, contentSecurityPolicy) => {
+const set$2 = async (url, contentSecurityPolicy) => {
   const pathName = new URL(url).pathname;
   await invoke('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
 };
@@ -1663,7 +1663,7 @@ const rpcs$1 = Object.create(null);
 const add$1 = (id, rpc) => {
   rpcs$1[id] = rpc;
 };
-const get$1 = id => {
+const get$2 = id => {
   return rpcs$1[id];
 };
 
@@ -1677,16 +1677,16 @@ const acquire = id => {
   delete registry[id];
   return fn;
 };
-const get = id => {
+const get$1 = id => {
   return rpcs[id];
 };
-const set = (id, rpc) => {
+const set$1 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 
 const createRpcWithId$1 = async id => {
   const fn = acquire(id);
-  const info = get$1(id);
+  const info = get$2(id);
   if (!info) {
     throw new Error(`rpc with id ${id} not found`);
   }
@@ -1701,16 +1701,16 @@ const createRpcWithId$1 = async id => {
     execute: fn
   });
   await newRpc.invoke('LoadFile.loadFile', info.url);
-  set(id, newRpc);
+  set$1(id, newRpc);
   return newRpc;
 };
 
 const getOrCreateRpc = async id => {
-  const rpc = get(id);
+  const rpc = get$1(id);
   if (!rpc) {
-    set(id, createRpcWithId$1(id));
+    set$1(id, createRpcWithId$1(id));
   }
-  return get(id);
+  return get$1(id);
 };
 const createRpcWithId = ({
   id,
@@ -1745,7 +1745,7 @@ const createLegacyRpc = async ({
   string(name);
   fn(execute);
   if (contentSecurityPolicy) {
-    await set$1(url, contentSecurityPolicy);
+    await set$2(url, contentSecurityPolicy);
   }
   const ipc = await create$7({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
@@ -1801,17 +1801,17 @@ const {
   }
 });
 
-const state$4 = {
+const state$5 = {
   providers: Object.create(null)
 };
 const registerSourceControlProvider = provider => {
-  state$4.providers[provider.id] = provider;
+  state$5.providers[provider.id] = provider;
 };
 const getFilesFromProvider = provider => {
   return provider.getChangedFiles();
 };
 const getChangedFiles = async providerId => {
-  const provider = state$4.providers[providerId];
+  const provider = state$5.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -1822,7 +1822,7 @@ const getChangedFiles = async providerId => {
 const getFileBefore = async (providerId, uri) => {
   string(providerId);
   string(uri);
-  const provider = state$4.providers[providerId];
+  const provider = state$5.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -1844,7 +1844,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$4.providers[providerId];
+  const provider = state$5.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -1852,14 +1852,14 @@ const getGroups = async (providerId, cwd) => {
   return groups;
 };
 const acceptInput = async (providerId, value) => {
-  const provider = state$4.providers[providerId];
+  const provider = state$5.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$4.providers)[0];
+  const provider = Object.values(state$5.providers)[0];
   if (!provider) {
     return;
   }
@@ -1867,7 +1867,7 @@ const add = async path => {
   await provider.add(path);
 };
 const discard = async path => {
-  const provider = Object.values(state$4.providers)[0];
+  const provider = Object.values(state$5.providers)[0];
   if (!provider) {
     return;
   }
@@ -1877,7 +1877,7 @@ const discard = async path => {
 const getEnabledProviderIds = async (scheme, root) => {
   string(scheme);
   string(root);
-  const providers = Object.values(state$4.providers);
+  const providers = Object.values(state$5.providers);
   const enabledIds = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -1906,7 +1906,7 @@ const {
   }
 });
 
-const state$3 = {
+const state$4 = {
   textSearchProviders: Object.create(null)
 };
 const registerTextSearchProvider = textSearchProvider => {
@@ -1917,14 +1917,14 @@ const registerTextSearchProvider = textSearchProvider => {
     if (!textSearchProvider.scheme) {
       throw new Error('textSearchProvider is missing scheme');
     }
-    state$3.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+    state$4.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
   } catch (error) {
     throw new VError$1(error, 'Failed to register text search provider');
   }
 };
 const executeTextSearchProvider = async (scheme, query) => {
   try {
-    const textSearchProvider = state$3.textSearchProviders[scheme];
+    const textSearchProvider = state$4.textSearchProviders[scheme];
     if (!textSearchProvider) {
       throw new Error(`No text search provider for ${scheme} found`);
     }
@@ -2181,14 +2181,14 @@ const createWorker = async ({
   return ipc;
 };
 
-const state$2 = {
+const state$3 = {
   workspacePath: ''
 };
 const setWorkspacePath = path => {
-  state$2.workspacePath = path;
+  state$3.workspacePath = path;
 };
 const getWorkspaceFolder = path => {
-  return state$2.workspacePath;
+  return state$3.workspacePath;
 };
 
 class FormattingError extends Error {
@@ -2200,12 +2200,12 @@ class FormattingError extends Error {
   }
 }
 
-const File$1 = 1;
+const File$2 = 1;
 const Match = 2;
 
 const TextSearchResultType = {
   __proto__: null,
-  File: File$1,
+  File: File$2,
   Match
 };
 
@@ -2418,7 +2418,7 @@ class ContentSecurityPolicyError extends Error {
   }
 }
 
-const state$1 = {
+const state$2 = {
   /**
    * @type {any[]}
    */
@@ -2426,13 +2426,13 @@ const state$1 = {
 };
 const addError = error => {
   // @ts-ignore
-  state$1.errors.push(error);
+  state$2.errors.push(error);
 };
 const hasRecentErrors = () => {
-  return state$1.errors.length > 0;
+  return state$2.errors.length > 0;
 };
 const getRecentError = () => {
-  return state$1.errors.at(-1);
+  return state$2.errors.at(-1);
 };
 
 const isImportErrorChrome = error => {
@@ -2542,7 +2542,7 @@ const CallExpression = 'CallExpression';
 const ExportAllDeclaration = 'ExportAllDeclaration';
 const ExportNamedDeclaration = 'ExportNamedDeclaration';
 const ExpressionStatement = 'ExpressionStatement';
-const File = 'File';
+const File$1 = 'File';
 const Import = 'Import';
 const ImportDeclaration = 'ImportDeclaration';
 const Program = 'Program';
@@ -2562,7 +2562,7 @@ const walk = (node, visitor) => {
   }
   visitor(node);
   switch (node.type) {
-    case File:
+    case File$1:
       walk(node.program, visitor);
       break;
     case Program:
@@ -2858,7 +2858,7 @@ const mockRpc = () => {
 };
 
 const getStatusBarItems = async () => {
-  const providers = Object.values(state$4.providers);
+  const providers = Object.values(state$5.providers);
   const statusBarItems = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -3054,14 +3054,14 @@ const NewLine$1 = '\n';
 const joinLines = lines => {
   return lines.join(NewLine$1);
 };
-const splitLines = 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(stderr);
+  const lines = splitLines$1(stderr);
   const messageIndex = lines.findIndex(isModuleNotFoundMessage);
   const message = lines[messageIndex];
   return {
@@ -3085,7 +3085,7 @@ const isMessageCodeBlockEndIndex = line => {
   return RE_MESSAGE_CODE_BLOCK_END.test(line);
 };
 const getMessageCodeBlock = stderr => {
-  const lines = splitLines(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);
@@ -3149,7 +3149,7 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
   if (isModuleNotFoundError(stderr)) {
     return getModuleNotFoundError(stderr);
   }
-  const lines = splitLines(stderr);
+  const lines = splitLines$1(stderr);
   const {
     actualMessage,
     rest
@@ -3340,35 +3340,6 @@ const handleMessagePort = port => {
   ipc.send('ready');
 };
 
-const serializeWebView = async webView => {
-  if (webView && webView.provider && webView.provider.saveState) {
-    const saved = await webView.provider.saveState();
-    return {
-      uri: webView.uri,
-      state: saved
-    };
-  }
-  return undefined;
-};
-const serializeWebViews = async webViews => {
-  const serialized = [];
-  for (const [key, value] of Object.entries(webViews)) {
-    const serializedValue = await serializeWebView(value);
-    if (serializedValue) {
-      serialized.push({
-        key,
-        value: serializedValue
-      });
-    }
-  }
-  return serialized;
-};
-const saveState = async () => {
-  const webViews = getWebViews();
-  const serialized = await serializeWebViews(webViews);
-  return serialized;
-};
-
 const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
 let idbProxyableTypes;
 let cursorAdvanceMethods;
@@ -3623,7 +3594,7 @@ replaceTraps(oldTraps => ({
   }
 }));
 
-const state = {
+const state$1 = {
   databases: Object.create(null),
   eventId: 0,
   dbVersion: 1,
@@ -3639,9 +3610,9 @@ const isDataCloneError = error => {
 
 // TODO high memory usage in idb because of transactionDoneMap
 
-const getDb = async () => {
+const getDb$1 = async () => {
   // @ts-ignore
-  const db = await openDB('session', state.dbVersion, {
+  const db = await openDB('session', state$1.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('session')) {
         const objectStore = await db.createObjectStore('session', {
@@ -3655,13 +3626,13 @@ const getDb = async () => {
   });
   return db;
 };
-const getDbMemoized = async () => {
-  state.cachedDb ||= await getDb();
-  return state.cachedDb;
+const getDbMemoized$1 = async () => {
+  state$1.cachedDb ||= await getDb$1();
+  return state$1.cachedDb;
 };
 const saveValue = async (storeId, value) => {
   try {
-    const db = await getDbMemoized();
+    const db = await getDbMemoized$1();
     await db.add('session', value);
   } catch (error) {
     if (isDataCloneError(error)) {
@@ -3673,7 +3644,7 @@ const saveValue = async (storeId, value) => {
 };
 const getValues = async storeId => {
   try {
-    const db = await getDbMemoized();
+    const db = await getDbMemoized$1();
     const tx = db.transaction(storeId, 'readwrite');
     const [objects] = await Promise.all([tx.store.getAll(), tx.done]);
     console.log({
@@ -3685,7 +3656,7 @@ const getValues = async storeId => {
   }
 };
 const getValuesByIndexName = async (storeId, indexName, only) => {
-  const db = await getDbMemoized();
+  const db = await getDbMemoized$1();
   const transaction = db.transaction(storeId);
   const index = transaction.store.index(indexName);
   const iterator = index.iterate(only);
@@ -3696,7 +3667,7 @@ const getValuesByIndexName = async (storeId, indexName, only) => {
   return objects;
 };
 const getHandleDb = async () => {
-  const db = await openDB('handle', state.dbVersion, {
+  const db = await openDB('handle', state$1.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('file-handles-store')) {
         // @ts-ignore
@@ -3710,20 +3681,264 @@ const addHandle = async (uri, handle) => {
   const handleDb = await getHandleDb();
   await handleDb.put('file-handles-store', handle, uri);
 };
-const getHandle = async uri => {
+const getHandle$1 = async uri => {
   const handleDb = await getHandleDb();
   const handle = await handleDb.get('file-handles-store', uri);
   return handle;
 };
 
+// TODO high memory usage in idb because of transactionDoneMap
+
+const state = {
+  databases: Object.create(null),
+  dbVersion: 2,
+  cachedDb: undefined
+};
+const storeId = 'lvce-keyvalue';
+const getDb = async () => {
+  const db = await openDB(storeId, state.dbVersion, {
+    async upgrade(db, oldVersion) {
+      if (!db.objectStoreNames.contains(storeId)) {
+        await db.createObjectStore(storeId, {
+          autoIncrement: true
+        });
+      }
+    }
+  });
+  return db;
+};
+const getDbMemoized = async () => {
+  state.cachedDb ||= await getDb();
+  return state.cachedDb;
+};
+const set = async (key, value) => {
+  try {
+    const db = await getDbMemoized();
+    await db.put(storeId, value, key);
+  } catch (error) {
+    throw new VError$1(error, 'Failed to save value to indexed db');
+  }
+};
+const get = async key => {
+  try {
+    const db = await getDbMemoized();
+    const value = db.get(storeId, key);
+    return value;
+  } catch (error) {
+    throw new VError$1(error, 'Failed to get value from indexed db');
+  }
+};
+
+const serializeWebView = async webView => {
+  if (webView && webView.provider && webView.provider.saveState) {
+    const saved = await webView.provider.saveState();
+    return {
+      uri: webView.uri,
+      state: saved
+    };
+  }
+  return undefined;
+};
+const serializeWebViews = async webViews => {
+  const serialized = [];
+  for (const [key, value] of Object.entries(webViews)) {
+    const serializedValue = await serializeWebView(value);
+    if (serializedValue) {
+      serialized.push({
+        key,
+        value: serializedValue
+      });
+    }
+  }
+  return serialized;
+};
+const saveState = async () => {
+  const webViews = getWebViews();
+  const serialized = await serializeWebViews(webViews);
+  return serialized;
+};
+
+class FileNotFoundError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'FileNotFoundError';
+  }
+}
+
+const Directory = 'directory';
+const File = 'file';
+
+// based on https://github.com/microsoft/vscode/blob/c0769274fa136b45799edeccc0d0a2f645b75caf/src/vs/base/common/arrays.ts#L625 (License MIT)
+
+const insertInto = (array, start, newItems) => {
+  const originalLength = array.length;
+  const newItemsLength = newItems.length;
+  array.length = originalLength + newItemsLength;
+  // Move the items after the start index, start from the end so that we don't overwrite any value.
+  for (let i = originalLength - 1; i >= start; i--) {
+    array[i + newItemsLength] = array[i];
+  }
+  for (let i = 0; i < newItemsLength; i++) {
+    array[i + start] = newItems[i];
+  }
+};
+const push = (array, newItems) => {
+  insertInto(array, array.length, newItems);
+};
+const fromAsync = async asyncIterable => {
+  const children = [];
+  for await (const value of asyncIterable) {
+    children.push(value);
+  }
+  return children;
+};
+
+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$1(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 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$1(error, 'Failed to get handle');
+  }
+};
+
+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 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$2,
+      text: file,
+      start: 0,
+      end: 0,
+      lineNumber: 0
+    });
+  }
+  return results;
+};
+
+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 = 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;
+};
+
 const commandMap = {
   'ExtensionHostRename.executeprepareRenameProvider': executeprepareRenameProvider,
   'ExtensionHostRename.executeRenameProvider': executeRenameProvider,
   'IndexedDb.addHandle': addHandle,
-  'IndexedDb.getHandle': getHandle,
+  'IndexedDb.get': get,
+  'IndexedDb.getHandle': getHandle$1,
   'IndexedDb.getValues': getValues,
   'IndexedDb.getValuesByIndexName': getValuesByIndexName,
   'IndexedDb.saveValue': saveValue,
+  'IndexedDb.set': set,
+  'TextSearchHtml.textSearch': textSearch,
   ['ExtensionHostDebug.evaluate']: evaluate,
   ['ExtensionHostDebug.getProperties']: getProperties,
   ['ExtensionHostDebug.listProcesses']: listProcesses,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/extension-host-worker",
-  "version": "1.13.0",
+  "version": "1.15.0",
   "description": "Webworker for the extension host functionality in Lvce Editor.",
   "main": "dist/extensionHostWorkerMain.js",
   "type": "module",