@lvce-editor/rpc-registry 2.30.0 → 2.32.0

package/dist/index.d.ts

@@ -2,11 +2,23 @@
 
 import { Rpc } from '@lvce-editor/rpc';
 
+export interface ClipBoardProcessApi {
+	readonly "ClipBoard.writeText": (text: string) => Promise<void>;
+	readonly "ClipBoard.readNativeFiles": () => Promise<any>;
+	readonly "ClipBoard.writeNativeFiles": (type: string, files: readonly string[]) => Promise<void>;
+}
+declare const invoke: <T extends keyof ClipBoardProcessApi>(method: T, ...params: Parameters<ClipBoardProcessApi[T]>) => ReturnType<ClipBoardProcessApi[T]>, invokeAndTransfer: <T extends keyof ClipBoardProcessApi>(method: T, ...params: Parameters<ClipBoardProcessApi[T]>) => ReturnType<ClipBoardProcessApi[T]>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose: () => Promise<void>;
+export interface ClipBoardWorkerApi {
+	readonly "ClipBoard.writeText": (text: string) => Promise<void>;
+	readonly "ClipBoard.readNativeFiles": () => Promise<any>;
+	readonly "ClipBoard.writeNativeFiles": (type: string, files: readonly string[]) => Promise<void>;
+}
+declare const invoke$1: <T extends keyof ClipBoardWorkerApi>(method: T, ...params: Parameters<ClipBoardWorkerApi[T]>) => ReturnType<ClipBoardWorkerApi[T]>, invokeAndTransfer$1: <T extends keyof ClipBoardWorkerApi>(method: T, ...params: Parameters<ClipBoardWorkerApi[T]>) => ReturnType<ClipBoardWorkerApi[T]>, set$1: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$1: () => Promise<void>;
 export interface DebugWorkerApi {
 	readonly "Debug.pause": () => Promise<void>;
 	readonly "Debug.resume": () => Promise<void>;
 }
-declare const invoke: <T extends keyof DebugWorkerApi>(method: T, ...params: Parameters<DebugWorkerApi[T]>) => ReturnType<DebugWorkerApi[T]>, invokeAndTransfer: <T extends keyof DebugWorkerApi>(method: T, ...params: Parameters<DebugWorkerApi[T]>) => ReturnType<DebugWorkerApi[T]>, set: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose: () => Promise<void>;
+declare const invoke$2: <T extends keyof DebugWorkerApi>(method: T, ...params: Parameters<DebugWorkerApi[T]>) => ReturnType<DebugWorkerApi[T]>, invokeAndTransfer$2: <T extends keyof DebugWorkerApi>(method: T, ...params: Parameters<DebugWorkerApi[T]>) => ReturnType<DebugWorkerApi[T]>, set$2: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$2: () => Promise<void>;
 export interface PositionAtCursor {
 	readonly x: number;
 	readonly y: number;
@@ -22,7 +34,7 @@ export interface EditorWorkerApi {
 	readonly "Editor.getSelections2": (editorUid: number) => Promise<readonly number[]>;
 	readonly "Editor.updateDebugInfo": (key: string) => Promise<void>;
 }
-declare const invoke$1: <T extends keyof EditorWorkerApi>(method: T, ...params: Parameters<EditorWorkerApi[T]>) => ReturnType<EditorWorkerApi[T]>, invokeAndTransfer$1: <T extends keyof EditorWorkerApi>(method: T, ...params: Parameters<EditorWorkerApi[T]>) => ReturnType<EditorWorkerApi[T]>, set$1: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$1: () => Promise<void>;
+declare const invoke$3: <T extends keyof EditorWorkerApi>(method: T, ...params: Parameters<EditorWorkerApi[T]>) => ReturnType<EditorWorkerApi[T]>, invokeAndTransfer$3: <T extends keyof EditorWorkerApi>(method: T, ...params: Parameters<EditorWorkerApi[T]>) => ReturnType<EditorWorkerApi[T]>, set$3: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$3: () => Promise<void>;
 export interface EmbedsProcessApi {
 	readonly "ElectronWebContents.dispose": (id: any) => Promise<void>;
 	readonly "ElectronWebContentsView.attachEventListeners": (webContentsId: any) => Promise<void>;
@@ -53,15 +65,15 @@ export interface EmbedsProcessApi {
 	readonly "ElectronWebContentsViewFunctions.setIframeSrcFallback": (id: any, ...args: readonly any[]) => Promise<void>;
 	readonly "ElectronWebContentsViewFunctions.show": (id: any, ...args: readonly any[]) => Promise<void>;
 }
-declare const invoke$2: <T extends keyof EmbedsProcessApi>(method: T, ...params: Parameters<EmbedsProcessApi[T]>) => ReturnType<EmbedsProcessApi[T]>, invokeAndTransfer$2: <T extends keyof EmbedsProcessApi>(method: T, ...params: Parameters<EmbedsProcessApi[T]>) => ReturnType<EmbedsProcessApi[T]>, set$2: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$2: () => Promise<void>;
+declare const invoke$4: <T extends keyof EmbedsProcessApi>(method: T, ...params: Parameters<EmbedsProcessApi[T]>) => ReturnType<EmbedsProcessApi[T]>, invokeAndTransfer$4: <T extends keyof EmbedsProcessApi>(method: T, ...params: Parameters<EmbedsProcessApi[T]>) => ReturnType<EmbedsProcessApi[T]>, set$4: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$4: () => Promise<void>;
 export interface ErrorWorkerApi {
 	readonly "Errors.prepare": (error: any) => Promise<any>;
 }
-declare const invoke$3: <T extends "Errors.prepare">(method: T, ...params: Parameters<ErrorWorkerApi[T]>) => ReturnType<ErrorWorkerApi[T]>, invokeAndTransfer$3: <T extends "Errors.prepare">(method: T, ...params: Parameters<ErrorWorkerApi[T]>) => ReturnType<ErrorWorkerApi[T]>, set$3: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$3: () => Promise<void>;
+declare const invoke$5: <T extends "Errors.prepare">(method: T, ...params: Parameters<ErrorWorkerApi[T]>) => ReturnType<ErrorWorkerApi[T]>, invokeAndTransfer$5: <T extends "Errors.prepare">(method: T, ...params: Parameters<ErrorWorkerApi[T]>) => ReturnType<ErrorWorkerApi[T]>, set$5: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$5: () => Promise<void>;
 export interface ExtensionHostWorkerApi {
 	readonly "Extensions.getExtensions": () => Promise<readonly any[]>;
 }
-declare const invoke$4: <T extends "Extensions.getExtensions">(method: T, ...params: Parameters<ExtensionHostWorkerApi[T]>) => ReturnType<ExtensionHostWorkerApi[T]>, invokeAndTransfer$4: <T extends "Extensions.getExtensions">(method: T, ...params: Parameters<ExtensionHostWorkerApi[T]>) => ReturnType<ExtensionHostWorkerApi[T]>, set$4: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$4: () => Promise<void>;
+declare const invoke$6: <T extends "Extensions.getExtensions">(method: T, ...params: Parameters<ExtensionHostWorkerApi[T]>) => ReturnType<ExtensionHostWorkerApi[T]>, invokeAndTransfer$6: <T extends "Extensions.getExtensions">(method: T, ...params: Parameters<ExtensionHostWorkerApi[T]>) => ReturnType<ExtensionHostWorkerApi[T]>, set$6: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$6: () => Promise<void>;
 export interface FileSystemProcessApi {
 	readonly "FileSystem.copy": (oldUri: string, newUri: string) => Promise<void>;
 	readonly "FileSystem.getPathSeparator": () => Promise<string>;
@@ -74,7 +86,7 @@ export interface FileSystemProcessApi {
 	readonly "FileSystem.stat": (uri: string) => Promise<any>;
 	readonly "FileSystem.writeFile": (uri: string, content: string) => Promise<void>;
 }
-declare const invoke$5: <T extends keyof FileSystemProcessApi>(method: T, ...params: Parameters<FileSystemProcessApi[T]>) => ReturnType<FileSystemProcessApi[T]>, invokeAndTransfer$5: <T extends keyof FileSystemProcessApi>(method: T, ...params: Parameters<FileSystemProcessApi[T]>) => ReturnType<FileSystemProcessApi[T]>, set$5: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$5: () => Promise<void>;
+declare const invoke$7: <T extends keyof FileSystemProcessApi>(method: T, ...params: Parameters<FileSystemProcessApi[T]>) => ReturnType<FileSystemProcessApi[T]>, invokeAndTransfer$7: <T extends keyof FileSystemProcessApi>(method: T, ...params: Parameters<FileSystemProcessApi[T]>) => ReturnType<FileSystemProcessApi[T]>, set$7: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$7: () => Promise<void>;
 export interface FileSystemWorkerApi {
 	readonly "FileSystem.copy": (oldUri: string, newUri: string) => Promise<void>;
 	readonly "FileSystem.getPathSeparator": () => Promise<string>;
@@ -87,7 +99,7 @@ export interface FileSystemWorkerApi {
 	readonly "FileSystem.stat": (uri: string) => Promise<any>;
 	readonly "FileSystem.writeFile": (uri: string, content: string) => Promise<void>;
 }
-declare const invoke$6: <T extends keyof FileSystemWorkerApi>(method: T, ...params: Parameters<FileSystemWorkerApi[T]>) => ReturnType<FileSystemWorkerApi[T]>, invokeAndTransfer$6: <T extends keyof FileSystemWorkerApi>(method: T, ...params: Parameters<FileSystemWorkerApi[T]>) => ReturnType<FileSystemWorkerApi[T]>, set$6: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$6: () => Promise<void>;
+declare const invoke$8: <T extends keyof FileSystemWorkerApi>(method: T, ...params: Parameters<FileSystemWorkerApi[T]>) => ReturnType<FileSystemWorkerApi[T]>, invokeAndTransfer$8: <T extends keyof FileSystemWorkerApi>(method: T, ...params: Parameters<FileSystemWorkerApi[T]>) => ReturnType<FileSystemWorkerApi[T]>, set$8: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$8: () => Promise<void>;
 declare const NodeWorker = 1;
 declare const NodeForkedProcess = 2;
 declare const ElectronUtilityProcess = 3;
@@ -108,12 +120,17 @@ export interface MainProcessApi {
 	readonly "ElectronWebContentsViewFunctions.show": (id: any, ...args: readonly any[]) => Promise<void>;
 	readonly "Trash.trash": (path: string) => Promise<void>;
 }
-declare const invoke$7: <T extends keyof MainProcessApi>(method: T, ...params: Parameters<MainProcessApi[T]>) => ReturnType<MainProcessApi[T]>, invokeAndTransfer$7: <T extends keyof MainProcessApi>(method: T, ...params: Parameters<MainProcessApi[T]>) => ReturnType<MainProcessApi[T]>, set$7: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$7: () => Promise<void>;
+declare const invoke$9: <T extends keyof MainProcessApi>(method: T, ...params: Parameters<MainProcessApi[T]>) => ReturnType<MainProcessApi[T]>, invokeAndTransfer$9: <T extends keyof MainProcessApi>(method: T, ...params: Parameters<MainProcessApi[T]>) => ReturnType<MainProcessApi[T]>, set$9: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$9: () => Promise<void>;
 export interface MarkdownWorkerApi {
 	readonly "Markdown.getMarkDownVirtualDom": (html: string) => Promise<any>;
 	readonly "Markdown.renderMarkdown": (markdown: string, options: any) => Promise<void>;
 }
-declare const invoke$8: <T extends keyof MarkdownWorkerApi>(method: T, ...params: Parameters<MarkdownWorkerApi[T]>) => ReturnType<MarkdownWorkerApi[T]>, invokeAndTransfer$8: <T extends keyof MarkdownWorkerApi>(method: T, ...params: Parameters<MarkdownWorkerApi[T]>) => ReturnType<MarkdownWorkerApi[T]>, set$8: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$8: () => Promise<void>;
+declare const invoke$10: <T extends keyof MarkdownWorkerApi>(method: T, ...params: Parameters<MarkdownWorkerApi[T]>) => ReturnType<MarkdownWorkerApi[T]>, invokeAndTransfer$10: <T extends keyof MarkdownWorkerApi>(method: T, ...params: Parameters<MarkdownWorkerApi[T]>) => ReturnType<MarkdownWorkerApi[T]>, set$10: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$10: () => Promise<void>;
+export interface RendererProcessApi {
+	readonly "Debug.pause": () => Promise<void>;
+	readonly "Debug.resume": () => Promise<void>;
+}
+declare const invoke$11: <T extends keyof RendererProcessApi>(method: T, ...params: Parameters<RendererProcessApi[T]>) => ReturnType<RendererProcessApi[T]>, invokeAndTransfer$11: <T extends keyof RendererProcessApi>(method: T, ...params: Parameters<RendererProcessApi[T]>) => ReturnType<RendererProcessApi[T]>, set$11: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$11: () => Promise<void>;
 export interface TextEdit {
 	readonly text: string;
 	readonly startRowIndex: number;
@@ -410,12 +427,13 @@ export interface RendererWorkerApi {
 	readonly "Workspace.getPath": () => Promise<string>;
 	readonly "Workspace.setPath": (uri: string) => Promise<void>;
 }
-declare const invoke$9: <T extends keyof RendererWorkerApi>(method: T, ...params: Parameters<RendererWorkerApi[T]>) => ReturnType<RendererWorkerApi[T]>, invokeAndTransfer$9: <T extends keyof RendererWorkerApi>(method: T, ...params: Parameters<RendererWorkerApi[T]>) => ReturnType<RendererWorkerApi[T]>, set$9: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$9: () => Promise<void>;
+declare const invoke$12: <T extends keyof RendererWorkerApi>(method: T, ...params: Parameters<RendererWorkerApi[T]>) => ReturnType<RendererWorkerApi[T]>, invokeAndTransfer$12: <T extends keyof RendererWorkerApi>(method: T, ...params: Parameters<RendererWorkerApi[T]>) => ReturnType<RendererWorkerApi[T]>, set$12: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$12: () => Promise<void>;
 declare const DebugWorker = 55;
 declare const EditorWorker = 99;
 declare const ExtensionHostWorker = 44;
 declare const MainProcess = -5;
 declare const RendererWorker = 1;
+declare const RendererProcess = 1670;
 declare const SearchProcess = 77;
 declare const SearchProcessElectron = 2;
 declare const SharedProcess = 1;
@@ -430,10 +448,12 @@ declare const ColorPickerWorker = 302;
 declare const SourceActionWorker = 303;
 declare const ErrorWorker = 3308;
 declare const SyntaxHighlightingWorker = 3309;
+declare const ClipBoardWorker = 3400;
+declare const ClipBoardProcess = 3401;
 export interface SearchProcessApi {
 	readonly "TextSearch.search": (options: any) => Promise<readonly SearchResult[]>;
 }
-declare const invoke$10: <T extends "TextSearch.search">(method: T, ...params: Parameters<SearchProcessApi[T]>) => ReturnType<SearchProcessApi[T]>, invokeAndTransfer$10: <T extends "TextSearch.search">(method: T, ...params: Parameters<SearchProcessApi[T]>) => ReturnType<SearchProcessApi[T]>, set$10: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$10: () => Promise<void>;
+declare const invoke$13: <T extends "TextSearch.search">(method: T, ...params: Parameters<SearchProcessApi[T]>) => ReturnType<SearchProcessApi[T]>, invokeAndTransfer$13: <T extends "TextSearch.search">(method: T, ...params: Parameters<SearchProcessApi[T]>) => ReturnType<SearchProcessApi[T]>, set$13: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$13: () => Promise<void>;
 export interface SharedProcessApi {
 	readonly "ElectronWebContents.callFunction": (webContentsId: any, method: string, ...params: readonly any[]) => Promise<any>;
 	readonly "ElectronWebContents.dispose": (id: any) => Promise<void>;
@@ -448,7 +468,7 @@ export interface SharedProcessApi {
 	readonly "ElectronWebContentsViewFunctions.setIframeSrcFallback": (id: any, ...args: readonly any[]) => Promise<void>;
 	readonly "ElectronWebContentsViewFunctions.show": (id: any, ...args: readonly any[]) => Promise<void>;
 }
-declare const invoke$11: <T extends keyof SharedProcessApi>(method: T, ...params: Parameters<SharedProcessApi[T]>) => ReturnType<SharedProcessApi[T]>, invokeAndTransfer$11: <T extends keyof SharedProcessApi>(method: T, ...params: Parameters<SharedProcessApi[T]>) => ReturnType<SharedProcessApi[T]>, set$11: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$11: () => Promise<void>;
+declare const invoke$14: <T extends keyof SharedProcessApi>(method: T, ...params: Parameters<SharedProcessApi[T]>) => ReturnType<SharedProcessApi[T]>, invokeAndTransfer$14: <T extends keyof SharedProcessApi>(method: T, ...params: Parameters<SharedProcessApi[T]>) => ReturnType<SharedProcessApi[T]>, set$14: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$14: () => Promise<void>;
 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>;
@@ -457,59 +477,70 @@ export interface SyntaxHighlightingWorkerApi {
 	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;
 }
-declare const invoke$12: <T extends keyof SyntaxHighlightingWorkerApi>(method: T, ...params: Parameters<SyntaxHighlightingWorkerApi[T]>) => ReturnType<SyntaxHighlightingWorkerApi[T]>, invokeAndTransfer$12: <T extends keyof SyntaxHighlightingWorkerApi>(method: T, ...params: Parameters<SyntaxHighlightingWorkerApi[T]>) => ReturnType<SyntaxHighlightingWorkerApi[T]>, set$12: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$12: () => Promise<void>;
+declare const invoke$15: <T extends keyof SyntaxHighlightingWorkerApi>(method: T, ...params: Parameters<SyntaxHighlightingWorkerApi[T]>) => ReturnType<SyntaxHighlightingWorkerApi[T]>, invokeAndTransfer$15: <T extends keyof SyntaxHighlightingWorkerApi>(method: T, ...params: Parameters<SyntaxHighlightingWorkerApi[T]>) => ReturnType<SyntaxHighlightingWorkerApi[T]>, set$15: (rpc: import("@lvce-editor/rpc").Rpc) => void, dispose$15: () => Promise<void>;
 export declare const getIpcType: (argv: readonly string[]) => number;
-declare const set$13: (id: number, rpc: Rpc) => void;
+declare const set$16: (id: number, rpc: Rpc) => void;
 export declare const get: (id: number) => Rpc;
 export declare const remove: (id: number) => void;
 
 declare namespace SyntaxHighlightingWorker$1 {
-	export { dispose$12 as dispose, invoke$12 as invoke, invokeAndTransfer$12 as invokeAndTransfer, set$12 as set };
+	export { dispose$15 as dispose, invoke$15 as invoke, invokeAndTransfer$15 as invokeAndTransfer, set$15 as set };
 }
-declare namespace DebugWorker$1 {
+declare namespace ClipBoardProcess$1 {
 	export { dispose, invoke, invokeAndTransfer, set };
 }
-declare namespace EditorWorker$1 {
+declare namespace ClipBoardWorker$1 {
 	export { dispose$1 as dispose, invoke$1 as invoke, invokeAndTransfer$1 as invokeAndTransfer, set$1 as set };
 }
-declare namespace EmbedsProcess$1 {
+declare namespace DebugWorker$1 {
 	export { dispose$2 as dispose, invoke$2 as invoke, invokeAndTransfer$2 as invokeAndTransfer, set$2 as set };
 }
-declare namespace ErrorWorker$1 {
+declare namespace EditorWorker$1 {
 	export { dispose$3 as dispose, invoke$3 as invoke, invokeAndTransfer$3 as invokeAndTransfer, set$3 as set };
 }
-declare namespace ExtensionHost {
+declare namespace EmbedsProcess$1 {
 	export { dispose$4 as dispose, invoke$4 as invoke, invokeAndTransfer$4 as invokeAndTransfer, set$4 as set };
 }
-declare namespace FileSystemProcess$1 {
+declare namespace ErrorWorker$1 {
 	export { dispose$5 as dispose, invoke$5 as invoke, invokeAndTransfer$5 as invokeAndTransfer, set$5 as set };
 }
-declare namespace FileSystemWorker$1 {
+declare namespace ExtensionHost {
 	export { dispose$6 as dispose, invoke$6 as invoke, invokeAndTransfer$6 as invokeAndTransfer, set$6 as set };
 }
+declare namespace FileSystemProcess$1 {
+	export { dispose$7 as dispose, invoke$7 as invoke, invokeAndTransfer$7 as invokeAndTransfer, set$7 as set };
+}
+declare namespace FileSystemWorker$1 {
+	export { dispose$8 as dispose, invoke$8 as invoke, invokeAndTransfer$8 as invokeAndTransfer, set$8 as set };
+}
 declare namespace IpcType {
 	export { ElectronMessagePort, ElectronUtilityProcess, NodeForkedProcess, NodeWorker, WebSocket$1 as WebSocket };
 }
 declare namespace MainProcess$1 {
-	export { dispose$7 as dispose, invoke$7 as invoke, invokeAndTransfer$7 as invokeAndTransfer, set$7 as set };
+	export { dispose$9 as dispose, invoke$9 as invoke, invokeAndTransfer$9 as invokeAndTransfer, set$9 as set };
 }
 declare namespace MarkdownWorker$1 {
-	export { dispose$8 as dispose, invoke$8 as invoke, invokeAndTransfer$8 as invokeAndTransfer, set$8 as set };
+	export { dispose$10 as dispose, invoke$10 as invoke, invokeAndTransfer$10 as invokeAndTransfer, set$10 as set };
+}
+declare namespace RendererProcess$1 {
+	export { dispose$11 as dispose, invoke$11 as invoke, invokeAndTransfer$11 as invokeAndTransfer, set$11 as set };
 }
 declare namespace RendererWorker$1 {
-	export { dispose$9 as dispose, invoke$9 as invoke, invokeAndTransfer$9 as invokeAndTransfer, set$9 as set };
+	export { dispose$12 as dispose, invoke$12 as invoke, invokeAndTransfer$12 as invokeAndTransfer, set$12 as set };
 }
 declare namespace RpcId {
-	export { ColorPickerWorker, CompletionWorker, DebugWorker, EditorWorker, EmbedsProcess, EmbedsWorker, ErrorWorker, ExtensionHostWorker, FileSystemProcess, FileSystemWorker, MainProcess, MarkdownWorker, RendererWorker, SearchProcess, SearchProcessElectron, SharedProcess, SourceActionWorker, SourceControlWorker, SyntaxHighlightingWorker };
+	export { ClipBoardProcess, ClipBoardWorker, ColorPickerWorker, CompletionWorker, DebugWorker, EditorWorker, EmbedsProcess, EmbedsWorker, ErrorWorker, ExtensionHostWorker, FileSystemProcess, FileSystemWorker, MainProcess, MarkdownWorker, RendererProcess, RendererWorker, SearchProcess, SearchProcessElectron, SharedProcess, SourceActionWorker, SourceControlWorker, SyntaxHighlightingWorker };
 }
 declare namespace SearchProcess$1 {
-	export { dispose$10 as dispose, invoke$10 as invoke, invokeAndTransfer$10 as invokeAndTransfer, set$10 as set };
+	export { dispose$13 as dispose, invoke$13 as invoke, invokeAndTransfer$13 as invokeAndTransfer, set$13 as set };
 }
 declare namespace SharedProcess$1 {
-	export { dispose$11 as dispose, invoke$11 as invoke, invokeAndTransfer$11 as invokeAndTransfer, set$11 as set };
+	export { dispose$14 as dispose, invoke$14 as invoke, invokeAndTransfer$14 as invokeAndTransfer, set$14 as set };
 }
 
 export {
+	ClipBoardProcess$1 as ClipBoardProcess,
+	ClipBoardWorker$1 as ClipBoardWorker,
 	DebugWorker$1 as DebugWorker,
 	EditorWorker$1 as EditorWorker,
 	EmbedsProcess$1 as EmbedsProcess,
@@ -520,13 +551,14 @@ export {
 	IpcType,
 	MainProcess$1 as MainProcess,
 	MarkdownWorker$1 as MarkdownWorker,
+	RendererProcess$1 as RendererProcess,
 	RendererWorker$1 as RendererWorker,
 	Rpc,
 	RpcId,
 	SearchProcess$1 as SearchProcess,
 	SharedProcess$1 as SharedProcess,
 	SyntaxHighlightingWorker$1 as SyntaxHighlightingWorker,
-	set$13 as set,
+	set$16 as set,
 };
 
 export {};

package/dist/index.js

@@ -1,5 +1,5 @@
 const rpcs = Object.create(null);
-const set$d = (id, rpc) => {
+const set$g = (id, rpc) => {
   rpcs[id] = rpc;
 };
 const get = id => {
@@ -26,7 +26,7 @@ const create = rpcId => {
       return rpc.invokeAndTransfer(method, ...params);
     },
     set(rpc) {
-      set$d(rpcId, rpc);
+      set$g(rpcId, rpc);
     },
     async dispose() {
       const rpc = get(rpcId);
@@ -40,6 +40,7 @@ const EditorWorker$1 = 99;
 const ExtensionHostWorker = 44;
 const MainProcess$1 = -5;
 const RendererWorker$1 = 1;
+const RendererProcess$1 = 1670;
 const SearchProcess$1 = 77;
 const SearchProcessElectron = 2;
 const SharedProcess$1 = 1;
@@ -54,9 +55,13 @@ const ColorPickerWorker = 302;
 const SourceActionWorker = 303;
 const ErrorWorker$1 = 3308;
 const SyntaxHighlightingWorker$1 = 3309;
+const ClipBoardWorker$1 = 3400;
+const ClipBoardProcess$1 = 3401;
 
 const RpcId = {
   __proto__: null,
+  ClipBoardProcess: ClipBoardProcess$1,
+  ClipBoardWorker: ClipBoardWorker$1,
   ColorPickerWorker,
   CompletionWorker,
   DebugWorker: DebugWorker$1,
@@ -69,6 +74,7 @@ const RpcId = {
   FileSystemWorker: FileSystemWorker$1,
   MainProcess: MainProcess$1,
   MarkdownWorker: MarkdownWorker$1,
+  RendererProcess: RendererProcess$1,
   RendererWorker: RendererWorker$1,
   SearchProcess: SearchProcess$1,
   SearchProcessElectron,
@@ -78,14 +84,59 @@ const RpcId = {
   SyntaxHighlightingWorker: SyntaxHighlightingWorker$1
 };
 
+const {
+  invoke: invoke$f,
+  invokeAndTransfer: invokeAndTransfer$f,
+  set: set$f,
+  dispose: dispose$f
+} = create(ClipBoardProcess$1);
+
+const ClipBoardProcess = {
+  __proto__: null,
+  dispose: dispose$f,
+  invoke: invoke$f,
+  invokeAndTransfer: invokeAndTransfer$f,
+  set: set$f
+};
+
+const {
+  invoke: invoke$e,
+  invokeAndTransfer: invokeAndTransfer$e,
+  set: set$e,
+  dispose: dispose$e
+} = create(ClipBoardWorker$1);
+
+const ClipBoardWorker = {
+  __proto__: null,
+  dispose: dispose$e,
+  invoke: invoke$e,
+  invokeAndTransfer: invokeAndTransfer$e,
+  set: set$e
+};
+
+const {
+  invoke: invoke$d,
+  invokeAndTransfer: invokeAndTransfer$d,
+  set: set$d,
+  dispose: dispose$d
+} = create(DebugWorker$1);
+
+const DebugWorker = {
+  __proto__: null,
+  dispose: dispose$d,
+  invoke: invoke$d,
+  invokeAndTransfer: invokeAndTransfer$d,
+  set: set$d
+};
+
 const {
   invoke: invoke$c,
   invokeAndTransfer: invokeAndTransfer$c,
   set: set$c,
   dispose: dispose$c
-} = create(DebugWorker$1);
+} = create(EditorWorker$1);
 
-const DebugWorker = {
+const EditorWorker = {
   __proto__: null,
   dispose: dispose$c,
   invoke: invoke$c,
@@ -98,9 +149,9 @@ const {
   invokeAndTransfer: invokeAndTransfer$b,
   set: set$b,
   dispose: dispose$b
-} = create(EditorWorker$1);
+} = create(EmbedsProcess$1);
 
-const EditorWorker = {
+const EmbedsProcess = {
   __proto__: null,
   dispose: dispose$b,
   invoke: invoke$b,
@@ -113,9 +164,9 @@ const {
   invokeAndTransfer: invokeAndTransfer$a,
   set: set$a,
   dispose: dispose$a
-} = create(EmbedsProcess$1);
+} = create(ErrorWorker$1);
 
-const EmbedsProcess = {
+const ErrorWorker = {
   __proto__: null,
   dispose: dispose$a,
   invoke: invoke$a,
@@ -128,9 +179,9 @@ const {
   invokeAndTransfer: invokeAndTransfer$9,
   set: set$9,
   dispose: dispose$9
-} = create(ErrorWorker$1);
+} = create(ExtensionHostWorker);
 
-const ErrorWorker = {
+const ExtensionHost = {
   __proto__: null,
   dispose: dispose$9,
   invoke: invoke$9,
@@ -143,9 +194,9 @@ const {
   invokeAndTransfer: invokeAndTransfer$8,
   set: set$8,
   dispose: dispose$8
-} = create(ExtensionHostWorker);
+} = create(FileSystemProcess$1);
 
-const ExtensionHost = {
+const FileSystemProcess = {
   __proto__: null,
   dispose: dispose$8,
   invoke: invoke$8,
@@ -158,9 +209,9 @@ const {
   invokeAndTransfer: invokeAndTransfer$7,
   set: set$7,
   dispose: dispose$7
-} = create(FileSystemProcess$1);
+} = create(FileSystemWorker$1);
 
-const FileSystemProcess = {
+const FileSystemWorker = {
   __proto__: null,
   dispose: dispose$7,
   invoke: invoke$7,
@@ -168,21 +219,6 @@ const FileSystemProcess = {
   set: set$7
 };
 
-const {
-  invoke: invoke$6,
-  invokeAndTransfer: invokeAndTransfer$6,
-  set: set$6,
-  dispose: dispose$6
-} = create(FileSystemWorker$1);
-
-const FileSystemWorker = {
-  __proto__: null,
-  dispose: dispose$6,
-  invoke: invoke$6,
-  invokeAndTransfer: invokeAndTransfer$6,
-  set: set$6
-};
-
 const NodeWorker = 1;
 const NodeForkedProcess = 2;
 const ElectronUtilityProcess = 3;
@@ -198,14 +234,29 @@ const IpcType = {
   WebSocket
 };
 
+const {
+  invoke: invoke$6,
+  invokeAndTransfer: invokeAndTransfer$6,
+  set: set$6,
+  dispose: dispose$6
+} = create(MainProcess$1);
+
+const MainProcess = {
+  __proto__: null,
+  dispose: dispose$6,
+  invoke: invoke$6,
+  invokeAndTransfer: invokeAndTransfer$6,
+  set: set$6
+};
+
 const {
   invoke: invoke$5,
   invokeAndTransfer: invokeAndTransfer$5,
   set: set$5,
   dispose: dispose$5
-} = create(MainProcess$1);
+} = create(MarkdownWorker$1);
 
-const MainProcess = {
+const MarkdownWorker = {
   __proto__: null,
   dispose: dispose$5,
   invoke: invoke$5,
@@ -218,9 +269,9 @@ const {
   invokeAndTransfer: invokeAndTransfer$4,
   set: set$4,
   dispose: dispose$4
-} = create(MarkdownWorker$1);
+} = create(RendererProcess$1);
 
-const MarkdownWorker = {
+const RendererProcess = {
   __proto__: null,
   dispose: dispose$4,
   invoke: invoke$4,
@@ -301,4 +352,4 @@ const getIpcType = argv => {
   throw new Error(`[file-system-process] unknown ipc type`);
 };
 
-export { DebugWorker, EditorWorker, EmbedsProcess, ErrorWorker, ExtensionHost, FileSystemProcess, FileSystemWorker, IpcType, MainProcess, MarkdownWorker, RendererWorker, RpcId, SearchProcess, SharedProcess, SyntaxHighlightingWorker, get, getIpcType, remove, set$d as set };
+export { ClipBoardProcess, ClipBoardWorker, DebugWorker, EditorWorker, EmbedsProcess, ErrorWorker, ExtensionHost, FileSystemProcess, FileSystemWorker, IpcType, MainProcess, MarkdownWorker, RendererProcess, RendererWorker, RpcId, SearchProcess, SharedProcess, SyntaxHighlightingWorker, get, getIpcType, remove, set$g as set };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/rpc-registry",
-  "version": "2.30.0",
+  "version": "2.32.0",
   "description": "Rpc Registry",
   "license": "MIT",
   "author": "Lvce Editor",