@lvce-editor/rpc-registry 8.0.0 → 8.2.0

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from './parts/Main/Main.ts';

package/dist/parts/BulkReplacementEdit/BulkReplacementEdit.d.ts

@@ -0,0 +1,5 @@
+import type { TextEdit } from '../TextEdit/TextEdit.ts';
+export interface BulkReplacementEdit {
+    readonly changes: readonly TextEdit[];
+    readonly uri: string;
+}

package/dist/parts/Change/Change.d.ts

@@ -0,0 +1,15 @@
+export interface Range {
+    readonly columnIndex: number;
+    readonly rowIndex: number;
+}
+export interface Selection {
+    readonly end: Range;
+    readonly start: Range;
+}
+export interface Change {
+    readonly deleted: readonly string[];
+    readonly end: Range;
+    readonly inserted: readonly string[];
+    readonly origin: string;
+    readonly start: Range;
+}

package/dist/parts/ClipBoardProcess/ClipBoardProcess.d.ts

@@ -0,0 +1 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;

package/dist/parts/ClipBoardProcessApi/ClipBoardProcessApi.d.ts

@@ -0,0 +1,5 @@
+export interface ClipBoardProcessApi {
+    readonly 'ClipBoard.readNativeFiles': () => Promise<any>;
+    readonly 'ClipBoard.writeNativeFiles': (type: string, files: readonly string[]) => Promise<void>;
+    readonly 'ClipBoard.writeText': (text: string) => Promise<void>;
+}

package/dist/parts/ClipBoardWorker/ClipBoardWorker.d.ts

@@ -0,0 +1,5 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const writeText: (text: string) => Promise<void>;
+export declare const readText: () => Promise<string>;
+export declare const writeImage: (image: any) => Promise<void>;
+export declare const readNativeFiles: () => Promise<readonly any[]>;

package/dist/parts/ClipBoardWorkerApi/ClipBoardWorkerApi.d.ts

@@ -0,0 +1,5 @@
+export interface ClipBoardWorkerApi {
+    readonly 'ClipBoard.readNativeFiles': () => Promise<any>;
+    readonly 'ClipBoard.writeNativeFiles': (type: string, files: readonly string[]) => Promise<void>;
+    readonly 'ClipBoard.writeText': (text: string) => Promise<void>;
+}

package/dist/parts/ConfirmPromptOptions/ConfirmPromptOptions.d.ts

@@ -0,0 +1,4 @@
+export interface ConfirmPromptOptions {
+    readonly confirmMessage: string;
+    readonly title: string;
+}

package/dist/parts/CreateLazyRpc/CreateLazyRpc.d.ts

@@ -0,0 +1,2 @@
+import type { LazyRpc } from '../LazyRpc/LazyRpc.ts';
+export declare const createLazyRpc: (rpcId: number) => LazyRpc;

package/dist/parts/DebugWorker/DebugWorker.d.ts

@@ -0,0 +1 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;

package/dist/parts/DebugWorkerApi/DebugWorkerApi.d.ts

@@ -0,0 +1,4 @@
+export interface DebugWorkerApi {
+    readonly 'Debug.pause': () => Promise<void>;
+    readonly 'Debug.resume': () => Promise<void>;
+}

package/dist/parts/DisposableMockRpc/DisposableMockRpc.d.ts

@@ -0,0 +1,4 @@
+import type { MockRpc } from '@lvce-editor/rpc';
+export interface DisposableMockRpc extends MockRpc {
+    [Symbol.dispose]: () => void;
+}

package/dist/parts/EditorWorker/EditorWorker.d.ts

@@ -0,0 +1,21 @@
+import type { Change } from '../Change/Change.ts';
+import type { PositionAtCursor } from '../PositionAtCursor/PositionAtCursor.ts';
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const sendMessagePortToExtensionHostWorker: (port: MessagePort) => Promise<void>;
+export declare const activateByEvent: (event: string) => Promise<void>;
+export declare const applyEdit: (editorUid: number, changes: readonly Change[]) => Promise<void>;
+export declare const applyDocumentEdits: (editorUid: number, changes: readonly Change[]) => Promise<void>;
+export declare const applyWorkspaceEdit: (editorUid: number, changes: readonly any[]) => Promise<void>;
+export declare const closeWidget: (editorUid: number, widgetId: number, widgetName: string, focusId: number) => Promise<void>;
+export declare const getWordAt: (uid: number, rowIndex: number, columnIndex: number) => Promise<string>;
+export declare const getLines: (editorUid: number) => Promise<readonly string[]>;
+export declare const getPositionAtCursor: (parentUid: number) => Promise<PositionAtCursor>;
+export declare const getOffsetAtCursor: (editorId: number) => Promise<number>;
+export declare const getSelections: (editorUid: number) => Promise<readonly number[]>;
+export declare const getWordAtOffset2: (editorUid: number) => Promise<string>;
+export declare const closeFind2: (editorUid: number) => Promise<void>;
+export declare const getWordBefore: (editorUid: number, rowIndex: number, columnIndex: number) => Promise<string>;
+export declare const updateDebugInfo: (info: any) => Promise<void>;
+export declare const getUri: (editorUid: number) => Promise<string>;
+export declare const getLanguageId: (editorUid: number) => Promise<string>;
+export declare const getProblems: () => Promise<readonly any[]>;

package/dist/parts/EditorWorkerApi/EditorWorkerApi.d.ts

@@ -0,0 +1,10 @@
+import type { PositionAtCursor } from '../PositionAtCursor/PositionAtCursor.ts';
+export interface EditorWorkerApi {
+    readonly 'Editor.getLines2': (editorUid: number) => Promise<readonly string[]>;
+    readonly 'Editor.getPositionAtCursor': (uid: number) => Promise<PositionAtCursor>;
+    readonly 'Editor.getSelections2': (editorUid: number) => Promise<readonly number[]>;
+    readonly 'Editor.getWordAt2': (uid: number, rowIndex: number, columnIndex: number) => Promise<string>;
+    readonly 'Editor.getWordAtOffset2': (uid: number) => Promise<string>;
+    readonly 'Editor.getWordBefore2': (editorUid: number, rowIndex: number, columnIndex: number) => Promise<string>;
+    readonly 'Editor.updateDebugInfo': (key: string) => Promise<void>;
+}

package/dist/parts/EmbedsProcess/EmbedsProcess.d.ts

@@ -0,0 +1,17 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const createWebContentsView: (restoreId: number, fallThroughKeyBindings: any) => Promise<any>;
+export declare const disposeWebContentsView: (id: number) => Promise<void>;
+export declare const resizeWebContentsView: (id: number, x: number, y: number, width: number, height: number) => Promise<void>;
+export declare const setIframeSrcFallback: (id: number, error: any) => Promise<void>;
+export declare const focus: (id: number) => Promise<void>;
+export declare const openDevtools: (id: string) => Promise<void>;
+export declare const reload: (id: string) => Promise<void>;
+export declare const show: (id: string) => Promise<void>;
+export declare const hide: (id: string) => Promise<void>;
+export declare const forward: (id: string) => Promise<void>;
+export declare const backward: (id: string) => Promise<void>;
+export declare const getDomTree: (id: string) => Promise<void>;
+export declare const insertCss: (id: string, css: string) => Promise<void>;
+export declare const insertJavaScript: (id: string, code: string) => Promise<void>;
+export declare const inspectElement: (id: string, x: number, y: number) => Promise<void>;
+export declare const copyImageAt: (id: string, x: number, y: number) => Promise<void>;

package/dist/parts/EmbedsProcessApi/EmbedsProcessApi.d.ts

@@ -0,0 +1,30 @@
+export interface EmbedsProcessApi {
+    readonly 'ElectronWebContents.dispose': (id: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.attachEventListeners': (webContentsId: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.backward': (id: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.cancelNavigation': (id: any) => Promise<any>;
+    readonly 'ElectronWebContentsView.copyImageAt': (id: any, x: number, y: number) => Promise<void>;
+    readonly 'ElectronWebContentsView.createWebContentsView': (webContentsId: any) => Promise<any>;
+    readonly 'ElectronWebContentsView.disposeWebContentsView': (webContentsId: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.focus': (id: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.forward': (id: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.getDomTree': (id: any) => Promise<string>;
+    readonly 'ElectronWebContentsView.getStats': (id: any, keyBindings: any) => Promise<any>;
+    readonly 'ElectronWebContentsView.hide': (id: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.insertCss': (id: any, css: string) => Promise<void>;
+    readonly 'ElectronWebContentsView.insertJavaScript': (id: any, code: string) => Promise<any>;
+    readonly 'ElectronWebContentsView.inspectElement': (id: any, x: number, y: number) => Promise<void>;
+    readonly 'ElectronWebContentsView.openDevtools': (id: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.reload': (id: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.resizeBrowserView': (id: any, x: number, y: number, width: number, height: number) => Promise<void>;
+    readonly 'ElectronWebContentsView.setIframeSrc': (id: any, iframeSrc: string) => Promise<void>;
+    readonly 'ElectronWebContentsView.setIframeSrcFallback': (id: any, code: any, error: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.show': (id: any) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.getStats': (id: any, ...args: readonly any[]) => Promise<any>;
+    readonly 'ElectronWebContentsViewFunctions.resizeBrowserView': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setBackgroundColor': (webContentsId: any, backgroundColor: string) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setFallthroughKeyBindings': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setIframeSrc': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setIframeSrcFallback': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.show': (id: any, ...args: readonly any[]) => Promise<void>;
+}

package/dist/parts/ErrorWorker/ErrorWorker.d.ts

@@ -0,0 +1 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;

package/dist/parts/ErrorWorkerApi/ErrorWorkerApi.d.ts

@@ -0,0 +1,3 @@
+export interface ErrorWorkerApi {
+    readonly 'Errors.prepare': (error: any) => Promise<any>;
+}

package/dist/parts/ExtensionHost/ExtensionHost.d.ts

@@ -0,0 +1,6 @@
+import type { RuntimeStatus } from '../RuntimeStatus/RuntimeStatus.ts';
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const executeReferenceProvider: (id: number, offset: number) => Promise<readonly any[]>;
+export declare const executeFileReferenceProvider: (id: number) => Promise<readonly any[]>;
+export declare const getRuntimeStatus: (extensionId: string) => Promise<RuntimeStatus>;
+export declare const getEnabledOutputProviderIds: () => Promise<readonly string[]>;

package/dist/parts/ExtensionHostWorkerApi/ExtensionHostWorkerApi.d.ts

@@ -0,0 +1,3 @@
+export interface ExtensionHostWorkerApi {
+    readonly 'Extensions.getExtensions': () => Promise<readonly any[]>;
+}

package/dist/parts/ExtensionManagementWorker/ExtensionManagementWorker.d.ts

@@ -0,0 +1,10 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const enable: (id: string) => Promise<void>;
+export declare const enable2: (id: string, platform: number) => Promise<void>;
+export declare const disable: (id: string) => Promise<void>;
+export declare const disable2: (id: string, platform: number) => Promise<void>;
+export declare const getExtension: (id: string) => Promise<any>;
+export declare const getLanguages: (platform: number, assetDir: string) => Promise<any>;
+export declare const install: (id: string) => Promise<void>;
+export declare const uninstall: (id: string) => Promise<void>;
+export declare const invalidateExtensionsCache: () => Promise<void>;

package/dist/parts/FileSearchWorker/FileSearchWorker.d.ts

@@ -0,0 +1,2 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const showQuickInput: (options: any) => Promise<any>;

package/dist/parts/FileSystemProcess/FileSystemProcess.d.ts

@@ -0,0 +1,15 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const remove: (uri: string) => Promise<void>;
+export declare const readFile: (uri: string) => Promise<string>;
+export declare const appendFile: (uri: string, text: string) => Promise<string>;
+export declare const readDirWithFileTypes: (uri: string) => Promise<readonly any[]>;
+export declare const getPathSeparator: (root: string) => Promise<string>;
+export declare const readJson: (root: string) => Promise<any>;
+export declare const getRealPath: (path: string) => Promise<string>;
+export declare const stat: (path: string) => Promise<any>;
+export declare const writeFile: (path: string, content: string) => Promise<void>;
+export declare const mkdir: (path: string) => Promise<void>;
+export declare const rename: (oldUri: string, newUri: string) => Promise<void>;
+export declare const copy: (oldUri: string, newUri: string) => Promise<void>;
+export declare const getFolderSize: (uri: string) => Promise<void>;
+export declare const exists: (uri: string) => Promise<boolean>;

package/dist/parts/FileSystemProcessApi/FileSystemProcessApi.d.ts

@@ -0,0 +1,12 @@
+export interface FileSystemProcessApi {
+    readonly 'FileSystem.copy': (oldUri: string, newUri: string) => Promise<void>;
+    readonly 'FileSystem.getPathSeparator': () => Promise<string>;
+    readonly 'FileSystem.getRealPath': (uri: string) => Promise<string>;
+    readonly 'FileSystem.mkdir': (uri: string) => Promise<void>;
+    readonly 'FileSystem.readDirWithFileTypes': (uri: string) => Promise<readonly any[]>;
+    readonly 'FileSystem.readFile': (uri: string) => Promise<string>;
+    readonly 'FileSystem.remove': (uri: string) => Promise<void>;
+    readonly 'FileSystem.rename': (oldUri: string, newUri: string) => Promise<void>;
+    readonly 'FileSystem.stat': (uri: string) => Promise<any>;
+    readonly 'FileSystem.writeFile': (uri: string, content: string) => Promise<void>;
+}

package/dist/parts/FileSystemWorker/FileSystemWorker.d.ts

@@ -0,0 +1,18 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const remove: (dirent: string) => Promise<void>;
+export declare const readDirWithFileTypes: (uri: string) => Promise<readonly any[]>;
+export declare const getPathSeparator: (root: string) => Promise<string>;
+export declare const getRealPath: (path: string) => Promise<string>;
+export declare const stat: (dirent: string) => Promise<any>;
+export declare const createFile: (uri: string) => Promise<void>;
+export declare const readFile: (uri: string) => Promise<string>;
+export declare const writeFile: (uri: string, content: string) => Promise<void>;
+export declare const mkdir: (uri: string) => Promise<void>;
+export declare const rename: (oldUri: string, newUri: string) => Promise<void>;
+export declare const copy: (oldUri: string, newUri: string) => Promise<void>;
+export declare const exists: (uri: string) => Promise<boolean>;
+export declare const getFolderSize: (uri: string) => Promise<number>;
+export declare const readFileAsBlob: (uri: string) => Promise<Blob>;
+export declare const appendFile: (uri: string, text: string) => Promise<string>;
+export declare const watchFile: (watchId: number, uri: string, rpcId: number) => Promise<void>;
+export declare const unwatchFile: (watchId: number) => Promise<void>;

package/dist/parts/FileSystemWorkerApi/FileSystemWorkerApi.d.ts

@@ -0,0 +1,12 @@
+export interface FileSystemWorkerApi {
+    readonly 'FileSystem.copy': (oldUri: string, newUri: string) => Promise<void>;
+    readonly 'FileSystem.getPathSeparator': () => Promise<string>;
+    readonly 'FileSystem.getRealPath': (uri: string) => Promise<string>;
+    readonly 'FileSystem.mkdir': (uri: string) => Promise<void>;
+    readonly 'FileSystem.readDirWithFileTypes': (uri: string) => Promise<readonly any[]>;
+    readonly 'FileSystem.readFile': (uri: string) => Promise<string>;
+    readonly 'FileSystem.remove': (uri: string) => Promise<void>;
+    readonly 'FileSystem.rename': (oldUri: string, newUri: string) => Promise<void>;
+    readonly 'FileSystem.stat': (uri: string) => Promise<any>;
+    readonly 'FileSystem.writeFile': (uri: string, content: string) => Promise<void>;
+}

package/dist/parts/GetIpcType/GetIpcType.d.ts

@@ -0,0 +1 @@
+export declare const getIpcType: (argv: readonly string[]) => number;

package/dist/parts/IconThemeWorker/IconThemeWorker.d.ts

@@ -0,0 +1,2 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const getIcons: (iconRequests: readonly any[]) => Promise<readonly any[]>;

package/dist/parts/IpcType/IpcType.d.ts

@@ -0,0 +1,5 @@
+export declare const NodeWorker = 1;
+export declare const NodeForkedProcess = 2;
+export declare const ElectronUtilityProcess = 3;
+export declare const ElectronMessagePort = 4;
+export declare const WebSocket = 6;

package/dist/parts/LazyRpc/LazyRpc.d.ts

@@ -0,0 +1,6 @@
+import type { Rpc } from '@lvce-editor/rpc';
+export interface LazyRpc {
+    readonly invoke: (method: string, ...params: readonly any[]) => Promise<any>;
+    readonly invokeAndTransfer: (method: string, ...params: readonly any[]) => Promise<any>;
+    readonly setFactory: (value: () => Promise<Rpc>) => void;
+}

package/dist/parts/Main/Main.d.ts

@@ -0,0 +1,34 @@
+export type { Rpc, MockRpc } from '@lvce-editor/rpc';
+export * as ClipBoardProcess from '../ClipBoardProcess/ClipBoardProcess.ts';
+export * as ClipBoardWorker from '../ClipBoardWorker/ClipBoardWorker.ts';
+export * as DebugWorker from '../DebugWorker/DebugWorker.ts';
+export * as EditorWorker from '../EditorWorker/EditorWorker.ts';
+export * as EmbedsProcess from '../EmbedsProcess/EmbedsProcess.ts';
+export * as ErrorWorker from '../ErrorWorker/ErrorWorker.ts';
+export * as ExtensionHost from '../ExtensionHost/ExtensionHost.ts';
+export * as ExtensionManagementWorker from '../ExtensionManagementWorker/ExtensionManagementWorker.ts';
+export * as FileSystemProcess from '../FileSystemProcess/FileSystemProcess.ts';
+export * as FileSystemWorker from '../FileSystemWorker/FileSystemWorker.ts';
+export * as IconThemeWorker from '../IconThemeWorker/IconThemeWorker.ts';
+export * as IpcType from '../IpcType/IpcType.ts';
+export * as MainProcess from '../MainProcess/MainProcess.ts';
+export * as MarkdownWorker from '../MarkdownWorker/MarkdownWorker.ts';
+export * as FileSearchWorker from '../FileSearchWorker/FileSearchWorker.ts';
+export * as RendererProcess from '../RendererProcess/RendererProcess.ts';
+export * as RendererWorker from '../RendererWorker/RendererWorker.ts';
+export * as SourceControlWorker from '../SourceControlWorker/SourceControlWorker.ts';
+export * as OpenerWorker from '../OpenerWorker/OpenerWorker.ts';
+export * as TextMeasurementWorker from '../TextMeasurementWorker/TextMeasurementWorker.ts';
+export * as MainAreaWorker from '../MainAreaWorker/MainAreaWorker.ts';
+export { RpcId } from '@lvce-editor/constants';
+export * as SearchProcess from '../SearchProcess/SearchProcess.ts';
+export * as SharedProcess from '../SharedProcess/SharedProcess.ts';
+export * as SyntaxHighlightingWorker from '../SyntaxHighlightingWorker/SyntaxHighlightingWorker.ts';
+export * from '../CreateLazyRpc/CreateLazyRpc.ts';
+export * from '../GetIpcType/GetIpcType.ts';
+export * from '../RegisterMockRpc/RegisterMockRpc.ts';
+export * from '../RpcRegistry/RpcRegistry.ts';
+export type * from '../SearchResult/SearchResult.ts';
+export type * from '../Change/Change.ts';
+export type * from '../TextEdit/TextEdit.ts';
+export type * from '../DisposableMockRpc/DisposableMockRpc.ts';

package/dist/parts/Main/Main.js

@@ -18,6 +18,7 @@ export * as RendererWorker from "../RendererWorker/RendererWorker.js";
 export * as SourceControlWorker from "../SourceControlWorker/SourceControlWorker.js";
 export * as OpenerWorker from "../OpenerWorker/OpenerWorker.js";
 export * as TextMeasurementWorker from "../TextMeasurementWorker/TextMeasurementWorker.js";
+export * as MainAreaWorker from "../MainAreaWorker/MainAreaWorker.js";
 export { RpcId } from '@lvce-editor/constants';
 export * as SearchProcess from "../SearchProcess/SearchProcess.js";
 export * as SharedProcess from "../SharedProcess/SharedProcess.js";

package/dist/parts/MainAreaWorker/MainAreaWorker.d.ts

@@ -0,0 +1 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;

package/dist/parts/MainAreaWorker/MainAreaWorker.js

@@ -0,0 +1,4 @@
+import * as RpcFactory from "../RpcFactory/RpcFactory.js";
+const rpcId = 123_456;
+export const { dispose, invoke, invokeAndTransfer, set } = RpcFactory.create(rpcId);
+// TODO add functions

package/dist/parts/MainProcess/MainProcess.d.ts

@@ -0,0 +1 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;

package/dist/parts/MainProcessApi/MainProcessApi.d.ts

@@ -0,0 +1,15 @@
+export interface MainProcessApi {
+    readonly 'ElectronWebContents.callFunction': (webContentsId: any, method: string, ...params: readonly any[]) => Promise<any>;
+    readonly 'ElectronWebContents.dispose': (id: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.attachEventListeners': (webContentsId: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.createWebContentsView': (webContentsId: any) => Promise<any>;
+    readonly 'ElectronWebContentsView.disposeWebContentsView': (webContentsId: any) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.getStats': (id: any, ...args: readonly any[]) => Promise<any>;
+    readonly 'ElectronWebContentsViewFunctions.resizeBrowserView': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setBackgroundColor': (webContentsId: any, backgroundColor: string) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setFallthroughKeyBindings': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setIframeSrc': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setIframeSrcFallback': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.show': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'Trash.trash': (path: string) => Promise<void>;
+}

package/dist/parts/MarkdownWorker/MarkdownWorker.d.ts

@@ -0,0 +1,3 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const getVirtualDom: (html: string) => Promise<readonly any[]>;
+export declare const render: (markdown: string, options?: any) => Promise<string>;

package/dist/parts/MarkdownWorkerApi/MarkdownWorkerApi.d.ts

@@ -0,0 +1,4 @@
+export interface MarkdownWorkerApi {
+    readonly 'Markdown.getMarkDownVirtualDom': (html: string) => Promise<any>;
+    readonly 'Markdown.renderMarkdown': (markdown: string, options: any) => Promise<void>;
+}

package/dist/parts/OpenerWorker/OpenerWorker.d.ts

@@ -0,0 +1,5 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const enableMemoryOpener: () => Promise<void>;
+export declare const openExternal: (url: string) => Promise<void>;
+export declare const openUrl: (url: string) => Promise<void>;
+export declare const readOpenedUrl: () => Promise<string>;

package/dist/parts/PositionAtCursor/PositionAtCursor.d.ts

@@ -0,0 +1,6 @@
+export interface PositionAtCursor {
+    readonly columnIndex: number;
+    readonly rowIndex: number;
+    readonly x: number;
+    readonly y: number;
+}

package/dist/parts/RegisterMockRpc/RegisterMockRpc.d.ts

@@ -0,0 +1,2 @@
+import type { MockRpc } from '@lvce-editor/rpc';
+export declare const registerMockRpc: (rpcId: number, commandMap: Record<string, any>) => MockRpc;

package/dist/parts/RendererProcess/RendererProcess.d.ts

@@ -0,0 +1,4 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const readClipBoardText: () => Promise<any>;
+export declare const readClipBoard: () => Promise<any>;
+export declare const writeClipBoard: (options: any) => Promise<void>;

package/dist/parts/RendererProcessApi/RendererProcessApi.d.ts

@@ -0,0 +1,4 @@
+export interface RendererProcessApi {
+    readonly 'Debug.pause': () => Promise<void>;
+    readonly 'Debug.resume': () => Promise<void>;
+}

package/dist/parts/RendererWorker/RendererWorker.d.ts

@@ -0,0 +1,94 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const searchFileHtml: (uri: string) => Promise<readonly string[]>;
+export declare const getFilePathElectron: (file: File) => Promise<string>;
+/**
+ * @deprecated
+ */
+export declare const showContextMenu: (x: number, y: number, id: number, ...args: readonly any[]) => Promise<void>;
+export declare const showContextMenu2: (uid: number, menuId: any, x: number, y: number, args: any) => Promise<void>;
+export declare const getElectronVersion: () => Promise<string>;
+export declare const applyBulkReplacement: (bulkEdits: readonly any[]) => Promise<void>;
+export declare const setColorTheme: (id: string) => Promise<string>;
+export declare const getNodeVersion: () => Promise<string>;
+export declare const getBadgeCounts: () => Promise<string>;
+export declare const getChromeVersion: () => Promise<string>;
+export declare const getV8Version: () => Promise<string>;
+export declare const getFileHandles: (fileIds: readonly number[]) => Promise<readonly FileSystemHandle[]>;
+export declare const setWorkspacePath: (path: string) => Promise<void>;
+export declare const registerWebViewInterceptor: (id: number, port: MessagePort) => Promise<void>;
+export declare const unregisterWebViewInterceptor: (id: number) => Promise<void>;
+export declare const sendMessagePortToEditorWorker: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const sendMessagePortToOpenerWorker: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const sendMessagePortToErrorWorker: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const sendMessagePortToMarkdownWorker: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const sendMessagePortToIconThemeWorker: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const sendMessagePortToFileSystemWorker: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const readFile: (uri: string) => Promise<string>;
+export declare const getWebViewSecret: (key: string) => Promise<string>;
+export declare const setWebViewPort: (uid: number, port: MessagePort, origin: string, portType: any) => Promise<void>;
+export declare const setFocus: (key: number) => Promise<void>;
+export declare const getFileIcon: (options: any) => Promise<string>;
+export declare const getColorThemeNames: () => Promise<readonly string[]>;
+export declare const disableExtension: (id: string) => Promise<Error | undefined>;
+export declare const enableExtension: (id: string) => Promise<Error | undefined>;
+export declare const handleDebugChange: (params: any) => Promise<void>;
+export declare const getFolderIcon: (options: any) => Promise<string>;
+export declare const handleWorkspaceRefresh: () => Promise<void>;
+export declare const closeWidget: (widgetId: string | number) => Promise<void>;
+export declare const sendMessagePortToExtensionHostWorker: (port: MessagePort, rpcId?: number) => Promise<void>;
+export declare const sendMessagePortToFileSearchWorker: (port: MessagePort, rpcId?: number) => Promise<void>;
+export declare const sendMessagePortToSearchProcess: (port: MessagePort) => Promise<void>;
+export declare const confirm: (message: string, options?: any) => Promise<boolean>;
+export declare const getRecentlyOpened: () => Promise<readonly string[]>;
+export declare const getKeyBindings: () => Promise<readonly any[]>;
+export declare const writeClipBoardText: (text: string) => Promise<void>;
+export declare const readClipBoardText: () => Promise<string>;
+export declare const writeClipBoardImage: (blob: any) => Promise<void>;
+export declare const searchFileMemory: (uri: string) => Promise<void>;
+export declare const searchFileFetch: (uri: string) => Promise<readonly string[]>;
+export declare const showMessageBox: (options: any) => Promise<void>;
+export declare const handleDebugResumed: (params: any) => Promise<void>;
+export declare const openWidget: (name: string) => Promise<void>;
+export declare const getIcons: (requests: readonly any[]) => Promise<readonly string[]>;
+export declare const activateByEvent: (event: string, assetDir: string, platform: number) => Promise<void>;
+export declare const setAdditionalFocus: (focusKey: number) => Promise<void>;
+export declare const getActiveEditorId: () => Promise<number>;
+export declare const getWorkspacePath: () => Promise<string>;
+export declare const sendMessagePortToRendererProcess: (port: MessagePort) => Promise<void>;
+export declare const sendMessagePortToTextMeasurementWorker: (port: MessagePort) => Promise<void>;
+export declare const sendMessagePortToSourceControlWorker: (port: MessagePort) => Promise<void>;
+export declare const sendMessagePortToSharedProcess: (port: MessagePort) => Promise<void>;
+export declare const sendMessagePortToFileSystemProcess: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const sendMessagePortToIframeWorker: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const sendMessagePortToExtensionManagementWorker: (port: MessagePort, rpcId: number) => Promise<void>;
+export declare const getPreference: (key: string) => Promise<any>;
+export declare const getAllExtensions: () => Promise<readonly any[]>;
+export declare const rerenderEditor: (key: string) => Promise<void>;
+export declare const handleDebugPaused: (params: any) => Promise<void>;
+export declare const openUri: (uri: string, focus?: boolean, options?: any) => Promise<void>;
+export declare const sendMessagePortToSyntaxHighlightingWorker: (port: MessagePort) => Promise<void>;
+export declare const handleDebugScriptParsed: (script: any) => Promise<void>;
+export declare const getWindowId: () => Promise<number>;
+export declare const getBlob: (uri: string) => Promise<Blob>;
+export declare const getExtensionCommands: () => Promise<readonly any[]>;
+export declare const showErrorDialog: (errorInfo: any) => Promise<void>;
+export declare const getFolderSize: (uri: string) => Promise<number>;
+export declare const getExtension: (id: string) => Promise<any>;
+export declare const getMarkdownDom: (html: string) => Promise<any>;
+export declare const renderMarkdown: (markdown: string, options: any) => Promise<any>;
+export declare const openNativeFolder: (uri: string) => Promise<void>;
+export declare const uninstallExtension: (id: string) => Promise<void>;
+export declare const installExtension: (id: string) => Promise<void>;
+export declare const minimizeWindow: () => Promise<void>;
+export declare const unmaximizeWindow: () => Promise<void>;
+export declare const maximizeWindow: () => Promise<void>;
+export declare const closeWindow: () => Promise<void>;
+export declare const openExtensionSearch: () => Promise<void>;
+export declare const setExtensionsSearchValue: (searchValue: string) => Promise<void>;
+export declare const openExternal: (uri: string) => Promise<void>;
+export declare const openUrl: (uri: string) => Promise<void>;
+export declare const getAllPreferences: () => Promise<any>;
+export declare const showSaveFilePicker: () => Promise<string>;
+export declare const getLogsDir: () => Promise<string>;
+export declare const measureTextBlockHeight: (actualInput: string, fontFamily: string, fontSize: number, lineHeightPx: number, width: number) => Promise<number>;
+export declare const refreshOutput: () => Promise<void>;

package/dist/parts/RendererWorkerApi/RendererWorkerApi.d.ts

@@ -0,0 +1,277 @@
+import type { BulkReplacementEdit } from '../BulkReplacementEdit/BulkReplacementEdit.ts';
+import type { ConfirmPromptOptions } from '../ConfirmPromptOptions/ConfirmPromptOptions.ts';
+import type { SearchResult } from '../SearchResult/SearchResult.ts';
+export interface RendererWorkerApi {
+    readonly 'About.focusNext': () => Promise<void>;
+    readonly 'About.focusPrevious': () => Promise<void>;
+    readonly 'About.handleClickClose': () => Promise<void>;
+    readonly 'About.handleClickCopy': () => Promise<void>;
+    readonly 'About.handleClickOk': () => Promise<void>;
+    readonly 'About.showAbout': () => Promise<void>;
+    readonly 'ActivityBar.focus': () => Promise<void>;
+    readonly 'ActivityBar.focusFirst': () => Promise<void>;
+    readonly 'ActivityBar.focusLast': () => Promise<void>;
+    readonly 'ActivityBar.focusNext': () => Promise<void>;
+    readonly 'ActivityBar.focusPrevious': () => Promise<void>;
+    readonly 'ActivityBar.handleClick': (index: number) => Promise<void>;
+    readonly 'ActivityBar.handleContextMenu': () => Promise<void>;
+    readonly 'ActivityBar.selectCurrent': () => Promise<void>;
+    readonly 'BulkReplacement.applyBulkReplacement': (edits: readonly BulkReplacementEdit[]) => Promise<void>;
+    readonly 'ClipBoard.readNativeFiles': () => Promise<readonly string[]>;
+    readonly 'ClipBoard.readText': () => Promise<string>;
+    readonly 'ClipBoard.writeNativeFiles': (type: string, files: readonly string[]) => Promise<void>;
+    readonly 'ClipBoard.writeText': (text: string) => Promise<void>;
+    readonly 'ColorTheme.getColorThemeNames': () => Promise<readonly string[]>;
+    readonly 'ColorTheme.setColorTheme': (id: string) => Promise<void>;
+    readonly 'ConfirmPrompt.prompt': (confirmText: string, options: ConfirmPromptOptions) => Promise<boolean>;
+    readonly 'ContextMenu.show': (x: number, y: number, id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'Develop.openCacheFolder': () => Promise<void>;
+    readonly 'Develop.openConfigFolder': () => Promise<void>;
+    readonly 'Develop.openIframeInspector': () => Promise<void>;
+    readonly 'Develop.openLogsFolder': () => Promise<void>;
+    readonly 'Develop.openProcessExplorer': () => Promise<void>;
+    readonly 'Develop.reloadColorTheme': () => Promise<void>;
+    readonly 'Develop.toggleDeveloperTools': () => Promise<void>;
+    readonly 'Editor.addAllMissingImports': () => Promise<void>;
+    readonly 'Editor.braceCompletion': (text: string) => Promise<void>;
+    readonly 'Editor.closeColorPicker': () => Promise<void>;
+    readonly 'Editor.closeCompletion': () => Promise<void>;
+    readonly 'Editor.contextMenu': (button: number, x: number, y: number) => Promise<void>;
+    readonly 'Editor.copy': () => Promise<void>;
+    readonly 'Editor.copyLineDown': () => Promise<void>;
+    readonly 'Editor.copyLineUp': () => Promise<void>;
+    readonly 'Editor.cursorCharacterLeft': () => Promise<void>;
+    readonly 'Editor.cursorCharacterRight': () => Promise<void>;
+    readonly 'Editor.cursorDown': () => Promise<void>;
+    readonly 'Editor.cursorEnd': () => Promise<void>;
+    readonly 'Editor.cursorHome': () => Promise<void>;
+    readonly 'Editor.cursorSet': (rowIndex: number, columnIndex: number) => Promise<void>;
+    readonly 'Editor.cursorUp': () => Promise<void>;
+    readonly 'Editor.cursorWordLeft': () => Promise<void>;
+    readonly 'Editor.cursorWordPartLeft': () => Promise<void>;
+    readonly 'Editor.cursorWordPartRight': () => Promise<void>;
+    readonly 'Editor.cursorWordRight': () => Promise<void>;
+    readonly 'Editor.deleteAllLeft': () => Promise<void>;
+    readonly 'Editor.deleteAllRight': () => Promise<void>;
+    readonly 'Editor.format': () => Promise<void>;
+    readonly 'Editor.getText': () => Promise<string>;
+    readonly 'Editor.goToDefinition': () => Promise<void>;
+    readonly 'Editor.goToTypeDefinition': () => Promise<void>;
+    readonly 'Editor.handleContextMenu': (x: number, y: number) => Promise<void>;
+    readonly 'Editor.insertLineBreak': () => Promise<void>;
+    readonly 'Editor.openColorPicker': () => Promise<void>;
+    readonly 'Editor.openCompletion': () => Promise<void>;
+    readonly 'Editor.openFind': () => Promise<void>;
+    readonly 'Editor.openRename': () => Promise<void>;
+    readonly 'Editor.organizeImports': () => Promise<void>;
+    readonly 'Editor.rename': () => Promise<void>;
+    readonly 'Editor.setDeltaY': (deltaY: number) => Promise<void>;
+    readonly 'Editor.setSelections': (selections: any) => Promise<void>;
+    readonly 'Editor.showHover2': () => Promise<void>;
+    readonly 'Editor.showSourceActions2': () => Promise<void>;
+    readonly 'Editor.sortImports': () => Promise<void>;
+    readonly 'Editor.tabCompletion': () => Promise<void>;
+    readonly 'Editor.toggleBlockComment': () => Promise<void>;
+    readonly 'Editor.toggleLineComment': () => Promise<void>;
+    readonly 'Editor.type': (text: string) => Promise<void>;
+    readonly 'EditorCompletion.closeDetais': () => Promise<void>;
+    readonly 'EditorCompletion.openDetails': () => Promise<void>;
+    readonly 'EditorCompletion.selectCurrentIndex': () => Promise<void>;
+    readonly 'EditorCompletion.selectIndex': (index: number) => Promise<void>;
+    readonly 'EditorSourceActions.selectCurrent': () => Promise<void>;
+    readonly 'ElectronDialog.showMessageBox': (options: any) => Promise<any>;
+    readonly 'ElectronWindow.close': () => Promise<void>;
+    readonly 'ElectronWindow.maximize': () => Promise<void>;
+    readonly 'ElectronWindow.minimize': () => Promise<void>;
+    readonly 'ElectronWindow.unmaximize': () => Promise<void>;
+    readonly 'ErrorHandling.showErrorDialog': (errorInfo: any) => Promise<void>;
+    readonly 'Explorer.acceptEdit': () => Promise<void>;
+    readonly 'Explorer.cancelEdit': () => Promise<void>;
+    readonly 'Explorer.cancelTypeAhead': () => Promise<void>;
+    readonly 'Explorer.expandAll': () => Promise<void>;
+    readonly 'Explorer.expandRecursively': () => Promise<void>;
+    readonly 'Explorer.focus': () => Promise<void>;
+    readonly 'Explorer.focusFirst': () => Promise<void>;
+    readonly 'Explorer.focusIndex': (index: number) => Promise<void>;
+    readonly 'Explorer.focusLast': () => Promise<void>;
+    readonly 'Explorer.handleArrowLeft': () => Promise<void>;
+    readonly 'Explorer.handleBlur': () => Promise<void>;
+    readonly 'Explorer.handleClick': (index: number) => Promise<void>;
+    readonly 'Explorer.handleClickAt': (preventDefault: boolean, button: number, ctrlKey: number, shiftKey: number, x: number, y: number) => Promise<void>;
+    readonly 'Explorer.handleClickCurrent': () => Promise<void>;
+    readonly 'Explorer.handleContextMenuKeyboard': () => Promise<void>;
+    readonly 'Explorer.handleDragLeave': () => Promise<void>;
+    readonly 'Explorer.handleDragOver': (x: number, y: number) => Promise<void>;
+    readonly 'Explorer.handleDrop': (x: number, y: number, fileIds: readonly number[], fileList: FileList | readonly File[]) => Promise<void>;
+    readonly 'Explorer.handleInputBlur': () => Promise<void>;
+    readonly 'Explorer.handleKeyDown': (key: string) => Promise<void>;
+    readonly 'Explorer.newFile': () => Promise<void>;
+    readonly 'Explorer.newFolder': () => Promise<void>;
+    readonly 'Explorer.refresh': () => Promise<void>;
+    readonly 'Explorer.removeDirent': () => Promise<void>;
+    readonly 'Explorer.rename': () => Promise<void>;
+    readonly 'Explorer.renameDirent': () => Promise<void>;
+    readonly 'Explorer.selectAll': () => Promise<void>;
+    readonly 'Explorer.selectDown': () => Promise<void>;
+    readonly 'Explorer.selectIndices': (indices: readonly number[]) => Promise<void>;
+    readonly 'Explorer.selectUp': () => Promise<void>;
+    readonly 'Explorer.updateEditingValue': (value: string) => Promise<void>;
+    readonly 'ExtensionDetail.open': (eextensionId: string) => Promise<void>;
+    readonly 'ExtensionDetail.selectFeature': (name: string) => Promise<void>;
+    readonly 'ExtensionDetail.selectTab': (name: string) => Promise<void>;
+    readonly 'ExtensionHost.executeCommand': (id: string) => Promise<void>;
+    readonly 'ExtensionHost.getCommands': () => Promise<readonly any[]>;
+    readonly 'ExtensionHost.searchFileWithFetch': (uri: string) => Promise<readonly string[]>;
+    readonly 'ExtensionHost.searchFileWithHtml': (uri: string) => Promise<readonly string[]>;
+    readonly 'ExtensionHost.searchFileWithMemory': (uri: string) => Promise<readonly string[]>;
+    readonly 'ExtensionHostManagement.activateByEvent': (event: string) => Promise<void>;
+    readonly 'ExtensionHostTextSearch.executeTextSearchProvider': (scheme: string, query: string) => Promise<readonly SearchResult[]>;
+    readonly 'ExtensionHostTextSearch.textSearchFetch': (scheme: string, root: string, query: string, options: any, assetDir: string) => Promise<readonly SearchResult[]>;
+    readonly 'ExtensionHostTextSearch.textSearchHtml': (scheme: string, root: string, query: string) => Promise<readonly SearchResult[]>;
+    readonly 'ExtensionHostTextSearch.textSearchMemory': (scheme: string, root: string, query: string, options: any, assetDir: string) => Promise<readonly SearchResult[]>;
+    readonly 'ExtensionManagement.disable': (id: string) => Promise<void>;
+    readonly 'ExtensionManagement.getAllExtensions': () => Promise<readonly any[]>;
+    readonly 'ExtensionManagement.getExtension': (id: string) => Promise<any>;
+    readonly 'ExtensionManagement.uninstall': (id: string) => Promise<void>;
+    readonly 'ExtensionMeta.addNodeExtension': (absolutePath: string) => Promise<void>;
+    readonly 'ExtensionMeta.addWebExtension': (absolutePath: string) => Promise<void>;
+    readonly 'FileSystem.copy': (oldUri: string, newUri: string) => Promise<void>;
+    readonly 'FileSystem.createFile': (uri: string) => Promise<void>;
+    readonly 'FileSystem.getFolderSize': (uri: string) => Promise<number>;
+    readonly 'FileSystem.getPathSeparator': (root: string) => Promise<string>;
+    readonly 'FileSystem.getRealPath': (root: string) => Promise<string>;
+    readonly 'FileSystem.mkdir': (uri: string) => Promise<void>;
+    readonly 'FileSystem.readDirWithFileTypes': (uri: string) => Promise<readonly any[]>;
+    readonly 'FileSystem.readFile': (uri: string) => Promise<string>;
+    readonly 'FileSystem.remove': (uri: string) => Promise<void>;
+    readonly 'FileSystem.rename': (oldUri: string, newUri: string) => Promise<void>;
+    readonly 'FileSystem.stat': (root: string) => Promise<any>;
+    readonly 'FileSystem.writeFile': (uri: string, content: string) => Promise<void>;
+    readonly 'FileSystemHandle.getFileHandles': (fileIds: readonly number[]) => Promise<readonly FileSystemHandle[]>;
+    readonly 'FileSystemHandle.getFilePathElectron': (file: File) => Promise<string>;
+    readonly 'FindWidget.focusNext': () => Promise<void>;
+    readonly 'FindWidget.handleInput': (value: string) => Promise<void>;
+    readonly 'Focus.setFocus': (focusId: number) => Promise<void>;
+    readonly 'Format.format': (editor: any) => Promise<any>;
+    readonly 'GetEditorSourceActions.getEditorSourceActions': () => Promise<any>;
+    readonly 'GetWindowId.getWindowId': () => Promise<number>;
+    readonly 'IconTheme.getFileIcon': (options: any) => Promise<string>;
+    readonly 'IconTheme.getFolderIcon': (options: any) => Promise<string>;
+    readonly 'IconTheme.getIcons': (request: readonly any[]) => Promise<readonly string[]>;
+    readonly 'IconTheme.setIconTheme': (id: string) => Promise<readonly string[]>;
+    readonly 'IframeInspector.focusFirst': () => Promise<void>;
+    readonly 'IframeInspector.focusLast': () => Promise<void>;
+    readonly 'IframeInspector.focusNext': () => Promise<void>;
+    readonly 'IframeInspector.focusPrevious': () => Promise<void>;
+    readonly 'IframeInspector.selectIndex': (index: number) => Promise<void>;
+    readonly 'IpcParent.create': (options: any) => Promise<void>;
+    readonly 'KeyBindings.addKeyBinding': () => Promise<void>;
+    readonly 'KeyBindings.changeWhenExpression': () => Promise<void>;
+    readonly 'KeyBindings.clearInput': () => Promise<void>;
+    readonly 'KeyBindings.copyCommandId': () => Promise<void>;
+    readonly 'KeyBindings.copyCommandTitle': () => Promise<void>;
+    readonly 'KeyBindings.focusFirst': () => Promise<void>;
+    readonly 'KeyBindings.focusLast': () => Promise<void>;
+    readonly 'KeyBindings.focusNext': () => Promise<void>;
+    readonly 'KeyBindings.focusPrevious': () => Promise<void>;
+    readonly 'KeyBindings.handleClick': (x: number, y: number) => Promise<void>;
+    readonly 'KeyBindings.handleContextMenu': (button: number, x: number, y: number) => Promise<void>;
+    readonly 'KeyBindings.handleDoubleClick': (x: number, y: number) => Promise<void>;
+    readonly 'KeyBindings.handleInput': (value: string) => Promise<void>;
+    readonly 'KeyBindings.handleWheel': (deltaMode: number, deltaY: number) => Promise<void>;
+    readonly 'KeyBindings.removeKeyBinding': () => Promise<void>;
+    readonly 'KeyBindings.resetKeyBinding': () => Promise<void>;
+    readonly 'KeyBindings.showSameKeyBindings': () => Promise<void>;
+    readonly 'KeyBindings.sortByPrecedence': () => Promise<void>;
+    readonly 'KeyBindings.startRecordingKeys': () => Promise<void>;
+    readonly 'KeyBindings.stopRecordingKeys': () => Promise<void>;
+    readonly 'KeyBindings.toggleRecordingKeys': () => Promise<void>;
+    readonly 'KeyBindingsInitial.getKeyBindings': () => Promise<readonly any[]>;
+    readonly 'Layout.hideSideBar': () => Promise<void>;
+    readonly 'Layout.showPanel': (id: string) => Promise<void>;
+    readonly 'Main.closeActiveEditor': () => Promise<void>;
+    readonly 'Main.closeAllEditors': () => Promise<void>;
+    readonly 'Main.closeOthers': () => Promise<void>;
+    readonly 'Main.closeTabsLeft': () => Promise<void>;
+    readonly 'Main.closeTabsRight': () => Promise<void>;
+    readonly 'Main.focusFirst': () => Promise<void>;
+    readonly 'Main.focusLast': () => Promise<void>;
+    readonly 'Main.focusNext': () => Promise<void>;
+    readonly 'Main.focusPrevious': () => Promise<void>;
+    readonly 'Main.openKeyBindings': () => Promise<void>;
+    readonly 'Main.openUri': (uri: string, focus?: boolean, props?: any) => Promise<void>;
+    readonly 'Main.splitRight': () => Promise<void>;
+    readonly 'Markdown.renderMarkdown': (markdown: string, options: any) => Promise<string>;
+    readonly 'Menu.selectItem': (text: string) => Promise<void>;
+    readonly 'MouseActions.get': (uid: number, button: number, modifiers: any) => Promise<any>;
+    readonly 'OpenNativeFolder.openNativeFolder': (path: string) => Promise<void>;
+    readonly 'Preferences.get': (key: string) => Promise<any>;
+    readonly 'Process.getChromeVersion': () => Promise<string>;
+    readonly 'Process.getElectronVersion': () => Promise<string>;
+    readonly 'Process.getNodeVersion': () => Promise<string>;
+    readonly 'Process.getV8Version': () => Promise<string>;
+    readonly 'RecentlyOpened.getRecentlyOpened': () => Promise<readonly string[]>;
+    readonly 'Run And Debug.handlePaused': (params: any) => Promise<void>;
+    readonly 'Run And Debug.handleResumed': (params: any) => Promise<void>;
+    readonly 'Run And Debug.handleScriptParsed': (params: any) => Promise<void>;
+    readonly 'Search.clearSearchResults': () => Promise<void>;
+    readonly 'Search.collapseDetails': () => Promise<void>;
+    readonly 'Search.dismissItem': () => Promise<void>;
+    readonly 'Search.focusFirst': () => Promise<void>;
+    readonly 'Search.focusIndex': (index: number) => Promise<void>;
+    readonly 'Search.focusNext': () => Promise<void>;
+    readonly 'Search.focusNextPage': () => Promise<void>;
+    readonly 'Search.focusPrevious': () => Promise<void>;
+    readonly 'Search.focusPreviousPage': () => Promise<void>;
+    readonly 'Search.handleExcludeInput': (value: string) => Promise<void>;
+    readonly 'Search.handleInput': (value: string) => Promise<void>;
+    readonly 'Search.handleReplaceInput': (value: string) => Promise<void>;
+    readonly 'Search.handleWheel': (deltaMode: number, deltaY: number) => Promise<void>;
+    readonly 'Search.openDetails': () => Promise<void>;
+    readonly 'Search.replaceAll': () => Promise<void>;
+    readonly 'Search.selectIndex': (index: number) => Promise<void>;
+    readonly 'Search.setIncludeValue': (value: string) => Promise<void>;
+    readonly 'Search.toggleMatchCase': () => Promise<void>;
+    readonly 'Search.toggleMatchWholeWord': () => Promise<void>;
+    readonly 'Search.togglePreserveCase': () => Promise<void>;
+    readonly 'Search.toggleReplace': () => Promise<void>;
+    readonly 'Search.toggleSearchDetails': () => Promise<void>;
+    readonly 'Search.toggleUseRegularExpression': () => Promise<void>;
+    readonly 'SearchProcess.invoke': (command: string, ...args: readonly any[]) => Promise<any>;
+    readonly 'SendMessagePortToElectron.sendMessagePortToElectron': (port: MessagePort, command: string) => Promise<void>;
+    readonly 'SendMessagePortToExtensionHostWorker.sendMessagePortToExtensionHostWorker': (port: MessagePort, initialCommand: string, rpcId: number) => Promise<void>;
+    readonly 'SendMessagePortToExtensionHostWorker.sendMessagePortToSharedProcess': (port: MessagePort, outerCommand: string, rpcId: number) => Promise<void>;
+    readonly 'SendMessagePortToFileSystemProcess.sendMessagePortToFileSystemProcess': (port: MessagePort, outerCommand: string, rpcId: number) => Promise<void>;
+    readonly 'SideBar.openViewlet': (id: string) => Promise<void>;
+    readonly 'SideBar.show': (id: string, focus?: boolean) => Promise<void>;
+    readonly 'Source Control.acceptInput': () => Promise<void>;
+    readonly 'Source Control.handleClickSourceControlButtons': (index: number, name: string) => Promise<void>;
+    readonly 'Source Control.handleInput': (text: string) => Promise<void>;
+    readonly 'Source Control.selectIndex': (index: number) => Promise<void>;
+    readonly 'StatusBar.updateStatusBarItems': () => Promise<void>;
+    readonly 'TitleBarMenuBar.closeMenu': () => Promise<void>;
+    readonly 'TitleBarMenuBar.focus': () => Promise<void>;
+    readonly 'TitleBarMenuBar.focusFirst': () => Promise<void>;
+    readonly 'TitleBarMenuBar.focusIndex': () => Promise<void>;
+    readonly 'TitleBarMenuBar.focusLast': () => Promise<void>;
+    readonly 'TitleBarMenuBar.focusNext': () => Promise<void>;
+    readonly 'TitleBarMenuBar.focusPrevious': () => Promise<void>;
+    readonly 'TitleBarMenuBar.handleKeyArrowDown': () => Promise<void>;
+    readonly 'TitleBarMenuBar.handleKeyArrowLeft': () => Promise<void>;
+    readonly 'TitleBarMenuBar.handleKeyArrowRight': () => Promise<void>;
+    readonly 'TitleBarMenuBar.handleKeyArrowUp': () => Promise<void>;
+    readonly 'TitleBarMenuBar.handleKeyEnd': () => Promise<void>;
+    readonly 'TitleBarMenuBar.handleKeyEscape': () => Promise<void>;
+    readonly 'TitleBarMenuBar.handleKeyHome': () => Promise<void>;
+    readonly 'TitleBarMenuBar.handleKeySpace': () => Promise<void>;
+    readonly 'TitleBarMenuBar.toggleIndex': (index: number) => Promise<void>;
+    readonly 'TitleBarMenuBar.toggleMenu': () => Promise<void>;
+    readonly 'Viewlet.closeWidget': (id: number | string) => Promise<void>;
+    readonly 'Viewlet.openWidget': (widgetId: string) => Promise<string>;
+    readonly 'WebView.getWebViewInfo2': (id: string) => Promise<any>;
+    readonly 'WebView.registerInterceptor': (id: number, port: MessagePort) => Promise<void>;
+    readonly 'WebView.setPort': (id: number, port: MessagePort, origin: string, portType: string) => Promise<void>;
+    readonly 'WebView.unregisterInterceptor': (id: number) => Promise<void>;
+    readonly 'Workspace.getPath': () => Promise<string>;
+    readonly 'Workspace.setPath': (uri: string) => Promise<void>;
+}

package/dist/parts/RpcFactory/RpcFactory.d.ts

@@ -0,0 +1,2 @@
+import type { RpcFactoryResult } from '../RpcFactoryResult/RpcFactoryResult.ts';
+export declare const create: (rpcId: number) => RpcFactoryResult;

package/dist/parts/RpcFactoryResult/RpcFactoryResult.d.ts

@@ -0,0 +1,9 @@
+import type { Rpc } from '@lvce-editor/rpc';
+import type { DisposableMockRpc } from '../DisposableMockRpc/DisposableMockRpc.ts';
+export interface RpcFactoryResult {
+    readonly dispose: () => Promise<void>;
+    readonly invoke: (method: string, ...params: readonly unknown[]) => Promise<any>;
+    readonly invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>;
+    readonly registerMockRpc: (commandMap: Record<string, any>) => DisposableMockRpc;
+    readonly set: (rpc: Rpc) => void;
+}

package/dist/parts/RpcRegistry/RpcRegistry.d.ts

@@ -0,0 +1,4 @@
+import type { Rpc } from '@lvce-editor/rpc';
+export declare const set: (id: number, rpc: Rpc) => void;
+export declare const get: (id: number) => Rpc;
+export declare const remove: (id: number) => void;

package/dist/parts/RuntimeStatus/RuntimeStatus.d.ts

@@ -0,0 +1,7 @@
+export interface RuntimeStatus {
+    readonly activationEvent: string;
+    readonly activationTime: number;
+    readonly id: string;
+    readonly importTime: number;
+    readonly status: number;
+}

package/dist/parts/SearchProcess/SearchProcess.d.ts

@@ -0,0 +1,4 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const search: (options: any) => Promise<any>;
+export declare const searchIncremental: (options: any) => Promise<any>;
+export declare const getIncrementalResults: (searchId: string, minLineY: number, maxLineY: number) => Promise<any>;

package/dist/parts/SearchProcessApi/SearchProcessApi.d.ts

@@ -0,0 +1,4 @@
+import type { SearchResult } from '../SearchResult/SearchResult.ts';
+export interface SearchProcessApi {
+    readonly 'TextSearch.search': (options: any) => Promise<readonly SearchResult[]>;
+}

package/dist/parts/SearchResult/SearchResult.d.ts

@@ -0,0 +1,7 @@
+export interface SearchResult {
+    readonly end: number;
+    readonly lineNumber: number;
+    readonly start: number;
+    readonly text: string;
+    readonly type: number;
+}

package/dist/parts/SharedProcess/SharedProcess.d.ts

@@ -0,0 +1 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;

package/dist/parts/SharedProcessApi/SharedProcessApi.d.ts

@@ -0,0 +1,14 @@
+export interface SharedProcessApi {
+    readonly 'ElectronWebContents.callFunction': (webContentsId: any, method: string, ...params: readonly any[]) => Promise<any>;
+    readonly 'ElectronWebContents.dispose': (id: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.attachEventListeners': (webContentsId: any) => Promise<void>;
+    readonly 'ElectronWebContentsView.createWebContentsView': (webContentsId: any) => Promise<any>;
+    readonly 'ElectronWebContentsView.disposeWebContentsView': (webContentsId: any) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.getStats': (id: any, ...args: readonly any[]) => Promise<any>;
+    readonly 'ElectronWebContentsViewFunctions.resizeBrowserView': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setBackgroundColor': (webContentsId: any, backgroundColor: string) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setFallthroughKeyBindings': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setIframeSrc': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.setIframeSrcFallback': (id: any, ...args: readonly any[]) => Promise<void>;
+    readonly 'ElectronWebContentsViewFunctions.show': (id: any, ...args: readonly any[]) => Promise<void>;
+}

package/dist/parts/SourceControlWorker/SourceControlWorker.d.ts

@@ -0,0 +1 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;

package/dist/parts/SyntaxHighlightingWorker/SyntaxHighlightingWorker.d.ts

@@ -0,0 +1 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;

package/dist/parts/SyntaxHighlightingWorkerApi/SyntaxHighlightingWorkerApi.d.ts

@@ -0,0 +1,8 @@
+export interface SyntaxHighlightingWorkerApi {
+    readonly 'GetTokensViewport.getTokensViewport': (editor: any, startLineIndex: number, endLineIndex: number, hasLinesToSend: boolean, id: number, linesToSend: readonly any[]) => Promise<any>;
+    readonly 'HandleMessagePort.handleMessagePort': (port: MessagePort) => Promise<void>;
+    readonly 'TextDocument.setLines': (documentId: string, lines: readonly string[]) => Promise<void>;
+    readonly 'Tokenizer.load': (languageId: string, tokenizePath: string) => Promise<void>;
+    readonly 'Tokenizer.tokenizeCodeBlock': (codeBlock: string, languageId: string, tokenizerPath: string) => Promise<any>;
+    readonly 'Tokenizer.tokenizeIncremental': (id: any, languageId: string, oldLine: string, newLine: string, rowIndex: number, minLineY: number) => any[] | undefined;
+}

package/dist/parts/TextEdit/TextEdit.d.ts

@@ -0,0 +1,7 @@
+export interface TextEdit {
+    readonly endColumnIndex: number;
+    readonly endRowIndex: number;
+    readonly startColumnIndex: number;
+    readonly startRowIndex: number;
+    readonly text: string;
+}

package/dist/parts/TextMeasurementWorker/TextMeasurementWorker.d.ts

@@ -0,0 +1,3 @@
+export declare const dispose: () => Promise<void>, invoke: (method: string, ...params: readonly unknown[]) => Promise<any>, invokeAndTransfer: (method: string, ...params: readonly unknown[]) => Promise<any>, registerMockRpc: (commandMap: Record<string, any>) => import("../DisposableMockRpc/DisposableMockRpc.ts").DisposableMockRpc, set: (rpc: import("@lvce-editor/rpc").Rpc) => void;
+export declare const measureTextWidth: (text: string, fontWeight: number, fontSize: number, fontFamily: string, letterSpacing: number, isMonoSpaceFont: boolean, charWidth: number) => Promise<number>;
+export declare const measureTextWidths: (texts: readonly string[], fontWeight: number, fontSize: number, fontFamily: string, letterSpacing: number, isMonoSpaceFont: boolean, charWidth: number) => Promise<readonly number[]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/rpc-registry",
-  "version": "8.0.0",
+  "version": "8.2.0",
   "description": "Rpc Registry",
   "repository": {
     "type": "git",