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

package/dist/extensionHostWorkerMain.js

@@ -90,6 +90,8 @@ const fn = value => {
 };
 
 const state$9 = {
+  /** @type{any[]} */
+  onDidOpenEditorListeners: [],
   /** @type{any[]} */
   onWillChangeEditorListeners: [],
   /** @type{any[]} */
@@ -619,7 +621,9 @@ const String = 'string';
 
 const {
   registerBraceCompletionProvider,
-  executeBraceCompletionProvider} = create$9({
+  executeBraceCompletionProvider,
+  reset: reset$9
+} = create$9({
   name: 'BraceCompletion',
   resultShape: {
     type: Boolean
@@ -762,17 +766,15 @@ const create$4$1 = (method, params) => {
     params
   };
 };
-const state$6 = {
-  callbacks: Object.create(null)
-};
+const callbacks = Object.create(null);
 const set$4 = (id, fn) => {
-  state$6.callbacks[id] = fn;
+  callbacks[id] = fn;
 };
 const get$4 = id => {
-  return state$6.callbacks[id];
+  return callbacks[id];
 };
 const remove = id => {
-  delete state$6.callbacks[id];
+  delete callbacks[id];
 };
 let id = 0;
 const create$3$1 = () => {
@@ -1134,17 +1136,17 @@ const handleIpc = ipc => {
   ipc.addEventListener('message', handleMessage);
 };
 
-const state$5 = {
+const state$6 = {
   /**
    * @type {any}
    */
   ipc: undefined
 };
 const get$3 = () => {
-  return state$5.ipc;
+  return state$6.ipc;
 };
 const set$3 = ipc => {
-  state$5.ipc = ipc;
+  state$6.ipc = ipc;
 };
 
 const send = (method, ...params) => {
@@ -1159,16 +1161,16 @@ const invokeAndTransfer = (method, ...params) => {
   const ipc = get$3();
   return invokeAndTransfer$1(ipc, method, ...params);
 };
-const listen$2 = ipc => {
+const listen$4 = ipc => {
   handleIpc(ipc);
   set$3(ipc);
 };
 
-const state$4 = {
+const state$5 = {
   debugProviderMap: Object.create(null)
 };
 const getDebugProvider = id => {
-  const provider = state$4.debugProviderMap[id];
+  const provider = state$5.debugProviderMap[id];
   if (!provider) {
     // @ts-ignore
     throw new VError$1(`no debug provider "${id}" found`);
@@ -1179,7 +1181,7 @@ const registerDebugProvider = debugProvider => {
   if (!debugProvider.id) {
     throw new Error('Failed to register debug system provider: missing id');
   }
-  state$4.debugProviderMap[debugProvider.id] = debugProvider;
+  state$5.debugProviderMap[debugProvider.id] = debugProvider;
 };
 const start = async (protocol, path) => {
   try {
@@ -1288,7 +1290,9 @@ const setPauseOnExceptions = async (protocol, value) => {
 
 const {
   registerDefinitionProvider,
-  executeDefinitionProvider} = create$9({
+  executeDefinitionProvider,
+  reset: reset$8
+} = create$9({
   name: 'Definition',
   resultShape: {
     allowUndefined: true,
@@ -1409,7 +1413,9 @@ const getPathSeparator = protocol => {
 
 const {
   registerFormattingProvider,
-  executeFormattingProvider} = create$9({
+  executeFormattingProvider,
+  reset: reset$7
+} = create$9({
   name: 'Formatting',
   executeKey: 'format',
   resultShape: {
@@ -1469,7 +1475,9 @@ const getPosition = (textDocument, offset) => {
 
 const {
   registerHoverProvider,
-  executeHoverProvider} = create$9({
+  executeHoverProvider,
+  reset: reset$6
+} = create$9({
   name: 'Hover',
   resultShape: {
     allowUndefined: true,
@@ -1480,7 +1488,9 @@ const {
 
 const {
   registerImplementationProvider,
-  executeImplementationProvider} = create$9({
+  executeImplementationProvider,
+  reset: reset$5
+} = create$9({
   name: 'Implementation',
   resultShape: {
     type: Array$1,
@@ -1592,7 +1602,9 @@ const showQuickPick = async ({
 const {
   registerReferenceProvider,
   executeReferenceProvider,
-  executefileReferenceProvider} = create$9({
+  executefileReferenceProvider,
+  reset: reset$4
+} = create$9({
   name: 'Reference',
   resultShape: {
     type: Array$1,
@@ -1617,7 +1629,9 @@ const {
 const {
   registerRenameProvider,
   executeRenameProvider,
-  executeprepareRenameProvider} = create$9({
+  executeprepareRenameProvider,
+  reset: reset$3
+} = create$9({
   name: 'Rename',
   resultShape: {
     type: Object$1,
@@ -1774,7 +1788,9 @@ const createRpc = ({
 
 const {
   registerSelectionProvider,
-  executeSelectionProvider} = create$9({
+  executeSelectionProvider,
+  reset: reset$2
+} = create$9({
   name: 'Selection',
   resultShape: {
     allowUndefined: true,
@@ -1785,17 +1801,17 @@ const {
   }
 });
 
-const state$3 = {
+const state$4 = {
   providers: Object.create(null)
 };
 const registerSourceControlProvider = provider => {
-  state$3.providers[provider.id] = provider;
+  state$4.providers[provider.id] = provider;
 };
 const getFilesFromProvider = provider => {
   return provider.getChangedFiles();
 };
 const getChangedFiles = async providerId => {
-  const provider = state$3.providers[providerId];
+  const provider = state$4.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -1806,7 +1822,7 @@ const getChangedFiles = async providerId => {
 const getFileBefore = async (providerId, uri) => {
   string(providerId);
   string(uri);
-  const provider = state$3.providers[providerId];
+  const provider = state$4.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -1828,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$3.providers[providerId];
+  const provider = state$4.providers[providerId];
   if (!provider) {
     throw new Error('no source control provider found');
   }
@@ -1836,14 +1852,14 @@ const getGroups = async (providerId, cwd) => {
   return groups;
 };
 const acceptInput = async (providerId, value) => {
-  const provider = state$3.providers[providerId];
+  const provider = state$4.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$3.providers)[0];
+  const provider = Object.values(state$4.providers)[0];
   if (!provider) {
     return;
   }
@@ -1851,7 +1867,7 @@ const add = async path => {
   await provider.add(path);
 };
 const discard = async path => {
-  const provider = Object.values(state$3.providers)[0];
+  const provider = Object.values(state$4.providers)[0];
   if (!provider) {
     return;
   }
@@ -1861,7 +1877,7 @@ const discard = async path => {
 const getEnabledProviderIds = async (scheme, root) => {
   string(scheme);
   string(root);
-  const providers = Object.values(state$3.providers);
+  const providers = Object.values(state$4.providers);
   const enabledIds = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -1880,7 +1896,9 @@ const getEnabledProviderIds = async (scheme, root) => {
 
 const {
   registerTabCompletionProvider,
-  executeTabCompletionProvider} = create$9({
+  executeTabCompletionProvider,
+  reset: reset$1
+} = create$9({
   name: 'TabCompletion',
   resultShape: {
     type: Object$1,
@@ -1888,7 +1906,7 @@ const {
   }
 });
 
-const state$2 = {
+const state$3 = {
   textSearchProviders: Object.create(null)
 };
 const registerTextSearchProvider = textSearchProvider => {
@@ -1899,14 +1917,14 @@ const registerTextSearchProvider = textSearchProvider => {
     if (!textSearchProvider.scheme) {
       throw new Error('textSearchProvider is missing scheme');
     }
-    state$2.textSearchProviders[textSearchProvider.scheme] = textSearchProvider;
+    state$3.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$2.textSearchProviders[scheme];
+    const textSearchProvider = state$3.textSearchProviders[scheme];
     if (!textSearchProvider) {
       throw new Error(`No text search provider for ${scheme} found`);
     }
@@ -1919,7 +1937,9 @@ const executeTextSearchProvider = async (scheme, query) => {
 
 const {
   registerTypeDefinitionProvider,
-  executeTypeDefinitionProvider} = create$9({
+  executeTypeDefinitionProvider,
+  reset
+} = create$9({
   name: 'TypeDefinition',
   resultShape: {
     allowUndefined: true,
@@ -2161,14 +2181,14 @@ const createWorker = async ({
   return ipc;
 };
 
-const state$1 = {
+const state$2 = {
   workspacePath: ''
 };
 const setWorkspacePath = path => {
-  state$1.workspacePath = path;
+  state$2.workspacePath = path;
 };
 const getWorkspaceFolder = path => {
-  return state$1.workspacePath;
+  return state$2.workspacePath;
 };
 
 class FormattingError extends Error {
@@ -2398,7 +2418,7 @@ class ContentSecurityPolicyError extends Error {
   }
 }
 
-const state = {
+const state$1 = {
   /**
    * @type {any[]}
    */
@@ -2406,13 +2426,13 @@ const state = {
 };
 const addError = error => {
   // @ts-ignore
-  state.errors.push(error);
+  state$1.errors.push(error);
 };
 const hasRecentErrors = () => {
-  return state.errors.length > 0;
+  return state$1.errors.length > 0;
 };
 const getRecentError = () => {
-  return state.errors.at(-1);
+  return state$1.errors.at(-1);
 };
 
 const isImportErrorChrome = error => {
@@ -2838,7 +2858,7 @@ const mockRpc = () => {
 };
 
 const getStatusBarItems = async () => {
-  const providers = Object.values(state$3.providers);
+  const providers = Object.values(state$4.providers);
   const statusBarItems = [];
   for (const provider of providers) {
     // @ts-ignore
@@ -2872,6 +2892,27 @@ const Auto = () => {
 const getData$1 = event => {
   return event.data;
 };
+const attachEvents = that => {
+  const handleMessage = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent('message', {
+      data
+    }));
+  };
+  that.onMessage(handleMessage);
+  const handleClose = event => {
+    that.dispatchEvent(new Event('close'));
+  };
+  that.onClose(handleClose);
+};
+class Ipc extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+}
+const readyMessage = 'ready';
 const walkValue = (value, transferrables, isTransferrable) => {
   if (!value) {
     return;
@@ -2922,35 +2963,56 @@ const getTransferrables = value => {
   walkValue(value, transferrables, isTransferrable);
   return transferrables;
 };
-const attachEvents = that => {
-  const handleMessage = (...args) => {
-    const data = that.getData(...args);
-    that.dispatchEvent(new MessageEvent('message', {
-      data
-    }));
-  };
-  that.onMessage(handleMessage);
-  const handleClose = event => {
-    that.dispatchEvent(new Event('close'));
-  };
-  that.onClose(handleClose);
+const listen$3 = ({
+  port
+}) => {
+  return port;
 };
-class Ipc extends EventTarget {
-  constructor(rawIpc) {
-    super();
-    this._rawIpc = rawIpc;
-    attachEvents(this);
+const signal$3 = port => {
+  port.postMessage(readyMessage);
+};
+class IpcChildWithMessagePort extends Ipc {
+  constructor(port) {
+    super(port);
+  }
+  getData(event) {
+    return getData$1(event);
+  }
+  send(message) {
+    this._rawIpc.postMessage(message);
+  }
+  sendAndTransfer(message) {
+    const transfer = getTransferrables(message);
+    this._rawIpc.postMessage(message, transfer);
+  }
+  dispose() {
+    // ignore
+  }
+  onClose(callback) {
+    // ignore
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener('message', callback);
+    this._rawIpc.start();
   }
 }
-const readyMessage = 'ready';
-const listen$4 = () => {
+const wrap$6 = port => {
+  return new IpcChildWithMessagePort(port);
+};
+const IpcChildWithMessagePort$1 = {
+  __proto__: null,
+  listen: listen$3,
+  signal: signal$3,
+  wrap: wrap$6
+};
+const listen$2 = () => {
   // @ts-ignore
   if (typeof WorkerGlobalScope === 'undefined') {
     throw new TypeError('module is not in web worker scope');
   }
   return globalThis;
 };
-const signal$3 = global => {
+const signal$2 = global => {
   global.postMessage(readyMessage);
 };
 class IpcChildWithModuleWorker extends Ipc {
@@ -2976,14 +3038,14 @@ class IpcChildWithModuleWorker extends Ipc {
     this._rawIpc.addEventListener('message', callback);
   }
 }
-const wrap$6 = global => {
+const wrap$5 = global => {
   return new IpcChildWithModuleWorker(global);
 };
 const IpcChildWithModuleWorker$1 = {
   __proto__: null,
-  listen: listen$4,
-  signal: signal$3,
-  wrap: wrap$6
+  listen: listen$2,
+  signal: signal$2,
+  wrap: wrap$5
 };
 const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
 const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
@@ -3100,10 +3162,10 @@ const getHelpfulChildProcessError = (stdout, stderr) => {
 };
 const normalizeLine = line => {
   if (line.startsWith('Error: ')) {
-    return line.slice(`Error: `.length);
+    return line.slice('Error: '.length);
   }
   if (line.startsWith('VError: ')) {
-    return line.slice(`VError: `.length);
+    return line.slice('VError: '.length);
   }
   return line;
 };
@@ -3201,10 +3263,10 @@ const waitForFirstMessage = async port => {
   // @ts-ignore
   return event.data;
 };
-const listen$3 = async () => {
-  const parentIpcRaw = listen$4();
-  signal$3(parentIpcRaw);
-  const parentIpc = wrap$6(parentIpcRaw);
+const listen$1 = async () => {
+  const parentIpcRaw = listen$2();
+  signal$2(parentIpcRaw);
+  const parentIpc = wrap$5(parentIpcRaw);
   const firstMessage = await waitForFirstMessage(parentIpc);
   if (firstMessage.method !== 'initialize') {
     throw new IpcError$1('unexpected first message');
@@ -3249,55 +3311,13 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.start();
   }
 }
-const wrap$5 = port => {
+const wrap$4$1 = port => {
   return new IpcChildWithModuleWorkerAndMessagePort(port);
 };
 const IpcChildWithModuleWorkerAndMessagePort$1 = {
-  __proto__: null,
-  listen: listen$3,
-  wrap: wrap$5
-};
-const listen$1 = ({
-  port
-}) => {
-  return port;
-};
-const signal = port => {
-  port.postMessage(readyMessage);
-};
-class IpcChildWithMessagePort extends Ipc {
-  constructor(port) {
-    super(port);
-  }
-  getData(event) {
-    return getData$1(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$2$1 = port => {
-  return new IpcChildWithMessagePort(port);
-};
-const IpcChildWithMessagePort$1 = {
   __proto__: null,
   listen: listen$1,
-  signal,
-  wrap: wrap$2$1
+  wrap: wrap$4$1
 };
 
 const getModule$1 = method => {
@@ -3349,9 +3369,361 @@ const saveState = async () => {
   return serialized;
 };
 
+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$4(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener('success', success);
+    request.addEventListener('error', error);
+  });
+  // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This
+  // is because we create many promises from a single IDBRequest.
+  reverseTransformCache.set(promise, request);
+  return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+  // Early bail if we've already created a done promise for this transaction.
+  if (transactionDoneMap.has(tx)) return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener('complete', complete);
+      tx.removeEventListener('error', error);
+      tx.removeEventListener('abort', error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException('AbortError', 'AbortError'));
+      unlisten();
+    };
+    tx.addEventListener('complete', complete);
+    tx.addEventListener('error', error);
+    tx.addEventListener('abort', error);
+  });
+  // Cache it for later retrieval.
+  transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      // Special handling for transaction.done.
+      if (prop === 'done') return transactionDoneMap.get(target);
+      // Make tx.store return the only store in the transaction, or undefined if there are many.
+      if (prop === 'store') {
+        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    // Else transform whatever we get back.
+    return wrap$4(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$4(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$4(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$4(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$4(request);
+  if (upgrade) {
+    request.addEventListener('upgradeneeded', event => {
+      upgrade(wrap$4(request.result), event.oldVersion, event.newVersion, wrap$4(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener('blocked', event => blocked(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    event.oldVersion, event.newVersion, event));
+  }
+  openPromise.then(db => {
+    if (terminated) db.addEventListener('close', () => terminated());
+    if (blocking) {
+      db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {});
+  return openPromise;
+}
+const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
+const writeMethods = ['put', 'add', 'delete', 'clear'];
+const cachedMethods = new Map();
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === 'string')) {
+    return;
+  }
+  if (cachedMethods.get(prop)) return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, '');
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (
+  // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+  !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
+    return;
+  }
+  const method = async function (storeName, ...args) {
+    // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
+    const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+    let target = tx.store;
+    if (useIndex) target = target.index(args.shift());
+    // Must reject if op rejects.
+    // If it's a write operation, must reject if tx.done rejects.
+    // Must reject with op rejection first.
+    // Must resolve with op value.
+    // Must handle both promises (no unhandled rejections)
+    return (await Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
+const methodMap = {};
+const advanceResults = new WeakMap();
+const ittrProxiedCursorToOriginalProxy = new WeakMap();
+const cursorIteratorTraps = {
+  get(target, prop) {
+    if (!advanceMethodProps.includes(prop)) return target[prop];
+    let cachedFunc = methodMap[prop];
+    if (!cachedFunc) {
+      cachedFunc = methodMap[prop] = function (...args) {
+        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+      };
+    }
+    return cachedFunc;
+  }
+};
+async function* iterate(...args) {
+  // tslint:disable-next-line:no-this-assignment
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
+  }
+  if (!cursor) return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  // Map this double-proxy back to the original, so other cursor methods work.
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    // If one of the advancing methods was not called, call continue().
+    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+    advanceResults.delete(proxiedCursor);
+  }
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop)) return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+  }
+}));
+
+const state = {
+  databases: Object.create(null),
+  eventId: 0,
+  dbVersion: 1,
+  /**
+   * @type {any}
+   */
+  cachedDb: undefined
+};
+
+const isDataCloneError = error => {
+  return error && error.name === 'DataCloneError';
+};
+
+// TODO high memory usage in idb because of transactionDoneMap
+
+const getDb = async () => {
+  // @ts-ignore
+  const db = await openDB('session', state.dbVersion, {
+    async upgrade(db, oldVersion) {
+      if (!db.objectStoreNames.contains('session')) {
+        const objectStore = await db.createObjectStore('session', {
+          autoIncrement: true
+        });
+        objectStore.createIndex('sessionId', 'sessionId', {
+          unique: false
+        });
+      }
+    }
+  });
+  return db;
+};
+const getDbMemoized = async () => {
+  state.cachedDb ||= await getDb();
+  return state.cachedDb;
+};
+const saveValue = async (storeId, value) => {
+  try {
+    const db = await getDbMemoized();
+    await db.add('session', value);
+  } catch (error) {
+    if (isDataCloneError(error)) {
+      // TODO
+      return;
+    }
+    throw new VError$1(error, 'Failed to save value to indexed db');
+  }
+};
+const getValues = async storeId => {
+  try {
+    const db = await getDbMemoized();
+    const tx = db.transaction(storeId, 'readwrite');
+    const [objects] = await Promise.all([tx.store.getAll(), tx.done]);
+    console.log({
+      objects
+    });
+    return objects;
+  } catch (error) {
+    throw new VError$1(error, 'Failed to get values from indexed db');
+  }
+};
+const getValuesByIndexName = async (storeId, indexName, only) => {
+  const db = await getDbMemoized();
+  const transaction = db.transaction(storeId);
+  const index = transaction.store.index(indexName);
+  const iterator = index.iterate(only);
+  const objects = [];
+  for await (const cursor of iterator) {
+    objects.push(cursor.value);
+  }
+  return objects;
+};
+const getHandleDb = async () => {
+  const db = await openDB('handle', state.dbVersion, {
+    async upgrade(db, oldVersion) {
+      if (!db.objectStoreNames.contains('file-handles-store')) {
+        // @ts-ignore
+        await db.createObjectStore('file-handles-store', {});
+      }
+    }
+  });
+  return db;
+};
+const addHandle = async (uri, handle) => {
+  const handleDb = await getHandleDb();
+  await handleDb.put('file-handles-store', handle, uri);
+};
+const getHandle = async uri => {
+  const handleDb = await getHandleDb();
+  const handle = await handleDb.get('file-handles-store', uri);
+  return handle;
+};
+
 const commandMap = {
-  'ExtensionHostRename.executeRenameProvider': executeRenameProvider,
   'ExtensionHostRename.executeprepareRenameProvider': executeprepareRenameProvider,
+  'ExtensionHostRename.executeRenameProvider': executeRenameProvider,
+  'IndexedDb.addHandle': addHandle,
+  'IndexedDb.getHandle': getHandle,
+  'IndexedDb.getValues': getValues,
+  'IndexedDb.getValuesByIndexName': getValuesByIndexName,
+  'IndexedDb.saveValue': saveValue,
   ['ExtensionHostDebug.evaluate']: evaluate,
   ['ExtensionHostDebug.getProperties']: getProperties,
   ['ExtensionHostDebug.listProcesses']: listProcesses,
@@ -3484,7 +3856,7 @@ const main = async () => {
   const ipc = await listen({
     method: Auto()
   });
-  listen$2(ipc);
+  listen$4(ipc);
 };
 
 main();

package/package.json

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