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

package/dist/extensionHostWorkerMain.js

@@ -30,13 +30,13 @@ const getJson = async url => {
   throw new DepecratedError(`vscode.getJson is deprecated, use createNodeRpc instead`);
 };
 
-let AssertionError$1 = class AssertionError extends Error {
+class AssertionError extends Error {
   constructor(message) {
     super(message);
     this.name = 'AssertionError';
   }
-};
-const getType$2 = value => {
+}
+const getType$1 = value => {
   switch (typeof value) {
     case 'number':
       return 'number';
@@ -59,33 +59,33 @@ const getType$2 = value => {
   }
 };
 const object = value => {
-  const type = getType$2(value);
+  const type = getType$1(value);
   if (type !== 'object') {
-    throw new AssertionError$1('expected value to be of type object');
+    throw new AssertionError('expected value to be of type object');
   }
 };
-const number$1 = value => {
-  const type = getType$2(value);
+const number = value => {
+  const type = getType$1(value);
   if (type !== 'number') {
-    throw new AssertionError$1('expected value to be of type number');
+    throw new AssertionError('expected value to be of type number');
   }
 };
 const array = value => {
-  const type = getType$2(value);
+  const type = getType$1(value);
   if (type !== 'array') {
-    throw new AssertionError$1('expected value to be of type array');
+    throw new AssertionError('expected value to be of type array');
   }
 };
 const string = value => {
-  const type = getType$2(value);
+  const type = getType$1(value);
   if (type !== 'string') {
-    throw new AssertionError$1('expected value to be of type string');
+    throw new AssertionError('expected value to be of type string');
   }
 };
 const fn = value => {
-  const type = getType$2(value);
+  const type = getType$1(value);
   if (type !== 'function') {
-    throw new AssertionError$1('expected value to be of type function');
+    throw new AssertionError('expected value to be of type function');
   }
 };
 
@@ -287,7 +287,7 @@ const getSyntheticChanges = (textDocument, changes) => {
   return syntheticChanges;
 };
 const syncIncremental = (textDocumentId, changes) => {
-  number$1(textDocumentId);
+  number(textDocumentId);
   array(changes);
   const textDocument = getDocument(textDocumentId);
   if (!textDocument) {
@@ -332,10 +332,10 @@ class NoProviderFoundError extends Error {
 
 const normalizeLine$1 = 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;
 };
@@ -386,7 +386,7 @@ let VError$1 = class VError extends Error {
   }
 };
 
-const getType$1 = value => {
+const getType = value => {
   switch (typeof value) {
     case 'number':
       return 'number';
@@ -417,7 +417,7 @@ const validateResultObject = (result, resultShape) => {
   for (const [key, value] of Object.entries(resultShape.properties)) {
     // @ts-ignore
     const expectedType = value.type;
-    const actualType = getType$1(result[key]);
+    const actualType = getType(result[key]);
     if (expectedType !== actualType) {
       return `item.${key} must be of type ${expectedType}`;
     }
@@ -426,7 +426,7 @@ const validateResultObject = (result, resultShape) => {
 };
 const validateResultArray = (result, resultShape) => {
   for (const item of result) {
-    const actualType = getType$1(item);
+    const actualType = getType(item);
     const expectedType = resultShape.items.type;
     if (actualType !== expectedType) {
       return `expected result to be of type ${expectedType} but was of type ${actualType}`;
@@ -447,7 +447,7 @@ const getPreviewString = item => {
   return `"${item}"`;
 };
 const getPreview = item => {
-  const type = getType$1(item);
+  const type = getType(item);
   switch (type) {
     case 'object':
       return getPreviewObject();
@@ -460,7 +460,7 @@ const getPreview = item => {
   }
 };
 const validate = (item, schema) => {
-  const actualType = getType$1(item);
+  const actualType = getType(item);
   const expectedType = schema.type;
   if (actualType !== expectedType) {
     if (schema.allowUndefined && (item === undefined || item === null)) {
@@ -684,7 +684,7 @@ const getCommandDisplay = command => {
   }
   return '';
 };
-const registerCommand$1 = command => {
+const registerCommand = command => {
   try {
     if (!command) {
       if (command === null) {
@@ -766,57 +766,19 @@ const create$4$1 = (method, params) => {
     params
   };
 };
-class AssertionError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = 'AssertionError';
-  }
-}
-const getType = value => {
-  switch (typeof value) {
-    case 'number':
-      return 'number';
-    case 'function':
-      return 'function';
-    case 'string':
-      return 'string';
-    case 'object':
-      if (value === null) {
-        return 'null';
-      }
-      if (Array.isArray(value)) {
-        return 'array';
-      }
-      return 'object';
-    case 'boolean':
-      return 'boolean';
-    default:
-      return 'unknown';
-  }
-};
-const number = value => {
-  const type = getType(value);
-  if (type !== 'number') {
-    throw new AssertionError('expected value to be of type number');
-  }
-};
-const state$1$1 = {
-  callbacks: Object.create(null)
-};
+const callbacks = Object.create(null);
 const set$4 = (id, fn) => {
-  state$1$1.callbacks[id] = fn;
+  callbacks[id] = fn;
 };
 const get$4 = id => {
-  return state$1$1.callbacks[id];
+  return callbacks[id];
 };
 const remove = id => {
-  delete state$1$1.callbacks[id];
-};
-const state$6 = {
-  id: 0
+  delete callbacks[id];
 };
+let id = 0;
 const create$3$1 = () => {
-  return ++state$6.id;
+  return ++id;
 };
 const warn = (...args) => {
   console.warn(...args);
@@ -833,15 +795,14 @@ const registerPromise = () => {
     promise
   };
 };
-const resolve = (id, args) => {
-  number(id);
+const resolve = (id, response) => {
   const fn = get$4(id);
   if (!fn) {
-    console.log(args);
+    console.log(response);
     warn(`callback ${id} may already be disposed`);
     return;
   }
-  fn(args);
+  fn(response);
   remove(id);
 };
 const create$2$1 = (method, params) => {
@@ -1063,32 +1024,42 @@ const defaultRequiresSocket = () => {
   return false;
 };
 const defaultResolve = resolve;
-const handleJsonRpcMessage = async (...args) => {
-  let message;
-  let ipc;
-  let execute;
-  let preparePrettyError;
-  let logError;
-  let resolve;
-  let requiresSocket;
+
+// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
+const normalizeParams = args => {
   if (args.length === 1) {
-    const arg = args[0];
-    message = arg.message;
-    ipc = arg.ipc;
-    execute = arg.execute;
-    preparePrettyError = arg.preparePrettyError || defaultPreparePrettyError;
-    logError = arg.logError || defaultLogError;
-    requiresSocket = arg.requiresSocket || defaultRequiresSocket;
-    resolve = arg.resolve || defaultResolve;
-  } else {
-    ipc = args[0];
-    message = args[1];
-    execute = args[2];
-    resolve = args[3];
-    preparePrettyError = args[4];
-    logError = args[5];
-    requiresSocket = args[6];
+    const options = args[0];
+    return {
+      ipc: options.ipc,
+      message: options.message,
+      execute: options.execute,
+      resolve: options.resolve || defaultResolve,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      logError: options.logError || defaultLogError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket
+    };
   }
+  return {
+    ipc: args[0],
+    message: args[1],
+    execute: args[2],
+    resolve: args[3],
+    preparePrettyError: args[4],
+    logError: args[5],
+    requiresSocket: args[6]
+  };
+};
+const handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    message,
+    ipc,
+    execute,
+    resolve,
+    preparePrettyError,
+    logError,
+    requiresSocket
+  } = options;
   if ('id' in message) {
     if ('method' in message) {
       const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
@@ -1109,39 +1080,33 @@ const handleJsonRpcMessage = async (...args) => {
   }
   throw new JsonRpcError('unexpected message');
 };
-const send$1 = (transport, method, ...params) => {
-  const message = create$4$1(method, params);
-  transport.send(message);
-};
-const invoke$1 = async (ipc, method, ...params) => {
+const invokeHelper = async (ipc, method, params, useSendAndTransfer) => {
   const {
     message,
     promise
   } = create$2$1(method, params);
-  ipc.send(message);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
   const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+  return unwrapJsonRpcResult(responseMessage);
 };
-const invokeAndTransfer$1 = async (ipc, method, ...params) => {
-  const {
-    message,
-    promise
-  } = create$2$1(method, params);
-  ipc.sendAndTransfer(message);
-  const responseMessage = await promise;
-  const result = unwrapJsonRpcResult(responseMessage);
-  return result;
+const send$1 = (transport, method, ...params) => {
+  const message = create$4$1(method, params);
+  transport.send(message);
+};
+const invoke$1 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, false);
+};
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
+  return invokeHelper(ipc, method, params, true);
 };
 
 const commands = Object.create(null);
-const registerCommand = (key, fn) => {
-  commands[key] = fn;
-};
 const register$1 = commandMap => {
-  for (const [key, value] of Object.entries(commandMap)) {
-    registerCommand(key, value);
-  }
+  Object.assign(commands, commandMap);
 };
 const getCommand = key => {
   return commands[key];
@@ -1171,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) => {
@@ -1196,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`);
@@ -1216,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 {
@@ -1836,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');
   }
@@ -1857,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');
   }
@@ -1879,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');
   }
@@ -1887,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;
   }
@@ -1902,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;
   }
@@ -1912,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
@@ -1941,7 +1906,7 @@ const {
   }
 });
 
-const state$2 = {
+const state$3 = {
   textSearchProviders: Object.create(null)
 };
 const registerTextSearchProvider = textSearchProvider => {
@@ -1952,16 +1917,16 @@ 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`);
+      throw new Error(`No text search provider for ${scheme} found`);
     }
     const results = await textSearchProvider.provideTextSearchResults(query);
     return results;
@@ -2216,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 {
@@ -2256,7 +2221,7 @@ const api = {
   // Code Action
   registerCodeActionsProvider: registerCodeActionProvider,
   // Command
-  registerCommand: registerCommand$1,
+  registerCommand: registerCommand,
   executeCommand: executeCommand,
   // Completion
   registerCompletionProvider: registerCompletionProvider,
@@ -2453,7 +2418,7 @@ class ContentSecurityPolicyError extends Error {
   }
 }
 
-const state = {
+const state$1 = {
   /**
    * @type {any[]}
    */
@@ -2461,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 => {
@@ -2893,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
@@ -2927,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;
@@ -2977,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 {
@@ -3031,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';
@@ -3155,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;
 };
@@ -3256,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');
@@ -3304,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 => {
@@ -3404,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,
@@ -3539,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.11.0",
+  "version": "1.13.0",
   "description": "Webworker for the extension host functionality in Lvce Editor.",
   "main": "dist/extensionHostWorkerMain.js",
   "type": "module",