@lvce-editor/extension-host-worker 3.14.0 → 3.16.0

package/dist/extensionHostWorkerMain.js

@@ -89,7 +89,7 @@ const fn = value => {
   }
 };
 
-const state$c = {
+const state$e = {
   /** @type{any[]} */
   onDidOpenEditorListeners: [],
   /** @type{any[]} */
@@ -101,19 +101,19 @@ const state$c = {
   textDocuments: Object.create(null)
 };
 const setDocument = (textDocumentId, textDocument) => {
-  state$c.textDocuments[textDocumentId] = textDocument;
+  state$e.textDocuments[textDocumentId] = textDocument;
 };
 const getDidOpenListeners = () => {
-  return state$c.onDidSaveTextDocumentListeners;
+  return state$e.onDidSaveTextDocumentListeners;
 };
 const getWillChangeListeners = () => {
-  return state$c.onWillChangeEditorListeners;
+  return state$e.onWillChangeEditorListeners;
 };
 const getDidChangeListeners = () => {
-  return state$c.onDidChangeTextDocumentListeners;
+  return state$e.onDidChangeTextDocumentListeners;
 };
 const getDocument = textDocumentId => {
-  return state$c.textDocuments[textDocumentId];
+  return state$e.textDocuments[textDocumentId];
 };
 
 const getOffset$1 = (textDocument, position) => {
@@ -303,11 +303,11 @@ const syncIncremental = (textDocumentId, changes) => {
   textDocument.text = before + syntheticChange.inserted + after;
   runListenersSafe(getDidChangeListeners(), textDocument, syntheticChanges);
 };
-const get$6 = textDocumentId => {
+const get$a = textDocumentId => {
   const textDocument = getDocument(textDocumentId);
   return textDocument;
 };
-const getText$1 = textDocument => {
+const getText$2 = textDocument => {
   return textDocument.text;
 };
 const setLanguageId = (textDocumentId, languageId) => {
@@ -319,8 +319,8 @@ const setLanguageId = (textDocumentId, languageId) => {
   runListenersSafe(getDidOpenListeners(), newTextDocument);
 };
 
-const BABEL_PARSER_SYNTAX_ERROR = 'BABEL_PARSER_SYNTAX_ERROR';
 const E_NO_PROVIDER_FOUND = 'E_NO_PROVIDER_FOUND';
+const BABEL_PARSER_SYNTAX_ERROR = 'BABEL_PARSER_SYNTAX_ERROR';
 
 class NoProviderFoundError extends Error {
   constructor(message) {
@@ -439,9 +439,9 @@ const getCombinedMessage = (error, message) => {
   }
   return stringifiedError;
 };
-const NewLine$2 = '\n';
+const NewLine$3 = '\n';
 const getNewLineIndex$1 = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine$2, startIndex);
+  return string.indexOf(NewLine$3, startIndex);
 };
 const mergeStacks = (parent, child) => {
   if (!child) {
@@ -535,7 +535,7 @@ const registerMethod = ({
 }) => {
   context[`execute${name}Provider`] = async function (textDocumentId, ...params) {
     try {
-      const textDocument = get$6(textDocumentId);
+      const textDocument = get$a(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$6(uid);
+  const textDocument = get$a(uid);
   const edits = await organizeImportsAction.execute(textDocument);
   return edits;
 };
 
-const state$b = {
+const state$d = {
   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$b.commands) {
+    if (command.id in state$d.commands) {
       throw new Error(`command cannot be registered multiple times`);
     }
-    state$b.commands[command.id] = command;
+    state$d.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$b.commands[id];
+    const command = state$d.commands[id];
     if (!command) {
       throw new Error(`command ${id} not found`);
     }
@@ -748,40 +748,40 @@ const {
   }]
 });
 
-const state$a = {
+const state$c = {
   configuration: Object.create(null)
 };
 const getConfiguration = key => {
-  return state$a.configuration[key] ?? '';
+  return state$c.configuration[key] ?? '';
 };
 const setConfigurations = preferences => {
-  state$a.configuration = preferences;
+  state$c.configuration = preferences;
 };
 
-const state$9 = {
+const state$b = {
   rpc: undefined
 };
 const invoke$2 = (method, ...params) => {
-  const rpc = state$9.rpc;
+  const rpc = state$b.rpc;
   return rpc.invoke(method, ...params);
 };
 const send$1 = (method, ...params) => {
-  const rpc = state$9.rpc;
+  const rpc = state$b.rpc;
   return rpc.send(method, ...params);
 };
 const invokeAndTransfer$1 = (method, ...params) => {
-  const rpc = state$9.rpc;
+  const rpc = state$b.rpc;
   return rpc.invokeAndTransfer(method, ...params);
 };
 const setRpc = rpc => {
-  state$9.rpc = rpc;
+  state$b.rpc = rpc;
 };
 
-const state$8 = {
+const state$a = {
   debugProviderMap: Object.create(null)
 };
 const getDebugProvider = id => {
-  const provider = state$8.debugProviderMap[id];
+  const provider = state$a.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$8.debugProviderMap[debugProvider.id] = debugProvider;
+  state$a.debugProviderMap[debugProvider.id] = debugProvider;
 };
 const start = async (protocol, path) => {
   try {
@@ -948,7 +948,7 @@ const exec = async (command, args, options) => {
 };
 
 const fileSystemProviderMap = Object.create(null);
-const get$5 = protocol => {
+const get$9 = protocol => {
   const provider = fileSystemProviderMap[protocol];
   if (!provider) {
     // @ts-ignore
@@ -956,7 +956,7 @@ const get$5 = protocol => {
   }
   return provider;
 };
-const set$4 = (id, provider) => {
+const set$8 = (id, provider) => {
   if (!id) {
     throw new Error('Failed to register file system provider: missing id');
   }
@@ -967,11 +967,11 @@ const registerFileSystemProvider = fileSystemProvider => {
   if (!fileSystemProvider.id) {
     throw new Error('Failed to register file system provider: missing id');
   }
-  set$4(fileSystemProvider.id, fileSystemProvider);
+  set$8(fileSystemProvider.id, fileSystemProvider);
 };
 const readDirWithFileTypes$2 = async (protocol, path) => {
   try {
-    const provider = get$5(protocol);
+    const provider = get$9(protocol);
     return await provider.readDirWithFileTypes(path);
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -979,7 +979,7 @@ const readDirWithFileTypes$2 = async (protocol, path) => {
 };
 const readFile$2 = async (protocol, path) => {
   try {
-    const provider = get$5(protocol);
+    const provider = get$9(protocol);
     return await provider.readFile(path);
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -1007,7 +1007,7 @@ const readDirWithFileTypesExternal = async path => {
 };
 const writeFile$2 = async (protocol, uri, content) => {
   try {
-    const provider = get$5(protocol);
+    const provider = get$9(protocol);
     return await provider.writeFile(uri, content);
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -1015,7 +1015,7 @@ const writeFile$2 = async (protocol, uri, content) => {
 };
 const getPathSeparator = protocol => {
   try {
-    const provider = get$5(protocol);
+    const provider = get$9(protocol);
     return provider.pathSeparator;
   } catch (error) {
     throw new VError(error, 'Failed to execute file system provider');
@@ -1188,9 +1188,9 @@ class Ipc extends EventTarget {
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
 const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
-const NewLine$1 = '\n';
+const NewLine$2 = '\n';
 const joinLines$1 = lines => {
-  return lines.join(NewLine$1);
+  return lines.join(NewLine$2);
 };
 const RE_AT = /^\s+at/;
 const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
@@ -1217,7 +1217,7 @@ const getDetails = lines => {
   };
 };
 const splitLines$2 = lines => {
-  return lines.split(NewLine$1);
+  return lines.split(NewLine$2);
 };
 const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
 const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
@@ -1645,18 +1645,18 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$3 = (id, fn) => {
+const set$7 = (id, fn) => {
   callbacks[id] = fn;
 };
-const get$4 = id => {
+const get$8 = id => {
   return callbacks[id];
 };
 const remove$2 = id => {
   delete callbacks[id];
 };
-let id = 0;
+let id$1 = 0;
 const create$3$1 = () => {
-  return ++id;
+  return ++id$1;
 };
 const registerPromise = () => {
   const id = create$3$1();
@@ -1664,7 +1664,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$3(id, resolve);
+  set$7(id, resolve);
   return {
     id,
     promise
@@ -1692,7 +1692,7 @@ class JsonRpcError extends Error {
     this.name = 'JsonRpcError';
   }
 }
-const NewLine = '\n';
+const NewLine$1 = '\n';
 const DomException = 'DOMException';
 const ReferenceError$1 = 'ReferenceError';
 const SyntaxError$1 = 'SyntaxError';
@@ -1738,22 +1738,22 @@ const constructError = (message, type, name) => {
   return new ErrorConstructor(message);
 };
 const getNewLineIndex = (string, startIndex = undefined) => {
-  return string.indexOf(NewLine, startIndex);
+  return string.indexOf(NewLine$1, startIndex);
 };
 const getParentStack = error => {
   let parentStack = error.stack || error.data || error.message || '';
   if (parentStack.startsWith('    at')) {
-    parentStack = error.message + NewLine + parentStack;
+    parentStack = error.message + NewLine$1 + parentStack;
   }
   return parentStack;
 };
 const joinLines = lines => {
-  return lines.join(NewLine);
+  return lines.join(NewLine$1);
 };
 const MethodNotFound = -32601;
 const Custom = -32001;
 const splitLines$1 = lines => {
-  return lines.split(NewLine);
+  return lines.split(NewLine$1);
 };
 const restoreJsonRpcError = error => {
   if (error && error instanceof Error) {
@@ -1763,14 +1763,14 @@ const restoreJsonRpcError = error => {
   if (error && error.code && error.code === MethodNotFound) {
     const restoredError = new JsonRpcError(error.message);
     const parentStack = getParentStack(error);
-    restoredError.stack = parentStack + NewLine + currentStack;
+    restoredError.stack = parentStack + NewLine$1 + currentStack;
     return restoredError;
   }
   if (error && error.message) {
     const restoredError = constructError(error.message, error.type, error.name);
     if (error.data) {
       if (error.data.stack && error.data.type && error.message) {
-        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
+        restoredError.stack = error.data.type + ': ' + error.message + NewLine$1 + error.data.stack + NewLine$1 + currentStack;
       } else if (error.data.stack) {
         restoredError.stack = error.data.stack;
       }
@@ -1817,14 +1817,14 @@ const unwrapJsonRpcResult = responseMessage => {
   }
   throw new JsonRpcError('unexpected response message');
 };
-const warn = (...args) => {
+const warn$1 = (...args) => {
   console.warn(...args);
 };
 const resolve = (id, response) => {
-  const fn = get$4(id);
+  const fn = get$8(id);
   if (!fn) {
     console.log(response);
-    warn(`callback ${id} may already be disposed`);
+    warn$1(`callback ${id} may already be disposed`);
     return;
   }
   fn(response);
@@ -2402,7 +2402,7 @@ const getExtensionHostSubWorkerUrl = () => {
 };
 const extensionHostSubWorkerUrl = getExtensionHostSubWorkerUrl();
 
-const set$2 = async (url, contentSecurityPolicy) => {
+const set$6 = async (url, contentSecurityPolicy) => {
   const pathName = new URL(url).pathname;
   await invoke$2('ExtensionHostWorkerContentSecurityPolicy.set', pathName, contentSecurityPolicy);
 };
@@ -2422,7 +2422,7 @@ const createLegacyRpc = async ({
   string(name);
   object(commandMap);
   if (contentSecurityPolicy) {
-    await set$2(url, contentSecurityPolicy);
+    await set$6(url, contentSecurityPolicy);
   }
   const rpc = await create$2({
     method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
@@ -2443,7 +2443,7 @@ const rpcs$1 = Object.create(null);
 const add$1 = (id, rpc) => {
   rpcs$1[id] = rpc;
 };
-const get$3 = id => {
+const get$7 = id => {
   return rpcs$1[id];
 };
 
@@ -2452,15 +2452,15 @@ const rpcs = Object.create(null);
 const register = (id, execute) => {
   registry[id] = execute;
 };
-const get$2 = id => {
+const get$6 = id => {
   return rpcs[id];
 };
-const set$1 = (id, rpc) => {
+const set$5 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 
 const createRpcWithId$1 = async (id, commandMap, execute) => {
-  const info = get$3(id);
+  const info = get$7(id);
   if (!info) {
     throw new Error(`rpc with id ${id} not found`);
   }
@@ -2476,16 +2476,16 @@ const createRpcWithId$1 = async (id, commandMap, execute) => {
     rpc.ipc.execute = execute;
   }
   await rpc.invoke('LoadFile.loadFile', info.url);
-  set$1(id, rpc);
+  set$5(id, rpc);
   return rpc;
 };
 
 const getOrCreateRpc = async (id, commandMap, execute) => {
-  const rpc = get$2(id);
+  const rpc = get$6(id);
   if (!rpc) {
-    set$1(id, createRpcWithId$1(id, commandMap, execute));
+    set$5(id, createRpcWithId$1(id, commandMap, execute));
   }
-  return get$2(id);
+  return get$6(id);
 };
 const createRpcWithId = ({
   id,
@@ -2551,17 +2551,17 @@ const {
   }
 });
 
-const state$7 = {
+const state$9 = {
   providers: Object.create(null)
 };
 const registerSourceControlProvider = provider => {
-  state$7.providers[provider.id] = provider;
+  state$9.providers[provider.id] = provider;
 };
 const getFilesFromProvider = provider => {
   return provider.getChangedFiles();
 };
 const getChangedFiles = async providerId => {
-  const provider = state$7.providers[providerId];
+  const provider = state$9.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$7.providers[providerId];
+  const provider = state$9.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$7.providers[providerId];
+  const provider = state$9.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$7.providers[providerId];
+  const provider = state$9.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$7.providers)[0];
+  const provider = Object.values(state$9.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$7.providers)[0];
+  const provider = Object.values(state$9.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$7.providers);
+  const providers = Object.values(state$9.providers);
   const enabledIds = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -2656,7 +2656,7 @@ const {
   }
 });
 
-const state$6 = {
+const state$8 = {
   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$6.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+    state$8.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$6.textSearchProviders[scheme];
+    const textSearchProvider = state$8.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$5 = {
+const state$7 = {
   workspacePath: ''
 };
 const setWorkspacePath = path => {
-  state$5.workspacePath = path;
+  state$7.workspacePath = path;
 };
 const getWorkspaceFolder = path => {
-  return state$5.workspacePath;
+  return state$7.workspacePath;
 };
 
 class FormattingError extends Error {
@@ -2969,7 +2969,7 @@ const api = {
   registerTabCompletionProvider: registerTabCompletionProvider,
   executeTabCompletionProvider: executeTabCompletionProvider,
   // Text Document
-  getTextFromTextDocument: getText$1,
+  getTextFromTextDocument: getText$2,
   // Text Search
   registerTextSearchProvider: registerTextSearchProvider,
   executeTextSearchProvider: executeTextSearchProvider,
@@ -3024,7 +3024,7 @@ const handleUnhandledRejection = event => {
   console.error(output);
 };
 
-const state$4 = {
+const state$6 = {
   /**
    * @type {any[]}
    */
@@ -3032,10 +3032,10 @@ const state$4 = {
 };
 const addError = error => {
   // @ts-ignore
-  state$4.errors.push(error);
+  state$6.errors.push(error);
 };
 const hasRecentErrors = () => {
-  return state$4.errors.length > 0;
+  return state$6.errors.length > 0;
 };
 const getRecentError = () => {
 };
@@ -3084,236 +3084,833 @@ const applyBulkReplacement = async (files, ranges, replacement) => {
   throw new Error('not implemented');
 };
 
-const getAssetDir = () => {
-  // @ts-ignore
-  if (typeof ASSET_DIR !== 'undefined') {
-    // @ts-ignore
-    return ASSET_DIR;
-  }
-  if (platform === Electron) {
-    return '../../../../..';
-  }
-  return '';
-};
-const assetDir = getAssetDir();
-
-const iframeWorkerUrl = `${assetDir}/packages/renderer-worker/node_modules/@lvce-editor/iframe-worker/dist/iframeWorkerMain.js`;
-
-const get$1 = key => {
-  return invoke$2('Preferences.get', key);
-};
-
-const getConfiguredIframeWorkerUrl = async () => {
-  let configuredWorkerUrl = (await get$1('develop.iframeWorkerPath')) || '';
-  if (configuredWorkerUrl) {
-    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
-  }
-  configuredWorkerUrl = configuredWorkerUrl || iframeWorkerUrl;
-  return configuredWorkerUrl;
+const addCssStyleSheet = (id, css) => {
+  return invoke$2('Css.addCssStyleSheet', id, css);
 };
 
-const state$3 = {
-  id: 0
-};
-const create$1 = () => {
-  return ++state$3.id;
-};
+const NewLine = '\n';
 
-const commandMap$1 = {
-  'WebView.compatExtensionHostWorkerInvoke': (...args) => invoke$2('WebView.compatExtensionHostWorkerInvoke', ...args),
-  'WebView.compatExtensionHostWorkerInvokeAndTransfer': (...args) => invokeAndTransfer$1('WebView.compatExtensionHostWorkerInvokeAndTransfer', ...args),
-  'WebView.compatRendererProcessInvoke': (...args) => invoke$2('WebView.compatRendererProcessInvoke', ...args),
-  'WebView.compatRendererProcessInvokeAndTransfer': (...args) => invokeAndTransfer$1('WebView.compatRendererProcessInvokeAndTransfer', ...args),
-  // @ts-ignore
-  'WebView.compatRendererWorkerInvokeAndTransfer': (...args) => invokeAndTransfer$1(...args),
-  // @ts-ignore
-  'WebView.compatRendererWorkerInvoke': (...args) => invoke$2(...args),
-  'WebView.compatSharedProcessInvoke': (...args) => invoke$2('WebView.compatSharedProcessInvoke', ...args),
-  'WebView.getSavedState': (...args) => invoke$2('WebView.getSavedState', ...args),
-  'WebView.getWebViewInfo': (...args) => invoke$2('WebView.getWebViewInfo', ...args),
-  'WebView.getWebViews': (...args) => invoke$2('WebView.getWebViews', ...args),
-  'WebView.setPort': (...args) => invoke$2('WebView.setPort', ...args),
-  'ExtensionHostManagement.activateByEvent': (...args) => invoke$2('ExtensionHostManagement.activateByEvent', ...args),
-  'WebView.getRemoteUrl': options => getRemoteUrlForWebView(options.uri, options)
-};
-const launchIframeWorker = async () => {
-  const configuredWorkerUrl = await getConfiguredIframeWorkerUrl();
-  const name = 'Iframe Worker';
-  const id = create$1();
-  const rpc = await create$2({
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
-    name,
-    url: configuredWorkerUrl,
-    id,
-    commandMap: commandMap$1
-  });
-  return rpc;
+const warn = (...args) => {
+  console.warn(...args);
 };
 
-let workerPromise;
-const ensureWorker = () => {
-  if (!workerPromise) {
-    workerPromise = launchIframeWorker();
-  }
-  return workerPromise;
-};
-const invoke = async (method, ...params) => {
-  const rpc = await ensureWorker();
-  return rpc.invoke(method, ...params);
+const transparent = (color, factor) => {
+  return color;
 };
-
-const createWebView3 = async ({
-  id,
-  uri,
-  isGitpod,
-  platform,
-  assetDir,
-  webViewScheme,
-  useNewWebViewHandler
-}) => {
-  await invoke('WebView.create3', {
-    id,
-    uri,
-    isGitpod,
-    platform,
-    assetDir,
-    webViewScheme,
-    useNewWebViewHandler
-  });
+const toColorRule = ([key, value]) => {
+  return `  --${key}: ${value};`;
 };
-
-const createWebViewWorkerRpc = async (rpcInfo, port) => {
-  // TODO this function is called from the iframe worker to create a direct
-  // connection between a webview/iframe and it's webworker. For this to work
-  // the iframe worker creates a messagechannel and sends one messageport to the webview
-  // and the other messageport to the webworker. This enables direct communication via
-  // the two message ports
-
-  // TODO have a way so that the worker already includes the webview api and the extension
-  // host subworker doesn't need to import the other file
-  await invokeAndTransfer$1('IpcParent.create', {
-    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
-    url: extensionHostSubWorkerUrl,
-    name: rpcInfo.name,
-    raw: true,
-    port
-  });
+const toTokenColorRule = tokenColor => {
+  return `.${tokenColor.name} { color: ${tokenColor.foreground} }`;
 };
-
-const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
-const ClosingTagExecuteClosingTagProvider = 'ExtensionHostClosingTag.executeClosingTagProvider';
-const CommandExecute = 'ExtensionHostCommand.executeCommand';
-const CompletionExecute = 'ExtensionHostCompletion.execute';
-const CompletionResolveExecute = 'ExtensionHostCompletion.executeResolve';
-const DefinitionExecuteDefinitionProvider = 'ExtensionHostDefinition.executeDefinitionProvider';
-const DiagnosticExecuteDiagnosticProvider = 'ExtensionHost.executeDiagnosticProvider';
-const ExtensionActivate = 'ExtensionHostExtension.activate';
-const FileSystemGetPathSeparator = 'ExtensionHostFileSystem.getPathSeparator';
-const FileSystemReadDirWithFileTypes = 'ExtensionHostFileSystem.readDirWithFileTypes';
-const FileSystemReadFile = 'ExtensionHostFileSystem.readFile';
-const FileSystemWriteFile = 'ExtensionHostFileSystem.writeFile';
-const FormattingExecuteFormmattingProvider = 'ExtensionHostFormatting.executeFormattingProvider';
-const HoverExecute = 'ExtensionHostHover.execute';
-const ImplementationExecuteImplementationProvider = 'ExtensionHostImplementation.executeImplementationProvider';
-const MockExec = 'ExtensionHostMockExec.mockExec';
-const MockRpc = 'ExtensionHostMockRpc.mockRpc';
-const OrganizeImportsExecute = 'ExtensionHostOrganizeImports.execute';
-const ReferenceExecuteFileReferenceProvider = 'ExtensionHostReference.executeFileReferenceProvider';
-const ReferenceExecuteReferenceProvider = 'ExtensionHostReference.executeReferenceProvider';
-const SourceControlAcceptInput = 'ExtensionHostSourceControl.acceptInput';
-const SourceControlAdd = 'ExtensionHostSourceControl.add';
-const SourceControlDiscard = 'ExtensionHostSourceControl.discard';
-const SourceControlGetChangedFiles = 'ExtensionHost.sourceControlGetChangedFiles';
-const SourceControlGetEnabledProviderIds = 'ExtensionHostSourceControl.getEnabledProviderIds';
-const SourceControlGetFileBefore = 'ExtensionHostSourceControl.GetFileBefore';
-const SourceControlGetGroups = 'ExtensionHostSourceControl.getGroups';
-const StatusBarGetStatusBarItems = 'ExtensionHost.getStatusBarItems';
-const StatusBarRegisterChangeListener = 'ExtensionHostStatusBar.registerChangeListener';
-const TabCompletionExecuteTabCompletionProvider = 'ExtensionHost.executeTabCompletionProvider';
-const TextDocumentSetLanguageId = 'ExtensionHostTextDocument.setLanguageId';
-const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
-const TextDocumentSyncIncremental = 'ExtensionHostTextDocument.syncIncremental';
-const TextSearchExecuteTextSearchProvider = 'ExtensionHostTextSearch.executeTextSearchProvider';
-const TypeDefinitionExecuteTypeDefinitionProvider = 'ExtensionHostTypeDefinition.executeTypeDefinitionProvider';
-const WorkspaceSetPath = 'Workspace.setWorkspacePath';
-const SelectionExecuteSelectionProvider = 'ExtensionHostSelection.executeSelectionProvider';
-const ConfigurationSetConfiguration = 'ExtensionHostConfiguration.setConfiguration';
-
-const create = () => {
-  return {
-    finished: false
+const addFallbackColors = colors => {
+  const newColors = {
+    ...colors
   };
-};
-const cancel = token => {
-  token.finished = true;
-};
-const isCanceled = token => {
-  return token.finished;
-};
-
-const baseName = path => {
-  const slashIndex = path.lastIndexOf('/');
-  return path.slice(slashIndex + 1);
-};
-const getExtensionId = extension => {
-  if (extension && extension.id) {
-    return extension.id;
+  if (!newColors.ActivityBarInactiveForeground) {
+    // TODO don't assign, avoid mutation
+    newColors.ActivityBarInactiveForeground = transparent(newColors.ActivityBarForeground);
   }
-  if (extension && extension.path) {
-    return baseName(extension.path);
-  }
-  return '<unknown>';
+  newColors.CssVariableName ||= colors.VariableName;
+  return newColors;
 };
-
-const getUrlPrefix = (platform, extensionPath) => {
-  if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
-    return extensionPath;
+const createColorThemeFromJson = (colorThemeId, colorThemeJson) => {
+  if (!colorThemeJson) {
+    warn(`color theme json for "${colorThemeId}" is empty: "${colorThemeJson}"`);
+    return '';
   }
-  if (platform === Web) {
-    return extensionPath;
+  if (typeof colorThemeJson !== 'object') {
+    warn(`color theme json for "${colorThemeId}" cannot be converted to css: "${colorThemeJson}"`);
+    return '';
   }
-  if (extensionPath.startsWith('/')) {
-    return `/remote${extensionPath}`;
+  if (Array.isArray(colorThemeJson)) {
+    warn(`color theme json for "${colorThemeId}" cannot be converted to css, it must be of type object but was of type array`);
+    return '';
   }
-  return `/remote/${extensionPath}`;
-};
-
-const handleRpcInfos = extension => {
-  try {
-    if (!extension) {
-      return;
-    }
-    const rpcs = extension.rpc;
-    const urlPrefix = getUrlPrefix(platform, extension.path);
-    if (!rpcs) {
-      return;
-    }
-    if (!Array.isArray(rpcs)) {
-      return;
-    }
-    for (const rpc of rpcs) {
-      rpc.url = `${urlPrefix}/${rpc.url}`;
-      add$1(rpc.id, rpc);
-    }
-  } catch (error) {
-    console.warn(`Failed to handle extension rpcs: ${error}`);
+  const colors = colorThemeJson.colors;
+  if (!colors) {
+    return '';
   }
-};
+  const newColors = addFallbackColors(colors);
+  const colorRules = Object.entries(newColors).map(toColorRule);
+  const tokenColors = colorThemeJson.tokenColors || [];
+  const tokenColorRules = tokenColors.map(toTokenColorRule);
+  const extraRules = [];
+  if (colors.ContrastBorder) {
+    extraRules.push(`#ActivityBar, #SideBar {
+  border-left: 1px solid var(--ContrastBorder);
+}`, `#Panel {
+  border-top: 1px solid var(--ContrastBorder);
+}`, `#StatusBar {
+  border-top: 1px solid var(--ContrastBorder);
+}`, `.ActivityBarItemBadge {
+  border: 1px solid var(--ContrastBorder);
+}`, `#QuickPick {
+  border: 1px solid var(--ContrastBorder);
+}`);
+  }
+  const colorThemeCss = `:root {\n${colorRules.join(NewLine)}\n}\n\n${tokenColorRules.join(NewLine)}\n\n${extraRules.join(NewLine)}`;
+  return colorThemeCss;
+};
+
+// for (let i = 0; i < 10000; i++) {
+//   createColorThemeFromJson({
+//     type: 'dark',
+//     colors: {
+//       ActivityBarBackground: 'rgb(40, 46, 47)',
+//       ActivityBarForeground: '#878f8c',
+//       ActivityBarActiveBackground: '#1f2727',
+
+//       EditorBackGround: '#1e2324',
+//       EditorScrollBarBackground: 'rgba(57, 71, 71, 0.6)',
+//       EditorCursorBackground: '#a8df5a',
+
+//       ListActiveSelectionBackground: '#515f59',
+//       ListActiveSelectionForeground: '#ffffff',
+//       ListHoverBackground: '#405c5033',
+//       ListHoverForeground: '#e0e0e0',
+//       ListInactiveSelectionBackground: '#3b474280',
+
+//       MainBackground: '#1e2324',
+
+//       PanelBackground: '#1b2020',
+//       PanelBorderTopColor: 'rgba(128, 128, 128, 0.35)',
+
+//       SideBarBackground: '#1b2020',
+
+//       StatusBarBackground: 'rgb(40, 46, 47)',
+//       StatusBarBorderTopColor: '#222222',
+
+//       TabActiveBackground: '#24292a',
+//       TabInactiveBackground: '#282e2f',
+
+//       TitleBarBackground: 'rgb(40, 46, 47)',
+//       TitleBarBorderBottomColor: '#222',
+//       TitleBarColor: '#cccccc',
+//       TitleBarColorInactive: 'rgba(204, 204, 204, 0.6)',
+//     },
+//   }) //?.
+// }
 
-class ContentSecurityPolicyError extends Error {
-  constructor(violatedDirective, sourceFile, lineNumber, columnNumber) {
-    super(`Content Security Policy Violation: ${violatedDirective}`);
-    this.name = 'ContentSecurityPolicyError';
-    if (sourceFile) {
-      this.stack = `Content Security Policy Violation
-    at ${sourceFile}:${lineNumber}:${columnNumber}`;
-    } else {
-      this.stack = `Content Security Policy Violation
-    at <unknown>`;
-    }
-  }
+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 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 storeId = 'lvce-keyvalue';
+
+// TODO high memory usage in idb because of transactionDoneMap
+
+const state$5 = {
+  databases: Object.create(null),
+  dbVersion: 2,
+  cachedDb: undefined
+};
+const getDb$1 = async () => {
+  const db = await openDB(storeId, state$5.dbVersion, {
+    async upgrade(db, oldVersion) {
+      if (!db.objectStoreNames.contains(storeId)) {
+        await db.createObjectStore(storeId, {
+          autoIncrement: true
+        });
+      }
+    }
+  });
+  return db;
+};
+const getDbMemoized$1 = async () => {
+  state$5.cachedDb ||= await getDb$1();
+  return state$5.cachedDb;
+};
+
+// TODO high memory usage in idb because of transactionDoneMap
+
+const set$4 = async (key, value) => {
+  try {
+    const db = await getDbMemoized$1();
+    await db.put(storeId, value, key);
+  } catch (error) {
+    throw new VError(error, 'Failed to save value to indexed db');
+  }
+};
+const get$5 = async key => {
+  try {
+    const db = await getDbMemoized$1();
+    const value = await db.get(storeId, key);
+    return value;
+  } catch (error) {
+    throw new VError(error, 'Failed to get value from indexed db');
+  }
+};
+
+const getCacheKey$1 = colorThemeId => {
+  return 'color-theme-' + colorThemeId;
+};
+const get$4 = colorThemeId => {
+  const cacheKey = getCacheKey$1(colorThemeId);
+  return get$5(cacheKey);
+};
+const set$3 = (colorThemeId, data) => {
+  const cacheKey = getCacheKey$1(colorThemeId);
+  return set$4(cacheKey, data);
+};
+
+const GetColorThemeCssCachedIndexedDb = {
+  __proto__: null,
+  get: get$4,
+  set: set$3
+};
+
+const getText$1 = key => {
+  return invoke$2('LocalStorage.getText', key);
+};
+const setText = (key, value) => {
+  return invoke$2('LocalStorage.setText', key, value);
+};
+
+const getCacheKey = colorThemeId => {
+  return 'lvce-color-theme-' + colorThemeId;
+};
+const get$3 = colorThemeId => {
+  const cacheKey = getCacheKey(colorThemeId);
+  return getText$1(cacheKey);
+};
+const set$2 = (colorThemeId, data) => {
+  const cacheKey = getCacheKey(colorThemeId);
+  return setText(cacheKey, data);
+};
+
+const GetColorThemeCssCachedLocalStorage = {
+  __proto__: null,
+  get: get$3,
+  set: set$2
+};
+
+const get$2 = colorThemeId => {
+  return '';
+};
+const set$1 = (colorThemeId, data) => {
+  //  noop
+};
+
+const GetColorThemeCssCachedNoop = {
+  __proto__: null,
+  get: get$2,
+  set: set$1
+};
+
+const get$1 = key => {
+  return invoke$2('Preferences.get', key);
+};
+
+const getCacheFn = config => {
+  switch (config) {
+    case 'localStorage':
+      return GetColorThemeCssCachedLocalStorage;
+    case 'indexedDb':
+      return GetColorThemeCssCachedIndexedDb;
+    default:
+      return GetColorThemeCssCachedNoop;
+  }
+};
+const getColorThemeCssCached = async (colorThemeId, getData) => {
+  const config = await get$1('colorTheme.cache');
+  const module = await getCacheFn(config);
+  const cachedData = await module.get(colorThemeId);
+  if (cachedData) {
+    return cachedData;
+  }
+  const newData = await getData(colorThemeId);
+  await module.set(colorThemeId, newData);
+  return newData;
+};
+
+const getColorThemeJson$2 = colorThemeId => {
+  return invoke$2(/* ExtensionHost.getColorThemeJson */'ExtensionHost.getColorThemeJson', /* colorThemeId */colorThemeId);
+};
+
+const getAssetDir = () => {
+  // @ts-ignore
+  if (typeof ASSET_DIR !== 'undefined') {
+    // @ts-ignore
+    return ASSET_DIR;
+  }
+  if (platform === Electron) {
+    return '../../../../..';
+  }
+  return '';
+};
+const assetDir = getAssetDir();
+
+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 getColorThemeUrlWeb = colorThemeId => {
+  return `${assetDir}/extensions/builtin.theme-${colorThemeId}/color-theme.json`;
+};
+const getColorThemeJson$1 = colorThemeId => {
+  const url = getColorThemeUrlWeb(colorThemeId);
+  // TODO handle error ?
+  return getJson(url);
+};
+
+const getColorThemeJson = colorThemeId => {
+  if (platform === Web) {
+    return getColorThemeJson$1(colorThemeId);
+  }
+  return getColorThemeJson$2(colorThemeId);
+};
+
+const getColorThemeCssFromJson = async (colorThemeId, colorThemeJson) => {
+  const colorThemeCss = createColorThemeFromJson(/* colorThemeId */colorThemeId, /* colorThemeJson */colorThemeJson);
+  return colorThemeCss;
+  // TODO generate color theme from jsonc
+};
+const getColorThemeCssNew = async colorThemeId => {
+  const colorThemeJson = await getColorThemeJson(colorThemeId);
+  const colorThemeCss = await getColorThemeCssFromJson(colorThemeId, colorThemeJson);
+  return colorThemeCss;
+};
+const getColorThemeCss = colorThemeId => {
+  return getColorThemeCssCached(colorThemeId, getColorThemeCssNew);
+};
+
+const getMetaThemeColor = colorThemeJson => {
+  return colorThemeJson && colorThemeJson.colors && colorThemeJson.colors.TitleBarBackground;
+};
+
+const setThemeColor = async themeColor => {
+  await invoke$2(/* Meta.setThemeColor */'Meta.setThemeColor', /* color */themeColor);
+};
+
+// TODO by default color theme should come from local storage, session storage, cache storage, indexeddb or blob url -> fast initial load
+// actual color theme can be computed after workbench has loaded (most times will be the same and doesn't need to be computed)
+
+const state$4 = {
+  watchedTheme: ''
+};
+const FALLBACK_COLOR_THEME_ID = 'slime';
+
+// TODO json parsing should also happen in renderer worker
+// so that all validation is here (json parsing errors, invalid shape, ...)
+
+const applyColorTheme = async colorThemeId => {
+  try {
+    string(colorThemeId);
+    state$4.colorTheme = colorThemeId;
+    const colorThemeCss = await getColorThemeCss(colorThemeId);
+    await addCssStyleSheet('ContributedColorTheme', colorThemeCss);
+    if (platform === Web) {
+      const themeColor = getMetaThemeColor(colorThemeId) || '';
+      await setThemeColor(themeColor);
+    }
+    if (platform !== Web && (await get$1('development.watchColorTheme'))) {
+      watch(colorThemeId);
+    }
+  } catch (error) {
+    throw new VError(error, `Failed to apply color theme "${colorThemeId}"`);
+  }
+};
+const watch = async id => {
+  if (state$4.watchedTheme === id) {
+    return;
+  }
+  state$4.watchedTheme = id;
+  await invoke$2('ExtensionHost.watchColorTheme', id);
+};
+const getPreferredColorTheme = () => {
+  const preferredColorTheme = get$1('workbench.colorTheme');
+  return preferredColorTheme;
+};
+
+// TODO test this, and also the error case
+// TODO have icon theme, color theme together (maybe)
+const hydrate$1 = async () => {
+  const preferredColorTheme = await getPreferredColorTheme();
+  const colorThemeId = preferredColorTheme || FALLBACK_COLOR_THEME_ID;
+  try {
+    await applyColorTheme(colorThemeId);
+  } catch (error) {
+    if (colorThemeId === FALLBACK_COLOR_THEME_ID) {
+      throw error;
+    }
+    console.error(error);
+    await applyColorTheme(FALLBACK_COLOR_THEME_ID);
+  }
+};
+
+const iframeWorkerUrl = `${assetDir}/packages/renderer-worker/node_modules/@lvce-editor/iframe-worker/dist/iframeWorkerMain.js`;
+
+const getConfiguredIframeWorkerUrl = async () => {
+  let configuredWorkerUrl = (await get$1('develop.iframeWorkerPath')) || '';
+  if (configuredWorkerUrl) {
+    configuredWorkerUrl = '/remote' + configuredWorkerUrl;
+  }
+  configuredWorkerUrl = configuredWorkerUrl || iframeWorkerUrl;
+  return configuredWorkerUrl;
+};
+
+const state$3 = {
+  id: 0
+};
+const create$1 = () => {
+  return ++state$3.id;
+};
+
+const commandMap$1 = {
+  'WebView.compatExtensionHostWorkerInvoke': (...args) => invoke$2('WebView.compatExtensionHostWorkerInvoke', ...args),
+  'WebView.compatExtensionHostWorkerInvokeAndTransfer': (...args) => invokeAndTransfer$1('WebView.compatExtensionHostWorkerInvokeAndTransfer', ...args),
+  'WebView.compatRendererProcessInvoke': (...args) => invoke$2('WebView.compatRendererProcessInvoke', ...args),
+  'WebView.compatRendererProcessInvokeAndTransfer': (...args) => invokeAndTransfer$1('WebView.compatRendererProcessInvokeAndTransfer', ...args),
+  // @ts-ignore
+  'WebView.compatRendererWorkerInvokeAndTransfer': (...args) => invokeAndTransfer$1(...args),
+  // @ts-ignore
+  'WebView.compatRendererWorkerInvoke': (...args) => invoke$2(...args),
+  'WebView.compatSharedProcessInvoke': (...args) => invoke$2('WebView.compatSharedProcessInvoke', ...args),
+  'WebView.getSavedState': (...args) => invoke$2('WebView.getSavedState', ...args),
+  'WebView.getWebViewInfo': (...args) => invoke$2('WebView.getWebViewInfo', ...args),
+  'WebView.getWebViews': (...args) => invoke$2('WebView.getWebViews', ...args),
+  'WebView.setPort': (...args) => invoke$2('WebView.setPort', ...args),
+  'ExtensionHostManagement.activateByEvent': (...args) => invoke$2('ExtensionHostManagement.activateByEvent', ...args),
+  'WebView.getRemoteUrl': options => getRemoteUrlForWebView(options.uri, options)
+};
+const launchIframeWorker = async () => {
+  const configuredWorkerUrl = await getConfiguredIframeWorkerUrl();
+  const name = 'Iframe Worker';
+  const id = create$1();
+  const rpc = await create$2({
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug$1,
+    name,
+    url: configuredWorkerUrl,
+    id,
+    commandMap: commandMap$1
+  });
+  return rpc;
+};
+
+let workerPromise;
+const ensureWorker = () => {
+  if (!workerPromise) {
+    workerPromise = launchIframeWorker();
+  }
+  return workerPromise;
+};
+const invoke = async (method, ...params) => {
+  const rpc = await ensureWorker();
+  return rpc.invoke(method, ...params);
+};
+
+const createWebView3 = async ({
+  id,
+  uri,
+  isGitpod,
+  platform,
+  assetDir,
+  webViewScheme,
+  useNewWebViewHandler
+}) => {
+  await invoke('WebView.create3', {
+    id,
+    uri,
+    isGitpod,
+    platform,
+    assetDir,
+    webViewScheme,
+    useNewWebViewHandler
+  });
+};
+
+const createWebViewWorkerRpc = async (rpcInfo, port) => {
+  // TODO this function is called from the iframe worker to create a direct
+  // connection between a webview/iframe and it's webworker. For this to work
+  // the iframe worker creates a messagechannel and sends one messageport to the webview
+  // and the other messageport to the webworker. This enables direct communication via
+  // the two message ports
+
+  // TODO have a way so that the worker already includes the webview api and the extension
+  // host subworker doesn't need to import the other file
+  await invokeAndTransfer$1('IpcParent.create', {
+    method: ModuleWorkerAndWorkaroundForChromeDevtoolsBug,
+    url: extensionHostSubWorkerUrl,
+    name: rpcInfo.name,
+    raw: true,
+    port
+  });
+};
+
+const BraceCompletionExecuteBraceCompletionProvider = 'ExtensionHostBraceCompletion.executeBraceCompletionProvider';
+const ClosingTagExecuteClosingTagProvider = 'ExtensionHostClosingTag.executeClosingTagProvider';
+const CommandExecute = 'ExtensionHostCommand.executeCommand';
+const CompletionExecute = 'ExtensionHostCompletion.execute';
+const CompletionResolveExecute = 'ExtensionHostCompletion.executeResolve';
+const DefinitionExecuteDefinitionProvider = 'ExtensionHostDefinition.executeDefinitionProvider';
+const DiagnosticExecuteDiagnosticProvider = 'ExtensionHost.executeDiagnosticProvider';
+const ExtensionActivate = 'ExtensionHostExtension.activate';
+const FileSystemGetPathSeparator = 'ExtensionHostFileSystem.getPathSeparator';
+const FileSystemReadDirWithFileTypes = 'ExtensionHostFileSystem.readDirWithFileTypes';
+const FileSystemReadFile = 'ExtensionHostFileSystem.readFile';
+const FileSystemWriteFile = 'ExtensionHostFileSystem.writeFile';
+const FormattingExecuteFormmattingProvider = 'ExtensionHostFormatting.executeFormattingProvider';
+const HoverExecute = 'ExtensionHostHover.execute';
+const ImplementationExecuteImplementationProvider = 'ExtensionHostImplementation.executeImplementationProvider';
+const MockExec = 'ExtensionHostMockExec.mockExec';
+const MockRpc = 'ExtensionHostMockRpc.mockRpc';
+const OrganizeImportsExecute = 'ExtensionHostOrganizeImports.execute';
+const ReferenceExecuteFileReferenceProvider = 'ExtensionHostReference.executeFileReferenceProvider';
+const ReferenceExecuteReferenceProvider = 'ExtensionHostReference.executeReferenceProvider';
+const SourceControlAcceptInput = 'ExtensionHostSourceControl.acceptInput';
+const SourceControlAdd = 'ExtensionHostSourceControl.add';
+const SourceControlDiscard = 'ExtensionHostSourceControl.discard';
+const SourceControlGetChangedFiles = 'ExtensionHost.sourceControlGetChangedFiles';
+const SourceControlGetEnabledProviderIds = 'ExtensionHostSourceControl.getEnabledProviderIds';
+const SourceControlGetFileBefore = 'ExtensionHostSourceControl.GetFileBefore';
+const SourceControlGetGroups = 'ExtensionHostSourceControl.getGroups';
+const StatusBarGetStatusBarItems = 'ExtensionHost.getStatusBarItems';
+const StatusBarRegisterChangeListener = 'ExtensionHostStatusBar.registerChangeListener';
+const TabCompletionExecuteTabCompletionProvider = 'ExtensionHost.executeTabCompletionProvider';
+const TextDocumentSetLanguageId = 'ExtensionHostTextDocument.setLanguageId';
+const TextDocumentSyncFull = 'ExtensionHostTextDocument.syncFull';
+const TextDocumentSyncIncremental = 'ExtensionHostTextDocument.syncIncremental';
+const TextSearchExecuteTextSearchProvider = 'ExtensionHostTextSearch.executeTextSearchProvider';
+const TypeDefinitionExecuteTypeDefinitionProvider = 'ExtensionHostTypeDefinition.executeTypeDefinitionProvider';
+const WorkspaceSetPath = 'Workspace.setWorkspacePath';
+const SelectionExecuteSelectionProvider = 'ExtensionHostSelection.executeSelectionProvider';
+const ConfigurationSetConfiguration = 'ExtensionHostConfiguration.setConfiguration';
+
+const create = () => {
+  return {
+    finished: false
+  };
+};
+const cancel = token => {
+  token.finished = true;
+};
+const isCanceled = token => {
+  return token.finished;
+};
+
+const baseName = path => {
+  const slashIndex = path.lastIndexOf('/');
+  return path.slice(slashIndex + 1);
+};
+const getExtensionId = extension => {
+  if (extension && extension.id) {
+    return extension.id;
+  }
+  if (extension && extension.path) {
+    return baseName(extension.path);
+  }
+  return '<unknown>';
+};
+
+const getUrlPrefix = (platform, extensionPath) => {
+  if (extensionPath.startsWith('http://') || extensionPath.startsWith('https://')) {
+    return extensionPath;
+  }
+  if (platform === Web) {
+    return extensionPath;
+  }
+  if (extensionPath.startsWith('/')) {
+    return `/remote${extensionPath}`;
+  }
+  return `/remote/${extensionPath}`;
+};
+
+const handleRpcInfos = extension => {
+  try {
+    if (!extension) {
+      return;
+    }
+    const rpcs = extension.rpc;
+    const urlPrefix = getUrlPrefix(platform, extension.path);
+    if (!rpcs) {
+      return;
+    }
+    if (!Array.isArray(rpcs)) {
+      return;
+    }
+    for (const rpc of rpcs) {
+      rpc.url = `${urlPrefix}/${rpc.url}`;
+      add$1(rpc.id, rpc);
+    }
+  } catch (error) {
+    console.warn(`Failed to handle extension rpcs: ${error}`);
+  }
+};
+
+class ContentSecurityPolicyError extends Error {
+  constructor(violatedDirective, sourceFile, lineNumber, columnNumber) {
+    super(`Content Security Policy Violation: ${violatedDirective}`);
+    this.name = 'ContentSecurityPolicyError';
+    if (sourceFile) {
+      this.stack = `Content Security Policy Violation
+    at ${sourceFile}:${lineNumber}:${columnNumber}`;
+    } else {
+      this.stack = `Content Security Policy Violation
+    at <unknown>`;
+    }
+  }
+}
+
 const isImportErrorChrome = error => {
   return error && error instanceof Error && error.message.startsWith('Failed to fetch dynamically imported module');
 };
@@ -3724,7 +4321,7 @@ const mockRpc = () => {
 };
 
 const getStatusBarItems = async () => {
-  const providers = Object.values(state$7.providers);
+  const providers = Object.values(state$9.providers);
   const statusBarItems = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -3757,19 +4354,6 @@ const getBlob$2 = async 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);
@@ -4022,7 +4606,7 @@ const getFiles = () => {
 };
 
 const getRpcInfo = rpcId => {
-  const info = get$3(rpcId);
+  const info = get$7(rpcId);
   if (!info) {
     throw new Error(`Rpc not found ${rpcId}`);
   }
@@ -4042,261 +4626,164 @@ const handleMessagePort = async port => {
   });
 };
 
-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 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]);
+const state$1 = {
+  webExtensions: []
+};
+
+const readJson = url => {
+  return invoke$2('FileSystem.readJson', url);
+};
+
+const findMatchingIconThemeExtension = (extensions, iconThemeId) => {
+  for (const extension of extensions) {
+    if (extension && extension.iconThemes) {
+      for (const iconTheme of extension.iconThemes) {
+        if (iconTheme.id === iconThemeId) {
+          return {
+            ...iconTheme,
+            extensionPath: extension.path
+          };
+        }
       }
     }
-    // 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 undefined;
+};
+
+const webExtensionsUrl = `${assetDir}/config/webExtensions.json`;
+
+const getSharedProcessExtensions$1 = () => {
+  return invoke$2(/* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
+};
+const getStaticWebExtensions = () => {
+  return getJson(webExtensionsUrl);
+};
+const getWebExtensionsWeb = async () => {
+  const staticWebExtensions = await getStaticWebExtensions();
+  return [...staticWebExtensions, ...state$1.webExtensions];
+};
+const isWebExtension = extension => {
+  return extension && typeof extension.browser === 'string';
+};
+const getWebExtensionsDefault = async () => {
+  const staticWebExtensions = await getStaticWebExtensions();
+  const sharedProcessExtensions = await getSharedProcessExtensions$1();
+  const sharedProcessWebExtensions = sharedProcessExtensions.filter(isWebExtension);
+  return [...staticWebExtensions, sharedProcessWebExtensions, ...state$1.webExtensions];
+};
+const getWebExtensions = async () => {
+  try {
+    switch (platform) {
+      case Web:
+        return await getWebExtensionsWeb();
+      default:
+        return await getWebExtensionsDefault();
     }
-    return prop in target;
+  } catch {
+    return state$1.webExtensions;
   }
 };
-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);
-    };
+
+const getSharedProcessExtensions = () => {
+  return invoke$2(/* ExtensionManagement.getExtensions */'ExtensionManagement.getExtensions');
+};
+const getExtensions$1 = async () => {
+  if (platform === Web) {
+    const webExtensions = await getWebExtensions();
+    return webExtensions;
   }
-  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);
+  if (platform === Remote) {
+    const webExtensions = await getWebExtensions();
+    const sharedProcessExtensions = await getSharedProcessExtensions();
+    return [...sharedProcessExtensions, ...webExtensions];
   }
-  return newValue;
-}
-const unwrap = value => reverseTransformCache.get(value);
+  const extensions = await getSharedProcessExtensions();
+  return extensions;
+};
 
-/**
- * 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);
-    });
+const cache = Object.create(null);
+const id = 1;
+const get = () => {
+  return cache[id];
+};
+const has = () => {
+  return id in cache;
+};
+const set = value => {
+  cache[id] = value;
+};
+
+const getExtensions = () => {
+  if (!has()) {
+    set(getExtensions$1());
   }
-  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));
+  return get();
+};
+
+const getIconThemeUrl = iconThemeId => {
+  return `${assetDir}/extensions/builtin.${iconThemeId}/icon-theme.json`;
+};
+
+const getIconThemeJson = async iconThemeId => {
+  if (platform === Web) {
+    const url = getIconThemeUrl(iconThemeId);
+    const json = await getJson(url);
+    return {
+      json,
+      extensionPath: `${assetDir}/extensions/builtin.${iconThemeId}`
+    };
   }
-  openPromise.then(db => {
-    if (terminated) db.addEventListener('close', () => terminated());
-    if (blocking) {
-      db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event));
+  for (const webExtension of state$1.webExtensions) {
+    if (webExtension.iconThemes) {
+      for (const iconTheme of webExtension.iconThemes) {
+        // TODO handle error when icon theme path is not of type string
+        const iconThemeUrl = `${webExtension.path}/${iconTheme.path}`;
+        const json = await getJson(iconThemeUrl);
+        return {
+          json,
+          extensionPath: webExtension.path
+        };
+      }
     }
-  }).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 extensions = await getExtensions();
+  const iconTheme = findMatchingIconThemeExtension(extensions, iconThemeId);
+  if (!iconTheme) {
+    return undefined;
   }
-  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];
+  const iconThemePath = `${iconTheme.extensionPath}/${iconTheme.path}`;
+  const iconThemeJson = await readJson(iconThemePath);
+  return {
+    extensionPath: iconTheme.extensionPath,
+    json: iconThemeJson
   };
-  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));
-      };
+};
+
+const handleIconThemeChange = async () => {
+  await invoke$2('IconTheme.handleIconThemeChange');
+};
+
+const setTheme = iconTheme => {
+};
+
+const setIconTheme = async iconThemeId => {
+  try {
+    const iconTheme = await getIconThemeJson(iconThemeId);
+    if (!iconTheme) {
+      return;
     }
-    return cachedFunc;
+    setTheme(iconTheme);
+    await handleIconThemeChange();
+  } catch (error) {
+    console.error(new VError(error, 'Failed to load icon theme'));
   }
 };
-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 hydrate = async () => {
+  const iconThemeId = (await get$1('icon-theme')) || 'vscode-icons';
+  await setIconTheme(iconThemeId);
+};
 
-const state$1 = {
+const state = {
   databases: Object.create(null),
   eventId: 0,
   dbVersion: 1,
@@ -4312,9 +4799,9 @@ const isDataCloneError = error => {
 
 // TODO high memory usage in idb because of transactionDoneMap
 
-const getDb$1 = async () => {
+const getDb = async () => {
   // @ts-ignore
-  const db = await openDB('session', state$1.dbVersion, {
+  const db = await openDB('session', state.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('session')) {
         const objectStore = await db.createObjectStore('session', {
@@ -4328,13 +4815,13 @@ const getDb$1 = async () => {
   });
   return db;
 };
-const getDbMemoized$1 = async () => {
-  state$1.cachedDb ||= await getDb$1();
-  return state$1.cachedDb;
+const getDbMemoized = async () => {
+  state.cachedDb ||= await getDb();
+  return state.cachedDb;
 };
 const saveValue = async (storeId, value) => {
   try {
-    const db = await getDbMemoized$1();
+    const db = await getDbMemoized();
     await db.add('session', value);
   } catch (error) {
     if (isDataCloneError(error)) {
@@ -4346,7 +4833,7 @@ const saveValue = async (storeId, value) => {
 };
 const getValues = async storeId => {
   try {
-    const db = await getDbMemoized$1();
+    const db = await getDbMemoized();
     const tx = db.transaction(storeId, 'readwrite');
     const [objects] = await Promise.all([tx.store.getAll(), tx.done]);
     console.log({
@@ -4358,7 +4845,7 @@ const getValues = async storeId => {
   }
 };
 const getValuesByIndexName = async (storeId, indexName, only) => {
-  const db = await getDbMemoized$1();
+  const db = await getDbMemoized();
   const transaction = db.transaction(storeId);
   const index = transaction.store.index(indexName);
   const iterator = index.iterate(only);
@@ -4369,7 +4856,7 @@ const getValuesByIndexName = async (storeId, indexName, only) => {
   return objects;
 };
 const getHandleDb = async () => {
-  const db = await openDB('handle', state$1.dbVersion, {
+  const db = await openDB('handle', state.dbVersion, {
     async upgrade(db, oldVersion) {
       if (!db.objectStoreNames.contains('file-handles-store')) {
         // @ts-ignore
@@ -4389,52 +4876,6 @@ const getHandle$1 = async uri => {
   return handle;
 };
 
-const storeId = 'lvce-keyvalue';
-
-// TODO high memory usage in idb because of transactionDoneMap
-
-const state = {
-  databases: Object.create(null),
-  dbVersion: 2,
-  cachedDb: undefined
-};
-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;
-};
-
-// TODO high memory usage in idb because of transactionDoneMap
-
-const set = async (key, value) => {
-  try {
-    const db = await getDbMemoized();
-    await db.put(storeId, value, key);
-  } catch (error) {
-    throw new VError(error, 'Failed to save value to indexed db');
-  }
-};
-const get = async key => {
-  try {
-    const db = await getDbMemoized();
-    const value = await db.get(storeId, key);
-    return value;
-  } catch (error) {
-    throw new VError(error, 'Failed to get value from indexed db');
-  }
-};
-
 const loadWebView = async (providerId, savedState) => {
   const rpc = getWebView(providerId);
   await rpc.provider.create(rpc, rpc.uri, savedState);
@@ -4596,34 +5037,72 @@ const searchFile = async uri => {
   return all;
 };
 
+const getTextSearchRegex = (query, matchCase) => {
+  const flags = matchCase ? 'u' : 'iu';
+  const regex = new RegExp(query, flags);
+  return regex;
+};
+
+const getLineMatchRegex = (line, lineNumber, query, matchCase) => {
+  const regex = getTextSearchRegex(query, matchCase);
+  const match = line.match(regex);
+  if (match && typeof match.index === 'number') {
+    return [{
+      type: Match,
+      text: line,
+      start: match.index,
+      end: match.index + match[0].length,
+      lineNumber
+    }];
+  }
+  return [];
+};
+
+const getLineMatchText = (line, lineNumber, query, queryLower, matchCase) => {
+  const lineToQuery = matchCase ? line : line.toLowerCase();
+  const actualQuery = matchCase ? query : queryLower;
+  const index = lineToQuery.indexOf(actualQuery);
+  if (index !== -1) {
+    return [{
+      type: Match,
+      text: line,
+      start: index,
+      end: index + query.length,
+      lineNumber
+    }];
+  }
+  return [];
+};
+
+const getLineMatch = (line, lineNumber, query, queryLower, useRegularExpression, matchCase) => {
+  if (useRegularExpression) {
+    return getLineMatchRegex(line, lineNumber, query, matchCase);
+  }
+  return getLineMatchText(line, lineNumber, query, queryLower, matchCase);
+};
+
+const UseRegularExpression = 1 << 1; // 2
+const MatchCase = 1 << 4; // 16
+ // 128
+
 const splitLines = lines => {
   return lines.split('\n');
 };
 
-const textSearchInText = (file, content, query) => {
-  const results = [];
+const textSearchInText = (file, content, query, flags = 0) => {
+  const matchCase = flags & MatchCase;
+  const useRegularExpression = flags & UseRegularExpression;
   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
-      });
-    }
-  }
+  const queryLower = query.toLowerCase();
+  const results = lines.flatMap((line, i) => getLineMatch(line, i, query, queryLower, useRegularExpression, matchCase));
   if (results.length > 0) {
-    results.unshift({
+    return [{
       type: File$3,
       text: file,
       start: 0,
       end: 0,
       lineNumber: 0
-    });
+    }, ...results];
   }
   return results;
 };
@@ -4741,13 +5220,14 @@ const textSearch = async (scheme, root, query, options, assetDir) => {
   const files = getFiles();
   const relativeRoot = root.slice('memfs://'.length);
   const allResults = [];
+  const flags = options.flags || 0;
   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);
+      const results = textSearchInText(relativeUri, value.content, query, flags);
       allResults.push(...results);
     }
   }
@@ -4756,6 +5236,7 @@ const textSearch = async (scheme, root, query, options, assetDir) => {
 
 const commandMap = {
   'BulkReplacement.applyBulkReplacement': applyBulkReplacement,
+  'ColorTheme.hydrate': hydrate$1,
   'ExtensionHost.launchIframeWorker': launchIframeWorker,
   'ExtensionHostRename.executeprepareRenameProvider': executeprepareRenameProvider,
   'ExtensionHostRename.executeRenameProvider': executeRenameProvider,
@@ -4775,13 +5256,15 @@ const commandMap = {
   'FileSystemMemory.readFile': readFile,
   'FileSystemMemory.remove': remove,
   'FileSystemMemory.writeFile': writeFile,
+  'IconTheme.hydrate': hydrate,
+  'IconTheme.setIconTheme': setIconTheme,
   'IndexedDb.addHandle': addHandle,
-  'IndexedDb.get': get,
+  'IndexedDb.get': get$5,
   'IndexedDb.getHandle': getHandle$1,
   'IndexedDb.getValues': getValues,
   'IndexedDb.getValuesByIndexName': getValuesByIndexName,
   'IndexedDb.saveValue': saveValue,
-  'IndexedDb.set': set,
+  'IndexedDb.set': set$4,
   'SearchFileWithFetch.searchFileWithFetch': searchFile$1,
   'SearchFileWithHtml.searchFileWithHtml': searchFile,
   'TextSearchFetch.textSearch': textSearch$2,