@lobehub/editor 4.14.0 → 4.15.1

package/es/codemirror.d.ts

@@ -0,0 +1,264 @@
+import { FC } from "react";
+
+//#region src/codemirror/types.d.ts
+interface CodeMirrorMode {
+  ext?: string[];
+  name: string;
+  syntax: string;
+  value: string;
+}
+interface CodeMirrorLabels {
+  copy?: string;
+  selectLanguage?: string;
+  showLineNumbers?: string;
+  tabSize?: string;
+  useTabs?: string;
+}
+interface CopyButtonProps {
+  className?: string;
+  labels?: Pick<CodeMirrorLabels, 'copy'>;
+  onCopy: () => void;
+}
+interface LanguageSelectProps {
+  className?: string;
+  labels?: Pick<CodeMirrorLabels, 'selectLanguage'>;
+  onLanguageChange: (value: string) => void;
+  options?: CodeMirrorMode[];
+  selectedLang: string;
+}
+interface MoreOptionsProps {
+  labels?: Pick<CodeMirrorLabels, 'showLineNumbers' | 'tabSize' | 'useTabs'>;
+  onShowLineNumbersChange: (checked: boolean) => void;
+  onTabSizeChange: (value: number | null) => void;
+  onUseTabsChange: (checked: boolean) => void;
+  showLineNumbers: boolean;
+  tabSize: number;
+  useTabs: boolean;
+}
+interface ToolbarProps {
+  expand?: boolean;
+  labels?: CodeMirrorLabels;
+  languageOptions?: CodeMirrorMode[];
+  onClick?: () => void;
+  onCopy: () => void;
+  onLanguageChange: (value: string) => void;
+  onShowLineNumbersChange: (checked: boolean) => void;
+  onTabSizeChange: (value: number | null) => void;
+  onUseTabsChange: (checked: boolean) => void;
+  selectedLang: string;
+  showLineNumbers: boolean;
+  tabSize: number;
+  toggleExpand?: () => void;
+  useTabs: boolean;
+}
+//#endregion
+//#region src/codemirror/components/CopyButton.d.ts
+declare const CopyButton: FC<CopyButtonProps>;
+//#endregion
+//#region src/codemirror/components/LanguageSelect.d.ts
+declare const LanguageSelect: FC<LanguageSelectProps>;
+//#endregion
+//#region src/codemirror/components/MoreOptions.d.ts
+declare const MoreOptions: FC<MoreOptionsProps>;
+//#endregion
+//#region src/codemirror/components/Toolbar.d.ts
+declare const Toolbar: FC<ToolbarProps>;
+//#endregion
+//#region src/codemirror/constants.d.ts
+declare const LANGUAGES: CodeMirrorMode[];
+//#endregion
+//#region src/codemirror/loader.d.ts
+interface CodeMirrorOptions {
+  className?: string;
+  foldGutter?: boolean;
+  history?: any;
+  indentWithTabs?: boolean;
+  lineNumbers?: boolean;
+  lineWrapping?: boolean;
+  mode?: string;
+  preventCopy?: boolean;
+  readOnly?: boolean;
+  tabSize?: number;
+  theme?: 'default';
+  value?: string;
+}
+interface ICodeMirrorInstance {
+  blur(): void;
+  clearHistory(): void;
+  destroy(): void;
+  focus(): void;
+  foldGutter?: boolean;
+  foldLines(): number[];
+  foldLines(lines: number[]): void;
+  formatAll(): void;
+  getHistory(): any;
+  getLine(line: number): string;
+  getSelection(): string;
+  getValue: () => string;
+  historyRedoDepth(): number;
+  historyUndoDepth(): number;
+  lineCount(): number;
+  on(event: 'change' | 'blur' | 'focus' | 'keyup' | 'fold' | 'unfold' | 'keydown' | 'rightOut' | 'leftOut', handler: (...args: any[]) => void): void;
+  optionHelper: {
+    theme: {
+      reconfigure: (theme: any) => void;
+    };
+  };
+  redoSelection(): void;
+  replaceSelection(text: string): void;
+  setOption(option: keyof CodeMirrorOptions, value: any): void;
+  setSelection(anchor: number, header: number): void;
+  setSelectionToEnd(): void;
+  setSelectionToStart(): void;
+  setValue(value: string): void;
+  undoSelection(): void;
+  view: {
+    constructor: {
+      theme: (options: any, settings: any) => any;
+    };
+    dispatch: (params: {
+      effects: any;
+    }) => void;
+  };
+}
+interface ICodeMirror {
+  fromTextArea: (textarea: HTMLTextAreaElement, options?: CodeMirrorOptions) => ICodeMirrorInstance;
+  new (dom: HTMLElement, options?: CodeMirrorOptions): ICodeMirrorInstance;
+}
+declare function loadCodeMirror(cdnUrl?: string): Promise<ICodeMirror>;
+//#endregion
+//#region src/codemirror/style.d.ts
+declare const styles: string;
+//#endregion
+//#region src/codemirror/theme.d.ts
+declare const lobeTheme: {
+  '&': {
+    '& .cm-cursor': {
+      'border-left-color': string;
+    };
+    '& .cm-cursor.cm-cursor-primary': {
+      'border-inline-start': string;
+    };
+    '& .cm-gutters': {
+      'background-color': string;
+      border: string;
+      color: string;
+      cursor: string;
+    };
+    '& .cm-line': {
+      '& .cm-atom': {
+        color: string;
+      };
+      '& .cm-attribute': {
+        color: string;
+      };
+      '& .cm-builtin': {
+        color: string;
+        fontStyle: string;
+      };
+      '& .cm-comment': {
+        color: string;
+        fontStyle: string;
+      };
+      '& .cm-foldPlaceholder': {
+        background: string;
+        border: string;
+        color: string;
+        display: string;
+        height: string;
+        padding: number;
+        'vertical-align': string;
+        width: string;
+      };
+      '& .cm-function': {
+        color: string;
+      };
+      '& .cm-header': {
+        color: string;
+      };
+      '& .cm-keyword': {
+        color: string;
+      };
+      '& .cm-meta': {
+        color: string;
+      };
+      '& .cm-modifier': {
+        color: string;
+      };
+      '& .cm-number': {
+        color: string;
+      };
+      '& .cm-operator': {
+        color: string;
+      };
+      '& .cm-property': {
+        color: string;
+      };
+      '& .cm-punctuation': {
+        color: string;
+      };
+      '& .cm-qualifier': {
+        color: string;
+      };
+      '& .cm-string': {
+        color: string;
+      };
+      '& .cm-string-2': {
+        color: string;
+      };
+      '& .cm-tag': {
+        color: string;
+      };
+      '& .cm-tag.cm-bracket': {
+        color: string;
+      };
+      '& .cm-type': {
+        color: string;
+      };
+      '& .cm-variable': {
+        color: string;
+      };
+      '& .cm-variable-2': {
+        color: string;
+      };
+      '& .cm-variable-3': {
+        color: string;
+      };
+      '& .cm-variable.cm-callee': {
+        color: string;
+      };
+      '& .cm-variable.cm-def': {
+        color: string;
+      };
+      color: string;
+      'padding-inline': string;
+    };
+  };
+  '& .cm-selectionBackground': {
+    background: string;
+  };
+  '& .cm-selectionMatch': {
+    background: string;
+  };
+  '&.cm-editor': {
+    background: string;
+    cursor: string;
+    'padding-block': string;
+    width: string;
+  };
+  '&.cm-editor span': {
+    'font-family': string;
+    'font-size': string;
+  };
+  '&.cm-editor.cm-focused .cm-selectionBackground': {
+    background: string;
+  };
+  '&.cm-editor.cm-focused .cm-selectionLineGutter': {
+    color: string;
+  };
+  '&.cm-focused > .cm-scroller > .cm-selectionLayer .cm-selectionBackground': {
+    background: string;
+  };
+};
+//#endregion
+export { type CodeMirrorLabels, type CodeMirrorMode, type CodeMirrorOptions, CopyButton, type CopyButtonProps, type ICodeMirror, type ICodeMirrorInstance, LANGUAGES, LanguageSelect, type LanguageSelectProps, MoreOptions, type MoreOptionsProps, Toolbar, type ToolbarProps, loadCodeMirror, lobeTheme, styles };

package/es/codemirror.js

@@ -0,0 +1,2 @@
+import { a as MoreOptions, c as CopyButton, i as Toolbar, n as styles, o as LanguageSelect, r as loadCodeMirror, s as LANGUAGES, t as lobeTheme } from "./codemirror-3POv7f__.js";
+export { CopyButton, LANGUAGES, LanguageSelect, MoreOptions, Toolbar, loadCodeMirror, lobeTheme, styles };

package/es/debug-CIvbNHJu.js

@@ -0,0 +1,270 @@
+import createDebug from "debug";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __hasOwnProp.call(mod, "module.exports") ? mod["module.exports"] : __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+//#endregion
+//#region src/utils/debug.ts
+var debug_exports = /* @__PURE__ */ __exportAll({
+	DebugLogger: () => DebugLogger,
+	browserDebug: () => browserDebug,
+	createDebugLogger: () => createDebugLogger,
+	debugLogger: () => debugLogger,
+	debugLoggers: () => debugLoggers,
+	devConsole: () => devConsole,
+	isDev: () => true,
+	prodSafeLogger: () => prodSafeLogger
+});
+/**
+* Convenience function to create a debug logger for a specific category
+* @param category - Main category (e.g., 'kernel', 'plugin', 'upload')
+* @param subcategory - Optional subcategory
+* @returns Logger object with debug methods
+*/
+function createDebugLogger(category, subcategory) {
+	return debugLogger.createLogger(category, subcategory);
+}
+var BASE_NAMESPACE, DebugLogger, debugLogger, debugLoggers, devConsole, prodSafeLogger, browserDebug;
+var init_debug = __esmMin((() => {
+	BASE_NAMESPACE = "lobe-editor";
+	DebugLogger = class {
+		constructor() {
+			this.debuggers = /* @__PURE__ */ new Map();
+		}
+		/**
+		* Get or create a debug function for a specific namespace
+		* @param category - The debug category (e.g., 'kernel', 'plugin', 'upload')
+		* @param subcategory - Optional subcategory for more specific debugging
+		* @returns Debug function
+		*/
+		getDebugger(category, subcategory) {
+			const namespace = subcategory ? `${BASE_NAMESPACE}:${category}:${subcategory}` : `${BASE_NAMESPACE}:${category}`;
+			if (!this.debuggers.has(namespace)) this.debuggers.set(namespace, createDebug(namespace));
+			return this.debuggers.get(namespace);
+		}
+		/**
+		* Create a scoped debug logger for a specific component/service
+		* @param category - Main category
+		* @param subcategory - Optional subcategory
+		* @returns Object with debug methods
+		*/
+		createLogger(category, subcategory) {
+			const debug = this.getDebugger(category, subcategory);
+			const warnDebugger = this.getDebugger(category, subcategory ? `${subcategory}:warn` : "warn");
+			const errorDebugger = this.getDebugger(category, subcategory ? `${subcategory}:error` : "error");
+			const info = this.getDebugger(category, subcategory ? `${subcategory}:info` : "info");
+			const warn = (...args) => {
+				if (warnDebugger.enabled) {
+					const prefix = warnDebugger.namespace;
+					console.warn(`${prefix}`, ...args);
+				}
+			};
+			const error = (...args) => {
+				if (errorDebugger.enabled) {
+					const prefix = errorDebugger.namespace;
+					console.error(`${prefix}`, ...args);
+				}
+			};
+			return {
+				/**
+				* General debug logging
+				*/
+				debug,
+				/**
+				* Error level logging - uses console.error for proper browser dev tool support
+				*/
+				error,
+				/**
+				* Info level logging
+				*/
+				info,
+				/**
+				* Log function - alias for debug for compatibility
+				*/
+				log: debug,
+				/**
+				* Warning level logging - uses console.warn for proper browser dev tool support
+				*/
+				warn
+			};
+		}
+		/**
+		* Enable debug for specific namespaces
+		* @param namespaces - Comma-separated list of namespaces to enable
+		*/
+		enable(namespaces) {
+			createDebug.enable(namespaces);
+		}
+		/**
+		* Disable all debug output
+		*/
+		disable() {
+			createDebug.disable();
+		}
+		/**
+		* Check if a namespace is enabled
+		* @param namespace - The namespace to check
+		* @returns Whether the namespace is enabled
+		*/
+		enabled(namespace) {
+			return createDebug.enabled(namespace);
+		}
+	};
+	debugLogger = new DebugLogger();
+	debugLoggers = {
+		demo: createDebugLogger("demo"),
+		file: createDebugLogger("file"),
+		image: createDebugLogger("image"),
+		kernel: createDebugLogger("kernel"),
+		markdown: createDebugLogger("markdown"),
+		math: createDebugLogger("math"),
+		mention: createDebugLogger("mention"),
+		plugin: createDebugLogger("plugin"),
+		react: createDebugLogger("react"),
+		service: createDebugLogger("service"),
+		slash: createDebugLogger("slash"),
+		upload: createDebugLogger("upload")
+	};
+	devConsole = {
+		error: (...args) => {
+			console.error(...args);
+		},
+		info: (...args) => {
+			console.info(...args);
+		},
+		log: (...args) => {
+			console.log(...args);
+		},
+		warn: (...args) => {
+			console.warn(...args);
+		}
+	};
+	prodSafeLogger = {
+		/**
+		* Debug info - only shown when debug is enabled
+		*/
+		debug: debugLoggers.kernel.debug,
+		/**
+		* Log critical errors that should always be visible (uses console.error)
+		*/
+		error: (...args) => {
+			console.error(...args);
+		},
+		/**
+		* Info logging - only shown when debug is enabled
+		*/
+		info: debugLoggers.kernel.info,
+		/**
+		* Log warnings that should always be visible (uses console.warn)
+		*/
+		warn: (...args) => {
+			console.warn(...args);
+		}
+	};
+	browserDebug = {
+		/**
+		* Disable debug logging in browser environment
+		*/
+		disable: () => {
+			if (typeof window !== "undefined") {
+				localStorage.removeItem("debug");
+				createDebug.disable();
+				console.info("Debug disabled.");
+			}
+		},
+		/**
+		* Enable debug logging in browser environment
+		* @param namespaces - Debug namespaces to enable (e.g., 'lobe-editor:*')
+		*/
+		enable: (namespaces = "lobe-editor:*") => {
+			if (typeof window !== "undefined") {
+				localStorage.debug = namespaces;
+				createDebug.enable(namespaces);
+				console.info(`Debug enabled: ${namespaces}`);
+				console.info("Refresh the page to see debug logs from initialization.");
+			}
+		},
+		/**
+		* Get current debug configuration
+		*/
+		getConfig: () => {
+			if (typeof window !== "undefined") {
+				const envDebug = typeof process !== "undefined" ? process.env.DEBUG : void 0;
+				const currentDebug = localStorage.getItem("debug");
+				if (envDebug) return {
+					enabled: envDebug,
+					source: "environment variable (auto-applied)"
+				};
+				else if (currentDebug) return {
+					enabled: currentDebug,
+					source: "development mode (auto-applied)"
+				};
+				else return {
+					enabled: false,
+					source: "disabled"
+				};
+			}
+			return {
+				enabled: (typeof process !== "undefined" ? process.env.DEBUG : void 0) || false,
+				source: "server-side"
+			};
+		},
+		/**
+		* Show available debug categories
+		*/
+		showCategories: () => {
+			console.group("Available debug categories:");
+			console.log("� lobe-editor:kernel - Core editor functionality");
+			console.log("🔌 lobe-editor:plugin:* - All plugins");
+			console.log("🔍 lobe-editor:service:* - All services");
+			console.log("💬 lobe-editor:*:info - Info level messages");
+			console.log("⚠️ lobe-editor:*:warn - Warning messages");
+			console.log("❌ lobe-editor:*:error - Error messages");
+			console.groupEnd();
+			console.info("Usage: browserDebug.enable(\"lobe-editor:kernel,lobe-editor:plugin:*\")");
+		},
+		/**
+		* Show current debug status and configuration
+		*/
+		showStatus: () => {
+			const config = browserDebug.getConfig();
+			console.group("� LobeHub Editor Debug Status");
+			console.log(`Status: ${config.enabled ? "✅ Enabled" : "❌ Disabled"}`);
+			console.log(`Configuration: ${config.enabled || "none"}`);
+			console.log(`Source: ${config.source}`);
+			console.groupEnd();
+			if (!config.enabled) console.info("💡 Zero-config setup: Set DEBUG=lobe-editor:* in your environment");
+		}
+	};
+}));
+//#endregion
+export { debug_exports as a, prodSafeLogger as c, __exportAll as d, __toCommonJS as f, debugLoggers as i, __commonJSMin as l, createDebugLogger as n, devConsole as o, __toESM as p, debugLogger as r, init_debug as s, browserDebug as t, __esmMin as u };

package/es/headless.d.ts

@@ -59,7 +59,6 @@ declare const _default: {
   };
   cancel: string;
   codemirror: {
-    copyFailed: string;
     copySuccess: string;
     selectLanguage: string;
     selectTheme: string;
@@ -489,6 +488,25 @@ declare const LITEXML_MODIFY_COMMAND: _$lexical.LexicalCommand<({
   litexml: string | string[];
 })[]>;
 //#endregion
+//#region src/headless/extract-media-from-editor-state.d.ts
+interface ImageListItem {
+  alt: string;
+  id: string;
+  url: string;
+}
+interface FileListItem {
+  fileType: string;
+  id: string;
+  name: string;
+  size: number;
+  url: string;
+}
+interface MediaLists {
+  fileList: FileListItem[];
+  imageList: ImageListItem[];
+}
+declare const extractMediaFromEditorState: (state: SerializedEditorState | null | undefined) => MediaLists;
+//#endregion
 //#region src/headless/index.d.ts
 type HeadlessDocumentType = 'json' | 'litexml' | 'markdown' | (string & object);
 interface HeadlessEditorHydrationInput {
@@ -552,4 +570,4 @@ declare class HeadlessEditor {
 }
 declare function createHeadlessEditor(options?: HeadlessEditorOptions): HeadlessEditor;
 //#endregion
-export { DEFAULT_HEADLESS_EDITOR_PLUGINS, HeadlessDocumentType, HeadlessEditor, HeadlessEditorExport, HeadlessEditorExportOptions, HeadlessEditorHydrationInput, HeadlessEditorOptions, HeadlessLiteXMLBatchOperation, HeadlessLiteXMLInsertOperation, HeadlessLiteXMLOperation, HeadlessLiteXMLRemoveOperation, HeadlessLiteXMLReplaceOperation, createHeadlessEditor };
+export { DEFAULT_HEADLESS_EDITOR_PLUGINS, type FileListItem, HeadlessDocumentType, HeadlessEditor, HeadlessEditorExport, HeadlessEditorExportOptions, HeadlessEditorHydrationInput, HeadlessEditorOptions, HeadlessLiteXMLBatchOperation, HeadlessLiteXMLInsertOperation, HeadlessLiteXMLOperation, HeadlessLiteXMLRemoveOperation, HeadlessLiteXMLReplaceOperation, type ImageListItem, type MediaLists, createHeadlessEditor, extractMediaFromEditorState };

package/es/headless.js

@@ -55,7 +55,6 @@ var locale_default = {
 	block: { delete: "Delete block" },
 	cancel: "Cancel",
 	codemirror: {
-		copyFailed: "Copy failed",
 		copySuccess: "Code copied to clipboard",
 		selectLanguage: "Select language",
 		selectTheme: "Select theme",
@@ -26841,6 +26840,54 @@ const HeadlessCodeblockPlugin = class extends KernelPlugin {
 	}
 };
 //#endregion
+//#region src/headless/extract-media-from-editor-state.ts
+const IMAGE_TYPES = new Set(["image", "block-image"]);
+const FILE_TYPE = "file";
+const generateId = () => {
+	if (typeof globalThis.crypto?.randomUUID === "function") return globalThis.crypto.randomUUID();
+	return `id-${Math.random().toString(36).slice(2)}-${Date.now().toString(36)}`;
+};
+const inferFileType = (name) => {
+	const dotIndex = name.lastIndexOf(".");
+	if (dotIndex < 0 || dotIndex === name.length - 1) return "unknown";
+	return name.slice(dotIndex + 1).toLowerCase() || "unknown";
+};
+const extractMediaFromEditorState = (state) => {
+	const imageList = [];
+	const fileList = [];
+	const visit = (node) => {
+		const type = node.type;
+		if (IMAGE_TYPES.has(type)) {
+			if (node.status === "uploaded" && typeof node.src === "string" && node.src) imageList.push({
+				alt: typeof node.altText === "string" ? node.altText : "",
+				id: generateId(),
+				url: node.src
+			});
+			return;
+		}
+		if (type === FILE_TYPE) {
+			if (node.status === "uploaded" && typeof node.fileUrl === "string" && node.fileUrl) {
+				const name = typeof node.name === "string" ? node.name : "unknown";
+				fileList.push({
+					fileType: inferFileType(name),
+					id: generateId(),
+					name,
+					size: typeof node.size === "number" ? node.size : 0,
+					url: node.fileUrl
+				});
+			}
+			return;
+		}
+		if (Array.isArray(node.children)) for (const child of node.children) visit(child);
+	};
+	const root = state?.root;
+	if (root && Array.isArray(root.children)) for (const child of root.children) visit(child);
+	return {
+		fileList,
+		imageList
+	};
+};
+//#endregion
 //#region src/headless/index.ts
 const getNumericId = (id) => {
 	if (typeof id !== "number" && typeof id !== "string") return null;
@@ -27016,4 +27063,4 @@ function createHeadlessEditor(options) {
 	return new HeadlessEditor(options);
 }
 //#endregion
-export { DEFAULT_HEADLESS_EDITOR_PLUGINS, HeadlessEditor, createHeadlessEditor };
+export { DEFAULT_HEADLESS_EDITOR_PLUGINS, HeadlessEditor, createHeadlessEditor, extractMediaFromEditorState };

package/es/{index-DJq7pYS0.d.ts → index-DHGp94p0.d.ts}

@@ -1,10 +1,10 @@
+import { DropdownMenuItemType } from "@lobehub/ui";
+import * as _$react from "react";
+import { CSSProperties, CompositionEvent, FC, FocusEvent, MouseEvent, ReactElement, ReactNode } from "react";
 import { HistoryState, HistoryStateEntry } from "@lexical/history";
 import * as _$lexical from "lexical";
 import { CommandListener, CommandListenerPriority, CommandPayloadType, DOMConversionMap, DOMExportOutput, DecoratorNode, EditorConfig, EditorState, ElementNode, LexicalCommand, LexicalEditor, LexicalNode, LexicalNodeConfig, LexicalUpdateJSON, RangeSelection, SerializedLexicalNode, Spread, TextNode } from "lexical";
 import { HeadingTagType } from "@lexical/rich-text";
-import * as _$react from "react";
-import { CSSProperties, CompositionEvent, FC, FocusEvent, MouseEvent, ReactElement, ReactNode } from "react";
-import { DropdownMenuItemType } from "@lobehub/ui";
 import Fuse, { IFuseOptions } from "fuse.js";
 
 //#region src/editor-kernel/data-source.d.ts
@@ -114,7 +114,6 @@ declare const _default: {
   };
   cancel: string;
   codemirror: {
-    copyFailed: string;
     copySuccess: string;
     selectLanguage: string;
     selectTheme: string;