@lvce-editor/static-server 0.63.2 → 0.63.3

package/static/{5dec7e3 → 1c3228b}/packages/error-worker/dist/errorWorkerMain.js

@@ -4,7 +4,7 @@ class HTTPError extends Error {
   options;
   constructor(response, request, options) {
     const code = response.status || response.status === 0 ? response.status : '';
-    const title = response.statusText || '';
+    const title = response.statusText ?? '';
     const status = `${code} ${title}`.trim();
     const reason = status ? `status code ${status}` : 'an unknown error';
     super(`Request failed with ${reason}: ${request.method} ${request.url}`);
@@ -60,7 +60,10 @@ const responseTypes = {
   text: 'text/*',
   formData: 'multipart/form-data',
   arrayBuffer: '*/*',
-  blob: '*/*'
+  blob: '*/*',
+  // Supported in modern Fetch implementations (for example, browsers and recent Node.js/undici).
+  // We still feature-check at runtime before exposing the shortcut.
+  bytes: '*/*'
 };
 // The maximum value of a 32bit int (see issue #117)
 const maxSafeTimeout = 2_147_483_647;
@@ -140,106 +143,70 @@ const getBodySize = body => {
   }
   return 0; // Default case, unable to determine size
 };
-const streamResponse = (response, onDownloadProgress) => {
-  const totalBytes = Number(response.headers.get('content-length')) || 0;
+const withProgress = (stream, totalBytes, onProgress) => {
+  let previousChunk;
   let transferredBytes = 0;
-  if (response.status === 204) {
-    if (onDownloadProgress) {
-      onDownloadProgress({
-        percent: 1,
-        totalBytes,
-        transferredBytes
-      }, new Uint8Array());
+  return stream.pipeThrough(new TransformStream({
+    transform(currentChunk, controller) {
+      controller.enqueue(currentChunk);
+      if (previousChunk) {
+        transferredBytes += previousChunk.byteLength;
+        let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+        // Avoid reporting 100% progress before the stream is actually finished (in case totalBytes is inaccurate)
+        if (percent >= 1) {
+          // Epsilon is used here to get as close as possible to 100% without reaching it.
+          // If we were to use 0.99 here, percent could potentially go backwards.
+          percent = 1 - Number.EPSILON;
+        }
+        onProgress?.({
+          percent,
+          totalBytes: Math.max(totalBytes, transferredBytes),
+          transferredBytes
+        }, previousChunk);
+      }
+      previousChunk = currentChunk;
+    },
+    flush() {
+      if (previousChunk) {
+        transferredBytes += previousChunk.byteLength;
+        onProgress?.({
+          percent: 1,
+          totalBytes: Math.max(totalBytes, transferredBytes),
+          transferredBytes
+        }, previousChunk);
+      }
     }
+  }));
+};
+const streamResponse = (response, onDownloadProgress) => {
+  if (!response.body) {
+    return response;
+  }
+  if (response.status === 204) {
     return new Response(null, {
       status: response.status,
       statusText: response.statusText,
       headers: response.headers
     });
   }
-  return new Response(new ReadableStream({
-    async start(controller) {
-      const reader = response.body.getReader();
-      if (onDownloadProgress) {
-        onDownloadProgress({
-          percent: 0,
-          transferredBytes: 0,
-          totalBytes
-        }, new Uint8Array());
-      }
-      async function read() {
-        const {
-          done,
-          value
-        } = await reader.read();
-        if (done) {
-          controller.close();
-          return;
-        }
-        if (onDownloadProgress) {
-          transferredBytes += value.byteLength;
-          const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-          onDownloadProgress({
-            percent,
-            transferredBytes,
-            totalBytes
-          }, value);
-        }
-        controller.enqueue(value);
-        await read();
-      }
-      await read();
-    }
-  }), {
+  const totalBytes = Number(response.headers.get('content-length')) || 0;
+  return new Response(withProgress(response.body, totalBytes, onDownloadProgress), {
     status: response.status,
     statusText: response.statusText,
     headers: response.headers
   });
 };
-const streamRequest = (request, onUploadProgress) => {
-  const totalBytes = getBodySize(request.body);
-  let transferredBytes = 0;
+// eslint-disable-next-line @typescript-eslint/ban-types
+const streamRequest = (request, onUploadProgress, originalBody) => {
+  if (!request.body) {
+    return request;
+  }
+  // Use original body for size calculation since request.body is already a stream
+  const totalBytes = getBodySize(originalBody ?? request.body);
   return new Request(request, {
     // @ts-expect-error - Types are outdated.
     duplex: 'half',
-    body: new ReadableStream({
-      async start(controller) {
-        const reader = request.body instanceof ReadableStream ? request.body.getReader() : new Response('').body.getReader();
-        async function read() {
-          const {
-            done,
-            value
-          } = await reader.read();
-          if (done) {
-            // Ensure 100% progress is reported when the upload is complete
-            if (onUploadProgress) {
-              onUploadProgress({
-                percent: 1,
-                transferredBytes,
-                totalBytes: Math.max(totalBytes, transferredBytes)
-              }, new Uint8Array());
-            }
-            controller.close();
-            return;
-          }
-          transferredBytes += value.byteLength;
-          let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-          if (totalBytes < transferredBytes || percent === 1) {
-            percent = 0.99;
-          }
-          if (onUploadProgress) {
-            onUploadProgress({
-              percent: Number(percent.toFixed(2)),
-              transferredBytes,
-              totalBytes
-            }, value);
-          }
-          controller.enqueue(value);
-          await read();
-        }
-        await read();
-      }
-    })
+    body: withProgress(request.body, totalBytes, onUploadProgress)
   });
 };
 
@@ -388,6 +355,26 @@ const findUnknownOptions = (request, options) => {
   }
   return unknownOptions;
 };
+const hasSearchParameters = search => {
+  if (search === undefined) {
+    return false;
+  }
+  // The `typeof array` still gives "object", so we need different checking for array.
+  if (Array.isArray(search)) {
+    return search.length > 0;
+  }
+  if (search instanceof URLSearchParams) {
+    return search.size > 0;
+  }
+  // Record
+  if (typeof search === 'object') {
+    return Object.keys(search).length > 0;
+  }
+  if (typeof search === 'string') {
+    return search.trim().length > 0;
+  }
+  return Boolean(search);
+};
 
 class Ky {
   static create(input, options) {
@@ -399,7 +386,7 @@ class Ky {
       // Delay the fetch so that body method shortcuts can set the Accept header
       await Promise.resolve();
       // Before using ky.request, _fetch clones it and saves the clone for future retries to use.
-      // If retry is not needed, close the cloned request's ReadableStream for memory safety.
+      // If retry is not needed, close both the original and cloned request's ReadableStream for memory safety.
       let response = await ky._fetch();
       for (const hook of ky._options.hooks.afterResponse) {
         // eslint-disable-next-line no-await-in-loop
@@ -431,12 +418,21 @@ class Ky {
     };
     const isRetriableMethod = ky._options.retry.methods.includes(ky.request.method.toLowerCase());
     const result = (isRetriableMethod ? ky._retry(function_) : function_()).finally(async () => {
-      // Now that we know a retry is not needed, close the ReadableStream of the cloned request.
+      const originalRequest = ky._originalRequest;
+      const cleanupPromises = [];
+      if (originalRequest && !originalRequest.bodyUsed) {
+        cleanupPromises.push(originalRequest.body?.cancel());
+      }
       if (!ky.request.bodyUsed) {
-        await ky.request.body?.cancel();
+        cleanupPromises.push(ky.request.body?.cancel());
       }
+      await Promise.all(cleanupPromises);
     });
     for (const [type, mimeType] of Object.entries(responseTypes)) {
+      // Only expose `.bytes()` when the environment implements it.
+      if (type === 'bytes' && typeof globalThis.Response?.prototype?.bytes !== 'function') {
+        continue;
+      }
       result[type] = async () => {
         // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
         ky.request.headers.set('accept', ky.request.headers.get('accept') || mimeType);
@@ -445,25 +441,34 @@ class Ky {
           if (response.status === 204) {
             return '';
           }
-          const arrayBuffer = await response.clone().arrayBuffer();
-          const responseSize = arrayBuffer.byteLength;
-          if (responseSize === 0) {
+          const text = await response.text();
+          if (text === '') {
             return '';
           }
           if (options.parseJson) {
-            return options.parseJson(await response.text());
+            return options.parseJson(text);
           }
+          return JSON.parse(text);
         }
         return response[type]();
       };
     }
     return result;
   }
+  // eslint-disable-next-line unicorn/prevent-abbreviations
+  static #normalizeSearchParams(searchParams) {
+    // Filter out undefined values from plain objects
+    if (searchParams && typeof searchParams === 'object' && !Array.isArray(searchParams) && !(searchParams instanceof URLSearchParams)) {
+      return Object.fromEntries(Object.entries(searchParams).filter(([, value]) => value !== undefined));
+    }
+    return searchParams;
+  }
   request;
   abortController;
   _retryCount = 0;
   _input;
   _options;
+  _originalRequest;
   // eslint-disable-next-line complexity
   constructor(input, options = {}) {
     this._input = input;
@@ -510,9 +515,9 @@ class Ky {
       this._options.headers.set('content-type', this._options.headers.get('content-type') ?? 'application/json');
     }
     this.request = new globalThis.Request(this._input, this._options);
-    if (this._options.searchParams) {
+    if (hasSearchParameters(this._options.searchParams)) {
       // eslint-disable-next-line unicorn/prevent-abbreviations
-      const textSearchParams = typeof this._options.searchParams === 'string' ? this._options.searchParams.replace(/^\?/, '') : new URLSearchParams(this._options.searchParams).toString();
+      const textSearchParams = typeof this._options.searchParams === 'string' ? this._options.searchParams.replace(/^\?/, '') : new URLSearchParams(Ky.#normalizeSearchParams(this._options.searchParams)).toString();
       // eslint-disable-next-line unicorn/prevent-abbreviations
       const searchParams = '?' + textSearchParams;
       const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
@@ -535,7 +540,8 @@ class Ky {
       }
       const originalBody = this.request.body;
       if (originalBody) {
-        this.request = streamRequest(this.request, this._options.onUploadProgress);
+        // Pass original body to calculate size correctly (before it becomes a stream)
+        this.request = streamRequest(this.request, this._options.onUploadProgress, this._options.body);
       }
     }
   }
@@ -615,12 +621,12 @@ class Ky {
     }
     const nonRequestOptions = findUnknownOptions(this.request, this._options);
     // Cloning is done here to prepare in advance for retries
-    const mainRequest = this.request;
-    this.request = mainRequest.clone();
+    this._originalRequest = this.request;
+    this.request = this._originalRequest.clone();
     if (this._options.timeout === false) {
-      return this._options.fetch(mainRequest, nonRequestOptions);
+      return this._options.fetch(this._originalRequest, nonRequestOptions);
     }
-    return timeout(mainRequest, nonRequestOptions, this.abortController, this._options);
+    return timeout(this._originalRequest, nonRequestOptions, this.abortController, this._options);
   }
 }
 
@@ -743,7 +749,7 @@ const Object$1 = 1;
 const Number$1 = 2;
 const Array$1 = 3;
 const String$1 = 4;
-const Boolean = 5;
+const Boolean$1 = 5;
 const Function$1 = 6;
 const Null = 7;
 const Unknown = 8;
@@ -764,7 +770,7 @@ const getType$2 = value => {
       }
       return Object$1;
     case 'boolean':
-      return Boolean;
+      return Boolean$1;
     default:
       return Unknown;
   }
@@ -1212,7 +1218,7 @@ const create$4$1 = (method, params) => {
   };
 };
 const callbacks = Object.create(null);
-const set$1 = (id, fn) => {
+const set$3 = (id, fn) => {
   callbacks[id] = fn;
 };
 const get$1 = id => {
@@ -1231,7 +1237,7 @@ const registerPromise = () => {
     resolve,
     promise
   } = Promise.withResolvers();
-  set$1(id, resolve);
+  set$3(id, resolve);
   return {
     id,
     promise
@@ -1311,7 +1317,8 @@ const splitLines$1 = lines => {
   return lines.split(NewLine$1);
 };
 const getCurrentStack = () => {
-  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(2));
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines$1(splitLines$1(new Error().stack || '').slice(stackLinesToSkip));
   return currentStack;
 };
 const getNewLineIndex$1 = (string, startIndex = undefined) => {
@@ -1575,13 +1582,19 @@ const send = (transport, method, ...params) => {
   const message = create$4$1(method, params);
   transport.send(message);
 };
-const invoke = (ipc, method, ...params) => {
+const invoke$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, false);
 };
-const invokeAndTransfer = (ipc, method, ...params) => {
+const invokeAndTransfer$1 = (ipc, method, ...params) => {
   return invokeHelper(ipc, method, params, true);
 };
 
+class CommandNotFoundError extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = 'CommandNotFoundError';
+  }
+}
 const commands = Object.create(null);
 const register = commandMap => {
   Object.assign(commands, commandMap);
@@ -1592,7 +1605,7 @@ const getCommand = key => {
 const execute = (command, ...args) => {
   const fn = getCommand(command);
   if (!fn) {
-    throw new Error(`command not found ${command}`);
+    throw new CommandNotFoundError(command);
   }
   return fn(...args);
 };
@@ -1608,10 +1621,10 @@ const createRpc = ipc => {
       send(ipc, method, ...params);
     },
     invoke(method, ...params) {
-      return invoke(ipc, method, ...params);
+      return invoke$1(ipc, method, ...params);
     },
     invokeAndTransfer(method, ...params) {
-      return invokeAndTransfer(ipc, method, ...params);
+      return invokeAndTransfer$1(ipc, method, ...params);
     },
     async dispose() {
       await ipc?.dispose();
@@ -1692,6 +1705,25 @@ const WebWorkerRpcClient = {
   __proto__: null,
   create: create$2
 };
+const createMockRpc = ({
+  commandMap
+}) => {
+  const invocations = [];
+  const invoke = (method, ...params) => {
+    invocations.push([method, ...params]);
+    const command = commandMap[method];
+    if (!command) {
+      throw new Error(`command ${method} not found`);
+    }
+    return command(...params);
+  };
+  const mockRpc = {
+    invoke,
+    invokeAndTransfer: invoke,
+    invocations
+  };
+  return mockRpc;
+};
 
 const commandMapRef = Object.create(null);
 
@@ -3049,7 +3081,6 @@ var estree = superClass => class ESTreeParserMixin extends superClass {
       this.castNodeTo(node, "ImportExpression");
       node.source = node.arguments[0];
       node.options = node.arguments[1] ?? null;
-      node.attributes = node.arguments[1] ?? null;
       delete node.arguments;
       delete node.callee;
     } else if (node.type === "OptionalCallExpression") {
@@ -10140,6 +10171,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
     this.expect(14);
     withProperty.value = this.tsParseImportTypeWithPropertyValue();
     node.properties = [this.finishObjectProperty(withProperty)];
+    this.eat(12);
     this.expect(8);
     return this.finishNode(node, "ObjectExpression");
   }
@@ -11478,6 +11510,7 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         if (!noCalls && this.atPossibleAsyncArrow(base)) {
           const asyncArrowFn = this.tsTryParseGenericAsyncArrowFunction(startLoc);
           if (asyncArrowFn) {
+            state.stop = true;
             return asyncArrowFn;
           }
         }
@@ -12509,6 +12542,10 @@ var typescript = superClass => class TypeScriptParserMixin extends superClass {
         node.declare ??= false;
         node.extends ??= [];
         return;
+      case "TSMappedType":
+        node.optional ??= false;
+        node.readonly ??= undefined;
+        return;
       case "TSModuleDeclaration":
         node.declare ??= false;
         node.global ??= node.kind === "global";
@@ -17745,7 +17782,7 @@ defineType$4("RegExpLiteral", {
     },
     flags: {
       validate: chain(assertValueType("string"), Object.assign(function (node, key, val) {
-        const invalid = /[^gimsuy]/.exec(val);
+        const invalid = /[^dgimsuvy]/.exec(val);
         if (invalid) {
           throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
         }
@@ -18697,7 +18734,7 @@ defineType$4("ExportNamespaceSpecifier", {
 defineType$4("OptionalMemberExpression", {
   builder: ["object", "property", "computed", "optional"],
   visitor: ["object", "property"],
-  aliases: ["Expression", "LVal"],
+  aliases: ["Expression"],
   fields: {
     object: {
       validate: assertNodeType("Expression")
@@ -19917,7 +19954,8 @@ defineType("TSTypeOperator", {
   builder: ["typeAnnotation", "operator"],
   fields: {
     operator: {
-      validate: assertOneOf("keyof", "readonly", "unique")
+      validate: assertOneOf("keyof", "readonly", "unique"),
+      default: undefined
     },
     typeAnnotation: validateType("TSType")
   }
@@ -20442,16 +20480,17 @@ const commandMap = {
   'Errors.tryToGetActualImportErrorMessage': tryToGetActualImportErrorMessage
 };
 
+const DebugWorker = 55;
+const RendererWorker$1 = 1;
+
 const rpcs = Object.create(null);
-const set$g = (id, rpc) => {
+const set$2 = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
   return rpcs[id];
 };
 
-/* eslint-disable  @typescript-eslint/explicit-function-return-type */
-
 const create = rpcId => {
   return {
     // @ts-ignore
@@ -20467,7 +20506,7 @@ const create = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$g(rpcId, rpc);
+      set$2(rpcId, rpc);
     },
     async dispose() {
       const rpc = get(rpcId);
@@ -20475,12 +20514,361 @@ const create = rpcId => {
     }
   };
 };
-const RendererWorker$1 = 1;
+
 const {
-  set: set$3} = create(RendererWorker$1);
+  invoke,
+  invokeAndTransfer,
+  set: set$1,
+  dispose
+} = create(RendererWorker$1);
+const searchFileHtml = async uri => {
+  return invoke('ExtensionHost.searchFileWithHtml', uri);
+};
+const getFilePathElectron = async file => {
+  return invoke('FileSystemHandle.getFilePathElectron', file);
+};
+const showContextMenu = async (x, y, id, ...args) => {
+  return invoke('ContextMenu.show', x, y, id, ...args);
+};
+const getElectronVersion = async () => {
+  return invoke('Process.getElectronVersion');
+};
+const applyBulkReplacement = async bulkEdits => {
+  await invoke('BulkReplacement.applyBulkReplacement', bulkEdits);
+};
+const setColorTheme = async id => {
+  // @ts-ignore
+  return invoke(/* ColorTheme.setColorTheme */'ColorTheme.setColorTheme', /* colorThemeId */id);
+};
+const getNodeVersion = async () => {
+  return invoke('Process.getNodeVersion');
+};
+const getChromeVersion = async () => {
+  return invoke('Process.getChromeVersion');
+};
+const getV8Version = async () => {
+  return invoke('Process.getV8Version');
+};
+const getFileHandles = async fileIds => {
+  const files = await invoke('FileSystemHandle.getFileHandles', fileIds);
+  return files;
+};
+const setWorkspacePath = async path => {
+  await invoke('Workspace.setPath', path);
+};
+const registerWebViewInterceptor = async (id, port) => {
+  await invokeAndTransfer('WebView.registerInterceptor', id, port);
+};
+const unregisterWebViewInterceptor = async id => {
+  await invoke('WebView.unregisterInterceptor', id);
+};
+const sendMessagePortToEditorWorker = async (port, rpcId) => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToEditorWorker', port, command, rpcId);
+};
+const sendMessagePortToErrorWorker = async (port, rpcId) => {
+  const command = 'Errors.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToErrorWorker', port, command, rpcId);
+};
+const sendMessagePortToMarkdownWorker = async (port, rpcId) => {
+  const command = 'Markdown.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToMarkdownWorker', port, command, rpcId);
+};
+const sendMessagePortToIconThemeWorker = async (port, rpcId) => {
+  const command = 'IconTheme.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToIconThemeWorker', port, command, rpcId);
+};
+const sendMessagePortToFileSystemWorker = async (port, rpcId) => {
+  const command = 'FileSystem.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToFileSystemWorker', port, command, rpcId);
+};
+const readFile = async uri => {
+  return invoke('FileSystem.readFile', uri);
+};
+const getWebViewSecret = async key => {
+  // @ts-ignore
+  return invoke('WebView.getSecret', key);
+};
+const setWebViewPort = async (uid, port, origin, portType) => {
+  return invokeAndTransfer('WebView.setPort', uid, port, origin, portType);
+};
+const setFocus = key => {
+  return invoke('Focus.setFocus', key);
+};
+const getFileIcon = async options => {
+  return invoke('IconTheme.getFileIcon', options);
+};
+const getColorThemeNames = async () => {
+  return invoke('ColorTheme.getColorThemeNames');
+};
+const disableExtension = async id => {
+  // @ts-ignore
+  return invoke('ExtensionManagement.disable', id);
+};
+const enableExtension = async id => {
+  // @ts-ignore
+  return invoke('ExtensionManagement.enable', id);
+};
+const handleDebugChange = async params => {
+  // @ts-ignore
+  return invoke('Run And Debug.handleChange', params);
+};
+const getFolderIcon = async options => {
+  return invoke('IconTheme.getFolderIcon', options);
+};
+const closeWidget = async widgetId => {
+  return invoke('Viewlet.closeWidget', widgetId);
+};
+const sendMessagePortToExtensionHostWorker = async (port, rpcId = 0) => {
+  const command = 'HandleMessagePort.handleMessagePort2';
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker', port, command, rpcId);
+};
+const sendMessagePortToSearchProcess = async port => {
+  await invokeAndTransfer('SendMessagePortToElectron.sendMessagePortToElectron', port, 'HandleMessagePortForSearchProcess.handleMessagePortForSearchProcess');
+};
+const confirm = async (message, options) => {
+  // @ts-ignore
+  const result = await invoke('ConfirmPrompt.prompt', message, options);
+  return result;
+};
+const getRecentlyOpened = async () => {
+  return invoke(/* RecentlyOpened.getRecentlyOpened */'RecentlyOpened.getRecentlyOpened');
+};
+const getKeyBindings = async () => {
+  return invoke('KeyBindingsInitial.getKeyBindings');
+};
+const writeClipBoardText = async text => {
+  await invoke('ClipBoard.writeText', /* text */text);
+};
+const writeClipBoardImage = async blob => {
+  // @ts-ignore
+  await invoke('ClipBoard.writeImage', /* text */blob);
+};
+const searchFileMemory = async uri => {
+  // @ts-ignore
+  return invoke('ExtensionHost.searchFileWithMemory', uri);
+};
+const searchFileFetch = async uri => {
+  return invoke('ExtensionHost.searchFileWithFetch', uri);
+};
+const showMessageBox = async options => {
+  return invoke('ElectronDialog.showMessageBox', options);
+};
+const handleDebugResumed = async params => {
+  await invoke('Run And Debug.handleResumed', params);
+};
+const openWidget = async name => {
+  await invoke('Viewlet.openWidget', name);
+};
+const getIcons = async requests => {
+  const icons = await invoke('IconTheme.getIcons', requests);
+  return icons;
+};
+const activateByEvent = event => {
+  return invoke('ExtensionHostManagement.activateByEvent', event);
+};
+const setAdditionalFocus = focusKey => {
+  // @ts-ignore
+  return invoke('Focus.setAdditionalFocus', focusKey);
+};
+const getActiveEditorId = () => {
+  // @ts-ignore
+  return invoke('GetActiveEditor.getActiveEditorId');
+};
+const getWorkspacePath = () => {
+  return invoke('Workspace.getPath');
+};
+const sendMessagePortToRendererProcess = async port => {
+  const command = 'HandleMessagePort.handleMessagePort';
+  // @ts-ignore
+  await invokeAndTransfer('SendMessagePortToExtensionHostWorker.sendMessagePortToRendererProcess', port, command, DebugWorker);
+};
+const getPreference = async key => {
+  return await invoke('Preferences.get', key);
+};
+const getAllExtensions = async () => {
+  return invoke('ExtensionManagement.getAllExtensions');
+};
+const rerenderEditor = async key => {
+  // @ts-ignore
+  return invoke('Editor.rerender', key);
+};
+const handleDebugPaused = async params => {
+  await invoke('Run And Debug.handlePaused', params);
+};
+const openUri = async (uri, focus, options) => {
+  await invoke('Main.openUri', uri, focus, options);
+};
+const sendMessagePortToSyntaxHighlightingWorker = async port => {
+  await invokeAndTransfer(
+  // @ts-ignore
+  'SendMessagePortToSyntaxHighlightingWorker.sendMessagePortToSyntaxHighlightingWorker', port, 'HandleMessagePort.handleMessagePort2');
+};
+const handleDebugScriptParsed = async script => {
+  await invoke('Run And Debug.handleScriptParsed', script);
+};
+const getWindowId = async () => {
+  return invoke('GetWindowId.getWindowId');
+};
+const getBlob = async uri => {
+  // @ts-ignore
+  return invoke('FileSystem.getBlob', uri);
+};
+const getExtensionCommands = async () => {
+  return invoke('ExtensionHost.getCommands');
+};
+const showErrorDialog = async errorInfo => {
+  // @ts-ignore
+  await invoke('ErrorHandling.showErrorDialog', errorInfo);
+};
+const getFolderSize = async uri => {
+  // @ts-ignore
+  return await invoke('FileSystem.getFolderSize', uri);
+};
+const getExtension = async id => {
+  // @ts-ignore
+  return invoke('ExtensionManagement.getExtension', id);
+};
+const getMarkdownDom = async html => {
+  // @ts-ignore
+  return invoke('Markdown.getVirtualDom', html);
+};
+const renderMarkdown = async (markdown, options) => {
+  // @ts-ignore
+  return invoke('Markdown.renderMarkdown', markdown, options);
+};
+const openNativeFolder = async uri => {
+  // @ts-ignore
+  await invoke('OpenNativeFolder.openNativeFolder', uri);
+};
+const uninstallExtension = async id => {
+  return invoke('ExtensionManagement.uninstall', id);
+};
+const installExtension = async id => {
+  // @ts-ignore
+  return invoke('ExtensionManagement.install', id);
+};
+const openExtensionSearch = async () => {
+  // @ts-ignore
+  return invoke('SideBar.openViewlet', 'Extensions');
+};
+const setExtensionsSearchValue = async searchValue => {
+  // @ts-ignore
+  return invoke('Extensions.handleInput', searchValue);
+};
+const openExternal = async uri => {
+  // @ts-ignore
+  await invoke('Open.openExternal', uri);
+};
+const openUrl = async uri => {
+  // @ts-ignore
+  await invoke('Open.openUrl', uri);
+};
+const getAllPreferences = async () => {
+  // @ts-ignore
+  return invoke('Preferences.getAll');
+};
+const showSaveFilePicker = async () => {
+  // @ts-ignore
+  return invoke('FilePicker.showSaveFilePicker');
+};
+const getLogsDir = async () => {
+  // @ts-ignore
+  return invoke('PlatformPaths.getLogsDir');
+};
+const registerMockRpc = commandMap => {
+  const mockRpc = createMockRpc({
+    commandMap
+  });
+  set$1(mockRpc);
+  return mockRpc;
+};
+
 const RendererWorker = {
-  __proto__: null,
-  set: set$3};
+    __proto__: null,
+    activateByEvent,
+    applyBulkReplacement,
+    closeWidget,
+    confirm,
+    disableExtension,
+    dispose,
+    enableExtension,
+    getActiveEditorId,
+    getAllExtensions,
+    getAllPreferences,
+    getBlob,
+    getChromeVersion,
+    getColorThemeNames,
+    getElectronVersion,
+    getExtension,
+    getExtensionCommands,
+    getFileHandles,
+    getFileIcon,
+    getFilePathElectron,
+    getFolderIcon,
+    getFolderSize,
+    getIcons,
+    getKeyBindings,
+    getLogsDir,
+    getMarkdownDom,
+    getNodeVersion,
+    getPreference,
+    getRecentlyOpened,
+    getV8Version,
+    getWebViewSecret,
+    getWindowId,
+    getWorkspacePath,
+    handleDebugChange,
+    handleDebugPaused,
+    handleDebugResumed,
+    handleDebugScriptParsed,
+    installExtension,
+    invoke,
+    invokeAndTransfer,
+    openExtensionSearch,
+    openExternal,
+    openNativeFolder,
+    openUri,
+    openUrl,
+    openWidget,
+    readFile,
+    registerMockRpc,
+    registerWebViewInterceptor,
+    renderMarkdown,
+    rerenderEditor,
+    searchFileFetch,
+    searchFileHtml,
+    searchFileMemory,
+    sendMessagePortToEditorWorker,
+    sendMessagePortToErrorWorker,
+    sendMessagePortToExtensionHostWorker,
+    sendMessagePortToFileSystemWorker,
+    sendMessagePortToIconThemeWorker,
+    sendMessagePortToMarkdownWorker,
+    sendMessagePortToRendererProcess,
+    sendMessagePortToSearchProcess,
+    sendMessagePortToSyntaxHighlightingWorker,
+    set: set$1,
+    setAdditionalFocus,
+    setColorTheme,
+    setExtensionsSearchValue,
+    setFocus,
+    setWebViewPort,
+    setWorkspacePath,
+    showContextMenu,
+    showErrorDialog,
+    showMessageBox,
+    showSaveFilePicker,
+    uninstallExtension,
+    unregisterWebViewInterceptor,
+    writeClipBoardImage,
+    writeClipBoardText
+};
 
 const {
   set