Web前端架构：Monaco Editor与协同编辑

// Monaco Editor的核心能力矩阵
const monacoCapabilities = {
    // 语法和语义支持
    syntaxHighlighting: true,      // 50+语言语法高亮
    autoCompletion: true,          // 智能补全
    errorDiagnostics: true,         // 实时错误诊断
    codeFormatting: true,           // 代码格式化
    
    // 高级编辑功能
    multiCursor: true,              // 多光标编辑
    findReplace: true,              // 查找替换
    codeFolding: true,             // 代码折叠
    minimap: true,                  // 小地图
    
    // 协作支持
    operationalTransform: false,    // OT已被CRDT取代
    crdtIntegration: true,          // Y.js集成支持
    awarenessProtocol: true          // 状态感知协议
};

├── Monaco Editor集成与配置
│   ├── 编辑器初始化配置
│   ├── 主题系统与定制
│   └── 扩展机制与插件开发
├── 语言支持体系
│   ├── 语法高亮实现
│   ├── 智能补全系统
│   └── 错误诊断与修复
├── 协同编辑原理与实现
│   ├── CRDT理论基础
│   ├── Y.js核心概念
│   └── 协同编辑实战
├── 性能优化策略
│   ├── 虚拟滚动实现
│   ├── 大文件处理
│   └── WebWorker优化
├── WebAssembly加速
│   ├── WASM与JS性能对比
│   ├── 计算密集型任务卸载
│   └── 实践案例
└── 完整实践：协同编辑器实现

// Monaco Editor核心类型定义
interface MonacoEditorCore {
    // 模型层：代码数据
    ITextModel: {
        getValue(): string;
        getLineCount(): number;
        getLineContent(lineNumber: number): string;
        getWordAtPosition(position: IPosition): IWordAtPosition;
        findMatches(pattern: string): FindMatch[];
    };
    
    // 视图层：渲染与交互
    ICodeEditor: {
        getDomNode(): HTMLElement;
        layout(): void;
        render(): void;
        getScrollTop(): number;
        setScrollTop(scrollTop: number): void;
    };
    
    // 命令系统
    ICommand: {
        id: number;
        execute(): void;
    };
}

// Monaco Editor完整配置
const editorOptions = {
    // 基础设置
    value: '// your code here',
    language: 'javascript',
    theme: 'vs-dark',
    
    // 自动格式化与补全
    automaticLayout: true,        // 自动调整布局
    autoClosingBrackets: 'always', // 自动闭合括号
    autoClosingQuotes: 'always',  // 自动闭合引号
    formatOnPaste: true,          // 粘贴时格式化
    formatOnType: true,           // 输入时格式化
    
    // 编辑体验
    tabSize: 4,                   // Tab宽度
    insertSpaces: true,           // 使用空格代替Tab
    wordWrap: 'off',              // 自动换行
    lineNumbers: 'on',            // 行号显示
    minimap: {
        enabled: true,            // 启用小地图
        maxColumn: 80             // 小地图最大宽度
    },
    
    // 滚动条设置
    scrollBeyondLastLine: false,
    smoothScrolling: true,
    mouseWheelZoom: true,
    
    // 字体设置
    fontFamily: "'Fira Code', Consolas, 'Courier New', monospace",
    fontLigatures: true,          // 连字符
    fontSize: 14,
    fontWeight: 'normal',
    
    // 光标设置
    cursorBlinking: 'smooth',
    cursorSmoothCaretAnimation: 'on',
    cursorStyle: 'line',
    cursorWidth: 2,
    
    // 选择与查找
    occurrencesHighlight: 'singleFile',
    renderLineHighlight: 'all',
    selectionHighlight: true,
    find: {
        seedSearchStringFromSelection: 'always',
        autoSearchInWholeFile: true
    },
    
    // 语法与验证
    renderWhitespace: 'selection',
    guides: {
        bracketPairs: true,
        indentation: true
    },
    
    // 性能相关
    largeFileOptimization: true,
    maxTokenizationLineLength: 20000,
    
    // 快捷键
    contextmenu: true,
    copyWithSyntaxHighlighting: true,
    
    // 协同编辑相关
    readOnly: false,
    domReadOnly: false
};

// Monaco Editor初始化完整实现
class MonacoEditorManager {
    constructor(container) {
        this.container = container;
        this.editor = null;
        this.models = new Map();
        this.disposables = [];
    }
    
    async initialize(options = {}) {
        // 加载Monaco Editor
        const monaco = await this.loadMonaco();
        
        // 定义自定义主题
        this.defineCustomTheme(monaco);
        
        // 注册自定义语言
        this.registerCustomLanguage(monaco);
        
        // 创建编辑器实例
        this.editor = monaco.editor.create(this.container, {
            ...this.getDefaultOptions(),
            ...options
        });
        
        // 设置编辑器事件
        this.setupEventHandlers();
        
        // 初始化语言服务
        await this.initializeLanguageServices();
        
        return this.editor;
    }
    
    loadMonaco() {
        return new Promise((resolve, reject) => {
            // 检测是否已加载
            if (window.monaco) {
                resolve(window.monaco);
                return;
            }
            
            // 动态加载AMDLoader
            const loaderScript = document.createElement('script');
            loaderScript.src = 'https://cdn.jsdelivr.net/npm/monaco-editor@0.45.0/min/vs/loader.js';
            loaderScript.onload = () => {
                require.config({
                    paths: {
                        'vs': 'https://cdn.jsdelivr.net/npm/monaco-editor@0.45.0/min/vs'
                    }
                });
                
                require(['vs/editor/editor.main'], () => {
                    resolve(window.monaco);
                });
            };
            loaderScript.onerror = reject;
            document.head.appendChild(loaderScript);
        });
    }
    
    getDefaultOptions() {
        return {
            value: '',
            language: 'plaintext',
            theme: 'custom-dark',
            automaticLayout: true,
            fontSize: 14,
            tabSize: 4,
            insertSpaces: true,
            wordWrap: 'off',
            lineNumbers: 'on',
            minimap: { enabled: true },
            scrollBeyondLastLine: false,
            smoothScrolling: true,
            cursorBlinking: 'smooth',
            cursorSmoothCaretAnimation: 'on',
            renderWhitespace: 'selection',
            bracketPairColorization: { enabled: true },
            guides: {
                bracketPairs: true,
                indentation: true
            },
            padding: { top: 10, bottom: 10 },
            scrollbar: {
                vertical: 'visible',
                horizontal: 'visible',
                verticalScrollbarSize: 14,
                horizontalScrollbarSize: 14
            }
        };
    }
    
    defineCustomTheme(monaco) {
        monaco.editor.defineTheme('custom-dark', {
            base: 'vs-dark',
            inherit: true,
            rules: [
                { token: 'comment', foreground: '6A9955', fontStyle: 'italic' },
                { token: 'keyword', foreground: '569CD6' },
                { token: 'string', foreground: 'CE9178' },
                { token: 'number', foreground: 'B5CEA8' },
                { token: 'type', foreground: '4EC9B0' },
                { token: 'function', foreground: 'DCDCAA' },
                { token: 'variable', foreground: '9CDCFE' },
                { token: 'operator', foreground: 'D4D4D4' }
            ],
            colors: {
                'editor.background': '#1E1E1E',
                'editor.foreground': '#D4D4D4',
                'editor.lineHighlightBackground': '#2D2D30',
                'editor.selectionBackground': '#264F78',
                'editorCursor.foreground': '#AEAFAD',
                'editorLineNumber.foreground': '#858585',
                'editorLineNumber.activeForeground': '#C6C6C6'
            }
        });
    }
    
    registerCustomLanguage(monaco) {
        // 注册自定义语言：Petal
        monaco.languages.register({ id: 'petal' });
        
        // 定义词法规则
        monaco.languages.setMonarchTokensProvider('petal', {
            tokenizer: {
                root: [
                    [/\/\/.*$/, 'comment'],
                    [/\/\*/, 'comment', '@comment'],
                    [/"([^"\\]|\\.)*"/, 'string'],
                    [/'([^'\\]|\\.)*'/, 'string'],
                    [/\b(func|var|let|const|if|else|for|while|return|class|struct|enum|import|from|as|pub|mod|trait|impl|self|super|crate|where|match|loop|break|continue|async|await|move|ref|move|static|mut|unsafe|extern|dyn)\b/, 'keyword'],
                    [/\b(i8|i16|i32|i64|i128|isize|u8|u16|u32|u64|u128|usize|f32|f64|bool|char|str|String|Vec|Option|Result|Box|Rc|Arc|Cell|RefCell)\b/, 'type'],
                    [/\b(true|false|nil|null|void)\b/, 'constant'],
                    [/[a-zA-Z_]\w*/, {
                        cases: {
                            '@keywords': 'keyword',
                            '@default': 'identifier'
                        }
                    }],
                    [/[=!<>+\-*/%&|^~?:]+/, 'operator'],
                    [/\d+\.\d+/, 'number.float'],
                    [/\d+/, 'number'],
                    [/[{}()\[\]]/, 'delimiter.bracket'],
                    [/[;,.]/, 'delimiter']
                ],
                comment: [
                    [/[^*/]+/, 'comment'],
                    [/\*\//, 'comment', '@pop'],
                    [/\*/, 'comment']
                ]
            }
        });
        
        // 定义语言配置
        monaco.languages.setLanguageConfiguration('petal', {
            comments: {
                lineComment: '//',
                blockComment: ['/*', '*/']
            },
            brackets: [['{', '}'], ['[', ']'], ['(', ')'], ['<', '>']],
            autoClosingPairs: [
                { open: '{', close: '}' },
                { open: '[', close: ']' },
                { open: '(', close: ')' },
                { open: '"', close: '"' },
                { open: "'", close: "'" }
            ],
            surroundingPairs: [
                { open: '{', close: '}' },
                { open: '[', close: ']' },
                { open: '(', close: ')' },
                { open: '"', close: '"' }
            ]
        });
    }
    
    setupEventHandlers() {
        // 内容变更事件
        this.editor.onDidChangeModelContent((e) => {
            console.log('Content changed:', e);
            this.onContentChanged(e);
        });
        
        // 光标位置变更
        this.editor.onDidChangeCursorPosition((e) => {
            console.log('Cursor moved:', e.position);
            this.onCursorChanged(e);
        });
        
        // 选择变更
        this.editor.onDidChangeCursorSelection((e) => {
            console.log('Selection changed:', e.selection);
            this.onSelectionChanged(e);
        });
        
        // 滚动事件
        this.editor.onDidScrollChange((e) => {
            this.onScrollChanged(e);
        });
        
        // 布局变更
        this.editor.onDidLayoutChange((e) => {
            console.log('Layout changed:', e);
        });
    }
    
    onContentChanged(changeEvent) {
        // 触发协同编辑同步
        if (this.collaborationProvider) {
            this.collaborationProvider.notifyChange(changeEvent);
        }
    }
    
    onCursorChanged(positionEvent) {
        // 更新远程用户光标位置
        if (this.awareness) {
            this.awareness.setLocalStateField('cursor', positionEvent.position);
        }
    }
    
    onSelectionChanged(selectionEvent) {
        // 处理选择变更
    }
    
    onScrollChanged(scrollEvent) {
        // 处理滚动同步
    }
    
    async initializeLanguageServices() {
        // 加载语言服务器
        const languageId = this.editor.getModel()?.getLanguageId();
        if (languageId && this.languageClients.has(languageId)) {
            const client = this.languageClients.get(languageId);
            await client.start();
        }
    }
    
    getEditor() {
        return this.editor;
    }
    
    getModel() {
        return this.editor?.getModel();
    }
    
    setValue(value) {
        if (this.editor) {
            this.editor.setValue(value);
        }
    }
    
    getValue() {
        return this.editor?.getModel()?.getValue() || '';
    }
    
    dispose() {
        // 清理资源
        this.models.forEach(model => model.dispose());
        this.models.clear();
        
        this.disposables.forEach(d => d.dispose());
        this.disposables = [];
        
        if (this.editor) {
            this.editor.dispose();
            this.editor = null;
        }
    }
}

// 使用示例
const container = document.getElementById('editor-container');
const manager = new MonacoEditorManager(container);
manager.initialize({
    value: '// Welcome to Petal IDE\nfunc main() {\n    println("Hello, World!");\n}',
    language: 'petal'
}).then(editor => {
    console.log('Monaco Editor initialized successfully');
    // 进一步配置...
});

// 高对比度主题配置
const highContrastTheme = {
    base: 'hc-black',
    inherit: false,
    rules: [
        // 注释
        { token: 'comment', foreground: '608B4E', fontStyle: 'italic' },
        // 关键字
        { token: 'keyword', foreground: '569CD6', fontStyle: 'bold' },
        // 字符串
        { token: 'string', foreground: 'CE9178' },
        // 数字
        { token: 'number', foreground: 'B5CEA8' },
        // 类型
        { token: 'type', foreground: '4EC9B0', fontStyle: 'bold' },
        // 函数
        { token: 'function', foreground: 'DCDCAA' },
        // 变量
        { token: 'variable', foreground: '9CDCFE' },
        // 操作符
        { token: 'operator', foreground: 'D4D4D4' },
        // 标识符
        { token: 'identifier', foreground: 'D4D4D4' },
        // 常量
        { token: 'constant', foreground: '4FC1FF' }
    ],
    colors: {
        // 编辑器背景
        'editor.background': '#000000',
        'editor.foreground': '#D4D4D4',
        
        // 光标
        'editorCursor.foreground': '#AEAFAD',
        'editorCursor.background': '#000000',
        
        // 行号
        'editorLineNumber.foreground': '#6E6E6E',
        'editorLineNumber.activeForeground': '#C6C6C6',
        
        // 选中行高亮
        'editor.lineHighlightBackground': '#1A1A1A',
        'editor.lineHighlightBorder': '#1A1A1A',
        
        // 选择
        'editor.selectionBackground': '#264F78',
        'editor.inactiveSelectionBackground': '#3A3D41',
        
        // 当前行选择
        'editor.selectionHighlightBackground': '#ADD6FF40',
        
        // 单词选择高亮
        'editor.wordHighlightBackground': '#575757',
        'editor.wordHighlightBorder': '#424242',
        'editor.wordHighlightStrongBackground': '#663300',
        
        // 查找匹配
        'editor.findMatchBackground': '#A8AC94',
        'editor.findMatchHighlightBackground': '#EA5C0055',
        'editor.findMatchRangeHighlightBackground': '#EA5C0055',
        
        // 缩进参考线
        'editorIndentGuide.background': '#404040',
        'editorIndentGuide.activeBackground': '#707070',
        
        // 括号匹配
        'editorBracketMatch.background': '#0064001A',
        'editorBracketMatch.border': '#888888',
        
        // 链接
        'editorLink.foreground': '#4EC9B0',
        'editorHoverWidget.background': '#1E1E1E',
        'editorHoverWidget.border': '#454545',
        
        // 小地图
        'minimap.background': '#1E1E1E',
        
        // 滚动条
        'scrollbarSlider.background': '#79797966',
        'scrollbarSlider.hoverBackground': '#646464B3',
        'scrollbarSlider.activeBackground': '#BFBFBF66',
        
        // 建议窗口
        'editorSuggestWidget.background': '#1E1E1E',
        'editorSuggestWidget.border': '#454545',
        'editorSuggestWidget.foreground': '#D4D4D4',
        'editorSuggestWidget.selectedBackground': '#094767',
        'editorSuggestWidget.highlightForeground': '#4EC9B0',
        
        // 参数提示
        'editorParameterHint.foreground': '#D4D4D4',
        'editorParameterHint.background': '#1E1E1E',
        'editorParameterHint.border': '#454545',
        
        // 诊断错误
        'editorError.foreground': '#F14C4C',
        'editorWarning.foreground': '#CCA700',
        'editorInfo.foreground': '#3794FF',
        'editorHint.foreground': '#B3B3B3',
        
        // 折叠
        'editorGutter.background': '#1E1E1E',
        'editorBracketHighlight.foreground1': '#FFD700',
        'editorBracketHighlight.foreground2': '#DA70D6',
        'editorBracketHighlight.foreground3': '#00CED1'
    }
};

// 注册主题
monaco.editor.defineTheme('high-contrast-custom', highContrastTheme);

// 动态切换主题
function switchTheme(themeName) {
    monaco.editor.setTheme(themeName);
}

// 获取当前主题
function getCurrentTheme() {
    return monaco.editor.getTheme();
}

// Monaco Editor扩展开发框架
class MonacoExtensionFramework {
    constructor(monaco) {
        this.monaco = monaco;
        this.extensions = new Map();
    }
    
    // 注册自定义代码补全提供者
    registerCompletionProvider(languageId, provider) {
        const disposable = this.monaco.languages.registerCompletionItemProvider(
            languageId,
            {
                triggerCharacters: ['.', ':', '<', '"', '/'],
                provideCompletionItems: (model, position, context) => {
                    return this.createCompletionResult(model, position, context, provider);
                },
                resolveCompletionItem: (item, token) => {
                    return this.resolveCompletionItem(item, token, provider);
                }
            }
        );
        this.extensions.set(`completion-${languageId}`, disposable);
        return disposable;
    }
    
    createCompletionResult(model, position, context, provider) {
        const wordInfo = model.getWordUntilPosition(position);
        const range = {
            startLineNumber: position.lineNumber,
            endLineNumber: position.lineNumber,
            startColumn: wordInfo.startColumn,
            endColumn: wordInfo.endColumn
        };
        
        const suggestions = provider.getCompletions(model, position, context);
        
        return {
            suggestions: suggestions.map(s => ({
                ...s,
                range: range
            })),
            incomplete: provider.incomplete || false
        };
    }
    
    resolveCompletionItem(item, token, provider) {
        if (provider.resolveCompletionItem) {
            return provider.resolveCompletionItem(item, token);
        }
        return item;
    }
    
    // 注册悬停提示提供者
    registerHoverProvider(languageId, provider) {
        const disposable = this.monaco.languages.registerHoverProvider(
            languageId,
            {
                provideHover: (model, position, token) => {
                    return provider.getHover(model, position, token);
                }
            }
        );
        this.extensions.set(`hover-${languageId}`, disposable);
        return disposable;
    }
    
    // 注册诊断信息提供者
    registerDiagnosticsProvider(languageId, provider) {
        const disposable = this.monaco.languages.registerCodeActionProvider(
            languageId,
            {
                provideCodeActions: (model, range, context, token) => {
                    return provider.getCodeActions(model, range, context, token);
                }
            }
        );
        this.extensions.set(`diagnostics-${languageId}`, disposable);
        return disposable;
    }
    
    // 注册折叠区域提供者
    registerFoldingProvider(languageId, provider) {
        const disposable = this.monaco.languages.registerFoldingRangeProvider(
            languageId,
            {
                provideFoldingRanges: (model, context, token) => {
                    return provider.getFoldingRanges(model, context, token);
                }
            }
        );
        this.extensions.set(`folding-${languageId}`, disposable);
        return disposable;
    }
    
    // 注册格式化提供者
    registerFormattingProvider(languageId, provider) {
        const disposable = this.monaco.languages.registerDocumentFormattingEditProvider(
            languageId,
            {
                provideDocumentFormattingEdits: (model, options, token) => {
                    return provider.formatDocument(model, options, token);
                }
            }
        );
        this.extensions.set(`formatting-${languageId}`, disposable);
        return disposable;
    }
    
    // 注册跳转到定义提供者
    registerDefinitionProvider(languageId, provider) {
        const disposable = this.monaco.languages.registerDefinitionProvider(
            languageId,
            {
                provideDefinition: (model, position, token) => {
                    return provider.getDefinition(model, position, token);
                }
            }
        );
        this.extensions.set(`definition-${languageId}`, disposable);
        return disposable;
    }
    
    // 注册引用查找提供者
    registerReferenceProvider(languageId, provider) {
        const disposable = this.monaco.languages.registerReferenceProvider(
            languageId,
            {
                provideReferences: (model, position, context, token) => {
                    return provider.getReferences(model, position, context, token);
                }
            }
        );
        this.extensions.set(`reference-${languageId}`, disposable);
        return disposable;
    }
    
    // 注册重命名提供者
    registerRenameProvider(languageId, provider) {
        const disposable = this.monaco.languages.registerRenameProvider(
            languageId,
            {
                provideRenameEdits: (model, position, newName, token) => {
                    return provider.provideRenameEdits(model, position, newName, token);
                }
            }
        );
        this.extensions.set(`rename-${languageId}`, disposable);
        return disposable;
    }
    
    // 注册动作提供者
    registerCodeActionProvider(languageId, provider) {
        const disposable = this.monaco.languages.registerCodeActionProvider(
            languageId,
            {
                provideCodeActions: (model, range, context, token) => {
                    return provider.getCodeActions(model, range, context, token);
                }
            }
        );
        this.extensions.set(`codeAction-${languageId}`, disposable);
        return disposable;
    }
    
    // 批量注册语言扩展
    registerLanguageExtension(languageId, extensionConfig) {
        const disposables = [];
        
        if (extensionConfig.completionProvider) {
            disposables.push(
                this.registerCompletionProvider(languageId, extensionConfig.completionProvider)
            );
        }
        
        if (extensionConfig.hoverProvider) {
            disposables.push(
                this.registerHoverProvider(languageId, extensionConfig.hoverProvider)
            );
        }
        
        if (extensionConfig.diagnosticsProvider) {
            disposables.push(
                this.registerDiagnosticsProvider(languageId, extensionConfig.diagnosticsProvider)
            );
        }
        
        if (extensionConfig.foldingProvider) {
            disposables.push(
                this.registerFoldingProvider(languageId, extensionConfig.foldingProvider)
            );
        }
        
        if (extensionConfig.formattingProvider) {
            disposables.push(
                this.registerFormattingProvider(languageId, extensionConfig.formattingProvider)
            );
        }
        
        if (extensionConfig.definitionProvider) {
            disposables.push(
                this.registerDefinitionProvider(languageId, extensionConfig.definitionProvider)
            );
        }
        
        if (extensionConfig.referenceProvider) {
            disposables.push(
                this.registerReferenceProvider(languageId, extensionConfig.referenceProvider)
            );
        }
        
        if (extensionConfig.renameProvider) {
            disposables.push(
                this.registerRenameProvider(languageId, extensionConfig.renameProvider)
            );
        }
        
        return {
            dispose: () => {
                disposables.forEach(d => d.dispose());
            }
        };
    }
    
    dispose() {
        this.extensions.forEach(disposable => disposable.dispose());
        this.extensions.clear();
    }
}

// JavaScript/Monarch词法配置
monaco.languages.setMonarchTokensProvider('javascript', {
    // 默认变量
    defaultToken: '',
    ignoreCase: false,
    tokenPostfix: '.js',
    
    // 关键词
    keywords: [
        'break', 'case', 'catch', 'continue', 'debugger', 'default',
        'delete', 'do', 'else', 'export', 'extends', 'finally',
        'for', 'function', 'if', 'import', 'in', 'instanceof',
        'new', 'return', 'switch', 'this', 'throw', 'try',
        'typeof', 'var', 'void', 'while', 'with', 'yield',
        'class', 'const', 'enum', 'let', 'static', 'super',
        'implements', 'interface', 'package', 'private', 'protected',
        'public', 'abstract', 'as', 'async', 'await', 'from',
        'get', 'of', 'set', 'target', 'type', 'namespace'
    ],
    
    // 类型
    typeKeywords: [
        'any', 'boolean', 'double', 'dynamic', 'int', 'null',
        'num', 'Object', 'String', 'void', 'Never', 'unknown',
        'undefined', 'bigint', 'symbol'
    ],
    
    // 操作符
    operators: [
        '=', '>', '<', '!', '~', '?', ':',
        '==', '<=', '>=', '!=', '&&', '||', '++', '--',
        '+', '-', '*', '/', '&', '|', '^', '%', '<<',
        '>>', '>>>', '+=', '-=', '*=', '/=', '&=', '|=',
        '^=', '%=', '<<=', '>>=', '>>>='
    ],
    
    // 符号
    symbols: /[=><!~?:&|+\-*\/\^%]+/,
    
    // 转义字符
    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
    
    // 整数
    integers: /0[xX][0-9a-fA-F]+|0[oO][0-7]+|0[bB][01]+|(?:\d(?:_?\d)*))(?:\.\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?/,
    
    // 浮点数
    floats: /(?:\d(?:_?\d)*)?\.(?:\d(?:_?\d)*)?(?:[eE][+-]?\d(?:_?\d)*)?/,
    
    // 词法分析器
    tokenizer: {
        root: [
            // 标识符和关键字
            [/[a-zA-Z_$][\w$]*/, {
                cases: {
                    '@keywords': 'keyword',
                    '@typeKeywords': 'type',
                    '@default': 'identifier'
                }
            }],
            
            // 分隔符
            [/[{}()\[\]]/, '@brackets'],
            [/[<>](?!@symbols)/, '@brackets'],
            
            // 分号和逗号
            [/[;,.]/, 'delimiter'],
            
            // 操作符
            [/@symbols/, {
                cases: {
                    '@operators': 'operator',
                    '@default': ''
                }
            }],
            
            // 数字
            [/0[xX][0-9a-fA-F]+/, 'number.hex'],
            [/0[oO][0-7]+/, 'number.octal'],
            [/0[bB][01]+/, 'number.binary'],
            [/(@integers)((?:_[0-9]+)*)/, ['number', 'number']],
            [/(@integers)?\.(@floats)((?:_[0-9]+)*)/, ['number', 'number.float', 'number']],
            
            // 字符串
            [/"([^"\\]|@escapes)*"/, 'string'],
            [/'([^'\\]|@escapes)*'/, 'string'],
            [/`([^`\\]|@escapes)*`/, 'string.template'],
            
            // 注释
            [/\/\/.*$/, 'comment'],
            [/\/\*/, 'comment', '@comment'],
            
            // 正则表达式
            [/\/(?!\{)[^\/\\]*(?:\\.[^\/\\]*)*\/[gimsuy]*/, 'regexp'],
            
            // HTML/XML
            [/<[^>]+>/, 'tag']
        ],
        
        comment: [
            [/[^\/*]+/, 'comment'],
            [/\/\*/, 'comment', '@push'],
            [/\*\/, 'comment', '@pop'],
            [/[\/*]/, 'comment']
        ]
    }
});

// 语言配置
monaco.languages.setLanguageConfiguration('javascript', {
    comments: {
        lineComment: '//',
        blockComment: ['/*', '*/']
    },
    brackets: [
        ['{', '}'],
        ['[', ']'],
        ['(', ')']
    ],
    autoClosingPairs: [
        { open: '{', close: '}', notIn: ['string', 'comment'] },
        { open: '[', close: ']', notIn: ['string', 'comment'] },
        { open: '(', close: ')', notIn: ['string', 'comment'] },
        { open: '"', close: '"', notIn: ['string', 'comment'] },
        { open: "'", close: "'", notIn: ['string', 'comment'] },
        { open: '`', close: '`', notIn: ['string', 'comment'] },
        { open: '/**', close: ' */', notIn: ['string', 'comment'] }
    ],
    surroundingPairs: [
        { open: '{', close: '}' },
        { open: '[', close: ']' },
        { open: '(', close: ')' },
        { open: '"', close: '"' },
        { open: "'", close: "'" },
        { open: '`', close: '`'}
    ],
    indentationRules: {
        increaseIndentPattern: /^\s*(\{|\[|(\b(else|finally|catch)\b(?!.*\)))\s*|(\}\s*else\b)|(\}\s*finally\b)|(\}\s*catch\b))/,
        decreaseIndentPattern: /^\s*((\}|\])|\b(else|catch|finally)\b(?!\s*{))/
    },
    folding: {
        markers: {
            start: /^\s*(\{|\[)/,
            end: /^\s*(\}|\])/
        }
    }
});

// Monaco智能补全系统
class SmartCompletionSystem {
    constructor(monaco) {
        this.monaco = monaco;
        this.providers = new Map();
        this.snippets = new Map();
        this.cache = new Map();
    }
    
    // 注册补全提供者
    registerProvider(languageId, provider) {
        const disposable = this.monaco.languages.registerCompletionItemProvider(
            languageId,
            {
                triggerCharacters: ['.', ':', '<', '"', '/', '@', '#'],
                supportInlineHighlights: true,
                provideCompletionItems: (model, position, context, token) => {
                    return this.provideCompletions(model, position, context, token, provider);
                },
                resolveCompletionItem: (item, token) => {
                    return this.resolveCompletionItem(item, token, provider);
                }
            }
        );
        
        this.providers.set(languageId, provider);
        return disposable;
    }
    
    async provideCompletions(model, position, context, token, provider) {
        // 获取补全上下文
        const completionContext = this.extractContext(model, position, context);
        
        // 检查缓存
        const cacheKey = this.getCacheKey(model, position, completionContext);
        if (this.cache.has(cacheKey)) {
            return this.cache.get(cacheKey);
        }
        
        // 获取补全项
        let items = [];
        
        // 1. 词法级补全（关键字、符号）
        items.push(...this.getLexicalCompletions(completionContext));
        
        // 2. 语义级补全（标识符、类型）
        if (provider.getSemanticCompletions) {
            items.push(...await provider.getSemanticCompletions(completionContext, token));
        }
        
        // 3. 片段补全（Snippet）
        items.push(...this.getSnippetCompletions(completionContext));
        
        // 4. 路径补全（导入语句）
        if (completionContext.inImport) {
            items.push(...await this.getPathCompletions(completionContext));
        }
        
        // 排序和过滤
        items = this.rankAndFilter(items, completionContext);
        
        // 转换为Monaco格式
        const result = this.convertToMonacoFormat(items, model, position);
        
        // 缓存结果
        this.cache.set(cacheKey, result);
        
        return result;
    }
    
    extractContext(model, position, context) {
        const lineContent = model.getLineContent(position.lineNumber);
        const beforeCursor = lineContent.substring(0, position.column - 1);
        
        // 提取当前单词
        const wordMatch = beforeCursor.match(/(\w+)$/);
        const currentWord = wordMatch ? wordMatch[1] : '';
        const prefix = currentWord;
        
        // 检测是否在字符串内
        const inString = this.isInString(lineContent, position.column - 1);
        
        // 检测是否在注释内
        const inComment = this.isInComment(lineContent, position.column - 1);
        
        // 检测导入语句
        const inImport = /^(\s*)(import|from|require)\s/.test(beforeCursor);
        
        return {
            model,
            position,
            lineContent,
            beforeCursor,
            currentWord,
            prefix,
            inString,
            inComment,
            inImport,
            triggerCharacter: context.triggerCharacter,
            triggerKind: context.triggerKind
        };
    }
    
    isInString(line, column) {
        let inString = false;
        let stringChar = null;
        
        for (let i = 0; i < column; i++) {
            const char = line[i];
            if (char === stringChar) {
                inString = false;
                stringChar = null;
            } else if (!inString && (char === '"' || char === "'" || char === '`')) {
                inString = true;
                stringChar = char;
            } else if (char === '\\' && inString) {
                i++;
            }
        }
        
        return inString;
    }
    
    isInComment(line, column) {
        const beforeCursor = line.substring(0, column);
        return beforeCursor.includes('//') || beforeCursor.includes('/*');
    }
    
    getCacheKey(model, position, context) {
        const offset = model.getOffsetAt(position);
        return `${model.getURI().toString()}:${offset}:${context.prefix}:${context.triggerCharacter}`;
    }
    
    getLexicalCompletions(context) {
        const completions = [];
        
        // JavaScript关键字
        const keywords = {
            'async': { detail: 'async function', insertText: 'async ' },
            'await': { detail: 'await expression', insertText: 'await ' },
            'function': { detail: 'function declaration', insertText: 'function ${1:name}($2) {\n\t$0\n}' },
            'const': { detail: 'constant declaration', insertText: 'const ${1:name} = $0;' },
            'class': { detail: 'class declaration', insertText: 'class ${1:name} {\n\t$0\n}' },
            'import': { detail: 'import statement', insertText: "import { $0 } from '${1:module}';" },
            'export': { detail: 'export statement', insertText: 'export ' },
            'if': { detail: 'if statement', insertText: 'if ($1) {\n\t$0\n}' },
            'for': { detail: 'for loop', insertText: 'for (let ${1:i} = 0; ${1:i} < ${2:length}; ${1:i}++) {\n\t$0\n}' },
            'try': { detail: 'try-catch block', insertText: 'try {\n\t$1\n} catch (${2:error}) {\n\t$0\n}' },
            'null': { detail: 'null value', insertText: 'null' },
            'undefined': { detail: 'undefined value', insertText: 'undefined' },
            'true': { detail: 'boolean true', insertText: 'true' },
            'false': { detail: 'boolean false', insertText: 'false' }
        };
        
        const lowerPrefix = context.prefix.toLowerCase();
        
        Object.entries(keywords).forEach(([keyword, meta]) => {
            if (!context.prefix || keyword.startsWith(lowerPrefix)) {
                completions.push({
                    label: keyword,
                    kind: this.monaco.languages.CompletionItemKind.Keyword,
                    detail: meta.detail,
                    insertText: meta.insertText,
                    insertTextRules: meta.insertText.includes('${') 
                        ? this.monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet 
                        : undefined,
                    range: {
                        startLineNumber: context.position.lineNumber,
                        endLineNumber: context.position.lineNumber,
                        startColumn: context.position.column - context.prefix.length,
                        endColumn: context.position.column
                    },
                    sortText: `1_${keyword}`
                });
            }
        });
        
        return completions;
    }
    
    getSnippetCompletions(context) {
        const snippets = [
            { label: 'log', detail: 'console.log', insertText: "console.log($0);" },
            { label: 'warn', detail: 'console.warn', insertText: "console.warn($0);" },
            { label: 'error', detail: 'console.error', insertText: "console.error($0);" },
            { label: 'trycatch', detail: 'try-catch block', insertText: "try {\n\t$1\n} catch (${2:error}) {\n\tconsole.error(${2:error});\n\t$0\n}" },
            { label: 'fore', detail: 'forEach loop', insertText: "${1:array}.forEach((${2:item}) => {\n\t$0\n});" },
            { label: 'prom', detail: 'Promise', insertText: "new Promise((resolve, reject) => {\n\t$0\n});" },
            { label: 'af', detail: 'async function', insertText: "async function ${1:name}($2) {\n\t$0\n}" },
            { label: 'cl', detail: 'class', insertText: "class ${1:ClassName} {\n\tconstructor($2) {\n\t\t$0\n\t}\n}" },
            { label: 'im', detail: 'import', insertText: "import { $0 } from '${1:module}';" },
            { label: 'todo', detail: 'TODO comment', insertText: "// TODO: $0" }
        ];
        
        const lowerPrefix = context.prefix.toLowerCase();
        return snippets
            .filter(s => !context.prefix || s.label.startsWith(lowerPrefix))
            .map(s => ({
                label: s.label,
                kind: this.monaco.languages.CompletionItemKind.Snippet,
                detail: s.detail,
                insertText: s.insertText,
                insertTextRules: this.monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
                range: {
                    startLineNumber: context.position.lineNumber,
                    endLineNumber: context.position.lineNumber,
                    startColumn: context.position.column - context.prefix.length,
                    endColumn: context.position.column
                },
                sortText: `2_${s.label}`
            }));
    }
    
    async getPathCompletions(context) {
        const suggestions = [];
        const pathMatch = context.beforeCursor.match(/from\s+['"]([^'"]*?)['"]$/);
        
        if (!pathMatch) return suggestions;
        
        const partialPath = pathMatch[1];
        const pathSuggestions = [
            { label: './components', detail: 'Directory' },
            { label: './utils', detail: 'Directory' },
            { label: './hooks', detail: 'Directory' },
            { label: 'react', detail: 'npm package' },
            { label: 'react-dom', detail: 'npm package' },
            { label: 'lodash', detail: 'npm package' }
        ];
        
        pathSuggestions.forEach(s => {
            if (s.label.startsWith(partialPath)) {
                suggestions.push({
                    label: s.label,
                    kind: s.detail === 'npm package' 
                        ? this.monaco.languages.CompletionItemKind.Module
                        : this.monaco.languages.CompletionItemKind.Folder,
                    detail: s.detail,
                    insertText: s.label.substring(partialPath.length),
                    range: {
                        startLineNumber: context.position.lineNumber,
                        endLineNumber: context.position.lineNumber,
                        startColumn: context.position.column - partialPath.length,
                        endColumn: context.position.column
                    }
                });
            }
        });
        
        return suggestions;
    }
    
    rankAndFilter(items, context) {
        return items.map(item => {
            let score = 0;
            const label = item.label.toLowerCase();
            const prefix = context.prefix.toLowerCase();
            
            if (label === prefix) score += 100;
            else if (label.startsWith(prefix)) score += 50;
            else if (label.includes(prefix)) score += 20;
            
            switch (item.kind) {
                case this.monaco.languages.CompletionItemKind.Keyword:
                    score += 5; break;
                case this.monaco.languages.CompletionItemKind.Snippet:
                    score += 3; break;
                case this.monaco.languages.CompletionItemKind.Method:
                    score += 8; break;
            }
            
            return { ...item, score };
        }).sort((a, b) => b.score - a.score);
    }
    
    convertToMonacoFormat(items, model, position) {
        const wordInfo = model.getWordUntilPosition(position);
        
        return {
            suggestions: items.map(item => ({
                ...item,
                range: item.range || {
                    startLineNumber: position.lineNumber,
                    endLineNumber: position.lineNumber,
                    startColumn: wordInfo.startColumn,
                    endColumn: wordInfo.endColumn
                }
            })),
            incomplete: items.length > 100
        };
    }
    
    resolveCompletionItem(item, token, provider) {
        if (provider.resolveCompletionItem) {
            return provider.resolveCompletionItem(item, token);
        }
        return item;
    }
}

// Monaco诊断与修复系统
class DiagnosticSystem {
    constructor(monaco) {
        this.monaco = monaco;
        this.markers = new Map();
        this.codeActions = new Map();
        this.linter = null;
    }
    
    // 初始化诊断系统
    initialize(languageId, options = {}) {
        this.languageId = languageId;
        this.linter = options.linter || new DefaultLinter(this.monaco);
        
        // 注册代码操作提供者
        this.registerCodeActionProvider(languageId);
        
        // 注册悬停诊断提供者
        this.registerHoverProvider(languageId);
        
        return this;
    }
    
    registerCodeActionProvider(languageId) {
        this.monaco.languages.registerCodeActionProvider(languageId, {
            provideCodeActions: (model, range, context, token) => {
                return this.provideCodeActions(model, range, context, token);
            },
            resolveCodeAction: (action, token) => {
                return this.resolveCodeAction(action, token);
            }
        });
    }
    
    registerHoverProvider(languageId) {
        this.monaco.languages.registerHoverProvider(languageId, {
            provideHover: (model, position, token) => {
                return this.provideHover(model, position, token);
            }
        });
    }
    
    // 获取诊断信息
    async getDiagnostics(model) {
        const uri = model.uri.toString();
        const content = model.getValue();
        
        // 使用linter进行诊断
        const diagnostics = await this.linter.lint(content, model);
        
        // 转换为Monaco标记格式
        const markers = diagnostics.map(d => this.toMarker(d));
        
        // 缓存诊断结果
        this.markers.set(uri, diagnostics);
        
        // 更新编辑器标记
        this.monaco.editor.setModelMarkers(model, 'linter', markers);
        
        return markers;
    }
    
    toMarker(diagnostic) {
        return {
            severity: this.toSeverity(diagnostic.severity),
            startLineNumber: diagnostic.range.startLine,
            startColumn: diagnostic.range.startColumn,
            endLineNumber: diagnostic.range.endLine,
            endColumn: diagnostic.range.endColumn,
            message: diagnostic.message,
            source: diagnostic.source || 'Linter',
            code: diagnostic.code,
            relatedInformation: diagnostic.relatedInformation
        };
    }
    
    toSeverity(severity) {
        switch (severity) {
            case 'error':
            case 2:
                return this.monaco.MarkerSeverity.Error;
            case 'warning':
            case 1:
                return this.monaco.MarkerSeverity.Warning;
            case 'info':
            case 0:
                return this.monaco.MarkerSeverity.Info;
            case 'hint':
                return this.monaco.MarkerSeverity.Hint;
            default:
                return this.monaco.MarkerSeverity.Error;
        }
    }
    
    provideCodeActions(model, range, context, token) {
        const diagnostics = context.markers || [];
        const actions = [];
        
        diagnostics.forEach(diagnostic => {
            const fixes = this.getFixesForDiagnostic(diagnostic);
            actions.push(...fixes);
        });
        
        return {
            actions: actions.map(action => ({
                title: action.title,
                edit: action.edit,
                diagnostics: action.diagnostics,
                kind: action.kind || 'quickfix',
                isPreferred: action.isPreferred || false
            })),
            dispose: () => {}
        };
    }
    
    getFixesForDiagnostic(diagnostic) {
        const fixes = [];
        
        switch (diagnostic.code) {
            case 'no-unused-variable':
                fixes.push({
                    title: 'Remove unused variable',
                    edit: { model: diagnostic.model, range: diagnostic.range, text: '' },
                    diagnostics: [diagnostic],
                    kind: 'quickfix',
                    isPreferred: true
                });
                fixes.push({
                    title: 'Prefix with underscore',
                    edit: { model: diagnostic.model, range: diagnostic.range, text: '_' + diagnostic.text },
                    diagnostics: [diagnostic],
                    kind: 'quickfix'
                });
                break;
                
            case 'missing-semicolon':
                fixes.push({
                    title: 'Add semicolon',
                    edit: {
                        model: diagnostic.model,
                        range: {
                            startLineNumber: diagnostic.range.endLineNumber,
                            startColumn: diagnostic.range.endColumn,
                            endLineNumber: diagnostic.range.endLineNumber,
                            endColumn: diagnostic.range.endColumn
                        },
                        text: ';'
                    },
                    diagnostics: [diagnostic],
                    kind: 'quickfix',
                    isPreferred: true
                });
                break;
                
            case 'no-console':
                fixes.push({
                    title: 'Remove console statement',
                    edit: { model: diagnostic.model, range: diagnostic.range, text: '' },
                    diagnostics: [diagnostic],
                    kind: 'quickfix',
                    isPreferred: true
                });
                break;
        }
        
        return fixes;
    }
    
    resolveCodeAction(action, token) {
        return action;
    }
    
    provideHover(model, position, token) {
        const uri = model.uri.toString();
        const diagnostics = this.markers.get(uri) || [];
        
        const diagnostic = diagnostics.find(d => 
            d.range.startLine <= position.lineNumber &&
            d.range.endLine >= position.lineNumber &&
            d.range.startColumn <= position.column &&
            d.range.endColumn >= position.column
        );
        
        if (!diagnostic) return null;
        
        const contents = [];
        contents.push({
            value: `**${diagnostic.severity.toUpperCase()}**: ${diagnostic.message}`
        });
        
        if (diagnostic.code) {
            contents.push({ value: `\`${diagnostic.code}\`` });
        }
        
        const fixes = this.getFixesForDiagnostic(diagnostic);
        if (fixes.length > 0) {
            contents.push({ value: '**Quick Fixes:**', isTrusted: false });
            fixes.slice(0, 3).forEach(fix => {
                contents.push({ value: `- ${fix.title}`, isTrusted: false });
            });
        }
        
        return {
            contents,
            range: {
                startLineNumber: diagnostic.range.startLine,
                endLineNumber: diagnostic.range.endLine,
                startColumn: diagnostic.range.startColumn,
                endColumn: diagnostic.range.endColumn
            }
        };
    }
    
    clearDiagnostics(model) {
        const uri = model.uri.toString();
        this.markers.delete(uri);
        this.monaco.editor.setModelMarkers(model, 'linter', []);
    }
    
    dispose() {
        this.markers.clear();
        this.codeActions.clear();
    }
}

// 默认Linter实现
class DefaultLinter {
    constructor(monaco) {
        this.monaco = monaco;
    }
    
    async lint(content, model) {
        const diagnostics = [];
        const lines = content.split('\n');
        
        lines.forEach((line, index) => {
            const lineNumber = index + 1;
            
            // 检测未使用的变量
            const unusedVarMatch = line.match(/\b(const|let|var)\s+(\w+)\s*=/);
            if (unusedVarMatch) {
                diagnostics.push({
                    severity: 'warning',
                    code: 'no-unused-variable',
                    message: `'${unusedVarMatch[2]}' is declared but its value is never used`,
                    source: 'ESLint',
                    range: {
                        startLine: lineNumber,
                        startColumn: line.indexOf(unusedVarMatch[2]) + 1,
                        endLine: lineNumber,
                        endColumn: line.indexOf(unusedVarMatch[2]) + unusedVarMatch[2].length + 1
                    }
                });
            }
            
            // 检测console语句
            if (/\bconsole\.(log|debug|info|warn|error)\b/.test(line)) {
                const consoleMatch = line.match(/\bconsole\.\w+\b/);
                diagnostics.push({
                    severity: 'warning',
                    code: 'no-console',
                    message: `Unexpected console statement`,
                    source: 'ESLint',
                    range: {
                        startLine: lineNumber,
                        startColumn: line.indexOf(consoleMatch[0]) + 1,
                        endLine: lineNumber,
                        endColumn: line.indexOf(consoleMatch[0]) + consoleMatch[0].length + 1
                    }
                });
            }
        });
        
        return diagnostics;
    }
}

// Monaco Editor协同编辑系统完整实现
class CollaborativeEditor {
    constructor(options = {}) {
        this.options = {
            serverUrl: options.serverUrl || 'ws://localhost:1234',
            roomName: options.roomName || 'default-room',
            user: options.user || { 
                name: 'Anonymous', 
                color: '#' + Math.floor(Math.random()*16777215).toString(16) 
            },
            monaco: options.monaco,
            editor: null,
            ...options
        };
        
        this.ydoc = null;
        this.provider = null;
        this.awareness = null;
        this.ymap = null;
        this.isLocalChange = false;
        this.disposables = [];
    }
    
    // 初始化协同编辑
    async initialize() {
        // 创建Y.Doc
        this.ydoc = new Y.Doc();
        
        // 连接到WebSocket服务器
        this.provider = new WebsocketProvider(
            this.options.serverUrl,
            this.options.roomName,
            this.ydoc
        );
        
        // 获取awareness
        this.awareness = this.provider.awareness;
        
        // 设置本地用户状态
        this.awareness.setLocalStateField('user', {
            name: this.options.user.name,
            color: this.options.user.color,
            cursor: null
        });
        
        // 获取或创建文本类型
        this.ymap = this.ydoc.getMap('monaco');
        
        // 初始化Monaco编辑器
        await this.initializeMonaco();
        
        // 设置事件监听
        this.setupEventListeners();
        
        // 设置协同感知
        this.setupAwareness();
        
        return this;
    }
    
    async initializeMonaco() {
        const monaco = this.options.monaco;
        
        // 创建编辑器实例
        this.options.editor = monaco.editor.create(document.getElementById('editor'), {
            value: '',
            language: 'javascript',
            theme: 'vs-dark',
            automaticLayout: true
        });
        
        this.editor = this.options.editor;
        this.model = this.editor.getModel();
        
        // 从Y.Map同步到Monaco
        this.syncFromYjs();
        
        // 监听Y.Map变化
        this.ymap.observe(event => {
            if (!this.isLocalChange) {
                this.syncFromYjs();
            }
        });
    }
    
    setupEventListeners() {
        // 监听Monaco内容变化
        const contentDisposable = this.editor.onDidChangeModelContent(event => {
            if (this.isLocalChange) return;
            
            this.isLocalChange = true;
            
            this.ydoc.transact(() => {
                event.changes.forEach(change => {
                    const delta = this.eventToDelta(change);
                    this.applyDeltaToYText(delta);
                });
            });
            
            this.isLocalChange = false;
        });
        
        this.disposables.push(contentDisposable);
        
        // 监听光标位置变化
        const cursorDisposable = this.editor.onDidChangeCursorPosition(event => {
            this.awareness.setLocalStateField('cursor', {
                position: event.position,
                selection: this.editor.getSelection()
            });
        });
        
        this.disposables.push(cursorDisposable);
        
        // 监听选择变化
        const selectionDisposable = this.editor.onDidChangeCursorSelection(event => {
            this.awareness.setLocalStateField('selection', event.selection);
        });
        
        this.disposables.push(selectionDisposable);
    }
    
    setupAwareness() {
        // 监听其他用户状态变化
        this.awareness.on('change', changes => {
            this.updateRemoteCursors();
        });
        
        // 监听连接状态
        this.provider.on('status', event => {
            console.log('Connection status:', event.status);
        });
    }
    
    // 将Monaco事件转换为Y.Text delta
    eventToDelta(change) {
        return {
            range: {
                startColumn: change.rangeOffset,
                endColumn: change.rangeLength
            },
            text: change.text
        };
    }
    
    // 应用delta到Y.Text
    applyDeltaToYText(delta) {
        const ytext = this.ydoc.getText('content');
        
        if (delta.text) {
            ytext.insert(delta.range.startColumn, delta.text);
        }
        if (delta.range.endColumn > delta.range.startColumn) {
            ytext.delete(delta.range.startColumn, delta.range.endColumn - delta.range.startColumn);
        }
    }
    
    // 从Y.Map同步到Monaco
    syncFromYjs() {
        const content = this.ymap.get('content') || '';
        
        if (this.model.getValue() !== content) {
            this.isLocalChange = true;
            this.model.setValue(content);
            this.isLocalChange = false;
        }
    }
    
    // 同步Monaco内容到Y.Map
    syncToYjs() {
        const content = this.model.getValue();
        this.ymap.set('content', content);
    }
    
    // 更新远程用户光标
    updateRemoteCursors() {
        const states = this.awareness.getStates();
        
        this.editor.deltaDecorations(
            this.remoteDecorations || [],
            []
        );
        
        const decorations = [];
        
        states.forEach((state, clientId) => {
            if (clientId === this.ydoc.clientID) return;
            
            if (state.user && state.cursor) {
                decorations.push({
                    range: new monaco.Range(
                        state.cursor.position.lineNumber,
                        state.cursor.position.column,
                        state.cursor.position.lineNumber,
                        state.cursor.position.column
                    ),
                    options: {
                        className: `remote-cursor-${clientId}`,
                        beforeContentClassName: `remote-cursor-marker-${clientId}`,
                        hoverMessage: { value: state.user.name },
                        stickiness: monaco.editor.TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges
                    }
                });
                
                if (state.selection) {
                    decorations.push({
                        range: state.selection,
                        options: {
                            className: `remote-selection-${clientId}`,
                            hoverMessage: { value: `${state.user.name}'s selection` }
                        }
                    });
                }
            }
        });
        
        this.remoteDecorations = this.editor.deltaDecorations([], decorations);
        this.addRemoteCursorStyles(states);
    }
    
    addRemoteCursorStyles(states) {
        let styleElement = document.getElementById('remote-cursor-styles');
        if (!styleElement) {
            styleElement = document.createElement('style');
            styleElement.id = 'remote-cursor-styles';
            document.head.appendChild(styleElement);
        }
        
        let css = '';
        states.forEach((state, clientId) => {
            if (clientId === this.ydoc.clientID) return;
            
            if (state.user) {
                const color = state.user.color || '#ff0000';
                
                css += `
                    .remote-cursor-${clientId} {
                        border-left: 2px solid ${color};
                        margin-left: -1px;
                    }
                    .remote-cursor-marker-${clientId}::before {
                        content: '';
                        position: absolute;
                        border-left: 6px solid transparent;
                        border-right: 6px solid transparent;
                        border-bottom: 10px solid ${color};
                        transform: translate(-5px, -12px);
                    }
                    .remote-selection-${clientId} {
                        background-color: ${color}40;
                    }
                `;
            }
        });
        
        styleElement.textContent = css;
    }
    
    // 获取连接状态
    isConnected() {
        return this.provider && this.provider.wsconnected;
    }
    
    // 获取在线用户列表
    getConnectedUsers() {
        const users = [];
        const states = this.awareness.getStates();
        
        states.forEach((state, clientId) => {
            if (state.user) {
                users.push({
                    clientId,
                    name: state.user.name,
                    color: state.user.color
                });
            }
        });
        
        return users;
    }
    
    // 销毁
    dispose() {
        this.disposables.forEach(d => d.dispose());
        
        if (this.awareness) this.awareness.destroy();
        if (this.provider) this.provider.destroy();
        if (this.ydoc) this.ydoc.destroy();
        if (this.editor) this.editor.dispose();
    }
}

// WebSocket提供者实现
class WebsocketProvider {
    constructor(serverUrl, roomName, ydoc) {
        this.serverUrl = serverUrl;
        this.roomName = roomName;
        this.ydoc = ydoc;
        
        this.ws = null;
        this.wsconnected = false;
        this.wsconnecting = false;
        
        this.awareness = new Awareness(ydoc);
        
        this.connect();
    }
    
    connect() {
        if (this.wsconnecting) return;
        
        this.wsconnecting = true;
        
        try {
            this.ws = new WebSocket(`${this.serverUrl}/${this.roomName}`);
            
            this.ws.onopen = () => {
                this.wsconnected = true;
                this.wsconnecting = false;
                this.emit('status', { status: 'connected' });
                this.sendSync();
            };
            
            this.ws.onclose = () => {
                this.wsconnected = false;
                this.wsconnecting = false;
                this.emit('status', { status: 'disconnected' });
                this.scheduleReconnect();
            };
            
            this.ws.onerror = (error) => {
                console.error('WebSocket error:', error);
            };
            
            this.ws.onmessage = (event) => {
                this.handleMessage(event.data);
            };
            
        } catch (error) {
            console.error('Failed to connect:', error);
            this.scheduleReconnect();
        }
    }
    
    scheduleReconnect() {
        if (this._reconnectTimeout) {
            clearTimeout(this._reconnectTimeout);
        }
        
        this._reconnectTimeout = setTimeout(() => {
            this.connect();
        }, 10000);
    }
    
    sendSync() {
        // 发送完整文档状态
        const state = Y.encodeStateAsUpdate(this.ydoc);
        this.send({ type: 'sync', data: Array.from(state) });
    }
    
    send(message) {
        if (this.ws && this.wsconnected) {
            this.ws.send(JSON.stringify(message));
        }
    }
    
    handleMessage(data) {
        try {
            const message = JSON.parse(data);
            
            switch (message.type) {
                case 'sync':
                    const update = new Uint8Array(message.data);
                    Y.applyUpdate(this.ydoc, update);
                    break;
                    
                case 'awareness':
                    this.awareness.setStates(message.states);
                    break;
                    
                case 'update':
                    const incrementalUpdate = new Uint8Array(message.data);
                    Y.applyUpdate(this.ydoc, incrementalUpdate);
                    break;
            }
        } catch (error) {
            console.error('Failed to handle message:', error);
        }
    }
    
    emit(event, data) {
        // 事件触发
    }
    
    destroy() {
        if (this._reconnectTimeout) {
            clearTimeout(this._reconnectTimeout);
        }
        
        if (this.ws) {
            this.ws.close();
        }
        
        this.awareness.destroy();
    }
}

// Awareness状态管理
class Awareness {
    constructor(ydoc) {
        this.ydoc = ydoc;
        this.states = new Map();
        this.localState = null;
        this.listeners = new Set();
    }
    
    setLocalState(state) {
        this.localState = state;
        this.broadcastState();
    }
    
    setLocalStateField(field, value) {
        if (!this.localState) {
            this.localState = {};
        }
        this.localState[field] = value;
        this.broadcastState();
    }
    
    getLocalState() {
        return this.localState;
    }
    
    getStates() {
        return this.states;
    }
    
    setStates(states) {
        this.states = states;
        this.emit('change', { states });
    }
    
    broadcastState() {
        // 广播状态到服务器
    }
    
    on(event, callback) {
        this.listeners.add(callback);
    }
    
    off(event, callback) {
        this.listeners.delete(callback);
    }
    
    emit(event, data) {
        this.listeners.forEach(callback => callback(data));
    }
    
    destroy() {
        this.listeners.clear();
        this.states.clear();
    }
}

// 协同编辑WebSocket服务器
class CollaborationServer {
    constructor(port = 1234) {
        this.port = port;
        this.rooms = new Map();
        this.clients = new Map();
    }
    
    start() {
        const WebSocket = require('ws');
        
        this.wss = new WebSocket.Server({ port: this.port });
        
        this.wss.on('connection', (ws, req) => {
            const url = new URL(req.url, `http://localhost:${this.port}`);
            const roomName = url.pathname.slice(1) || 'default';
            
            this.handleConnection(ws, roomName);
        });
        
        console.log(`Collaboration server running on port ${this.port}`);
    }
    
    handleConnection(ws, roomName) {
        if (!this.rooms.has(roomName)) {
            this.rooms.set(roomName, {
                clients: new Set(),
                state: null,
                awareness: new Map()
            });
        }
        
        const room = this.rooms.get(roomName);
        room.clients.add(ws);
        
        const clientId = this.generateClientId();
        this.clients.set(ws, { roomName, clientId });
        
        ws.send(JSON.stringify({
            type: 'welcome',
            clientId: clientId
        }));
        
        if (room.state) {
            ws.send(JSON.stringify({
                type: 'sync',
                data: Array.from(room.state)
            }));
        }
        
        this.broadcast(roomName, {
            type: 'awareness',
            action: 'add',
            clientId: clientId,
            states: Array.from(room.awareness.entries())
        }, ws);
        
        ws.on('message', (data) => {
            try {
                const message = JSON.parse(data);
                this.handleMessage(ws, roomName, message);
            } catch (error) {
                console.error('Failed to parse message:', error);
            }
        });
        
        ws.on('close', () => {
            this.handleDisconnect(ws, roomName);
        });
    }
    
    handleMessage(ws, roomName, message) {
        const room = this.rooms.get(roomName);
        
        switch (message.type) {
            case 'sync':
                room.state = new Uint8Array(message.data);
                this.broadcast(roomName, {
                    type: 'sync',
                    data: message.data
                }, ws);
                break;
                
            case 'update':
                const update = new Uint8Array(message.data);
                if (room.state) {
                    room.state = this.mergeUpdates(room.state, update);
                } else {
                    room.state = update;
                }
                
                this.broadcast(roomName, {
                    type: 'update',
                    data: message.data
                }, ws);
                break;
                
            case 'awareness':
                const clientId = this.clients.get(ws).clientId;
                room.awareness.set(clientId, message.state);
                
                this.broadcast(roomName, {
                    type: 'awareness',
                    clientId: clientId,
                    state: message.state
                }, ws);
                break;
        }
    }
    
    handleDisconnect(ws, roomName) {
        const room = this.rooms.get(roomName);
        const clientInfo = this.clients.get(ws);
        
        if (room && clientInfo) {
            room.clients.delete(ws);
            room.awareness.delete(clientInfo.clientId);
            
            this.broadcast(roomName, {
                type: 'awareness',
                action: 'remove',
                clientId: clientInfo.clientId
            });
            
            if (room.clients.size === 0) {
                this.rooms.delete(roomName);
            }
        }
        
        this.clients.delete(ws);
    }
    
    broadcast(roomName, message, exclude = null) {
        const room = this.rooms.get(roomName);
        if (!room) return;
        
        const messageStr = JSON.stringify(message);
        
        room.clients.forEach(client => {
            if (client !== exclude && client.readyState === WebSocket.OPEN) {
                client.send(messageStr);
            }
        });
    }
    
    mergeUpdates(state1, state2) {
        return state1.length > state2.length ? state1 : state2;
    }
    
    generateClientId() {
        return Math.random().toString(36).substring(2, 15);
    }
    
    stop() {
        this.wss.close();
    }
}

// Monaco虚拟滚动优化配置
class VirtualScrollOptimizer {
    constructor(monaco) {
        this.monaco = monaco;
    }
    
    getOptimizedOptions() {
        return {
            // 滚动设置
            scrollBeyondLastLine: false,
            smoothScrolling: true,
            mouseWheelZoom: true,
            scrollbar: {
                vertical: 'visible',
                horizontal: 'visible',
                verticalScrollbarSize: 14,
                horizontalScrollbarSize: 14,
                useShadows: false
            },
            
            // 渲染优化
            renderingOptions: {
                GuessedIndentGuides: false,
                bracketGuides: false,
                highlightActiveLine: true,
                selectionHighlight: true,
                occurrencesHighlight: 'off',
                codeLens: false,
                glyphMargin: false
            },
            
            // 视图优化
            viewInfo: {
                extraEditorClassName: '',
                fixedOverflowWidgets: true,
                showGlyphMargin: false,
                wordWrap: 'off'
            },
            
            // 大文件优化
            largeFileOptimization: true,
            maxTokenizationLineLength: 15000,
            
            // 性能关键选项
            suggest: {
                showWords: false,
                insertMode: 'replace'
            },
            
            quickSuggestions: false,
            cursorSmoothCaretAnimation: 'off',
            cursorBlinking: 'solid',
            renderLineHighlight: 'line',
            renderWhitespace: 'none',
            matchBrackets: 'never',
            folding: true,
            foldingHighlight: false
        };
    }
    
    // 动态调整选项
    adjustForFileSize(options, lineCount) {
        if (lineCount > 10000) {
            return {
                ...options,
                renderingOptions: {
                    ...options.renderingOptions,
                    bracketGuides: false,
                    highlightActiveLine: false,
                    selectionHighlight: false,
                    occurrencesHighlight: 'off'
                },
                suggest: {
                    showWords: false,
                    insertMode: 'replace',
                    showMethods: false,
                    showFunctions: false,
                    showConstructors: false,
                    showFields: false,
                    showVariables: false,
                    showClasses: false,
                    showKeywords: true,
                    showSnippets: true
                },
                quickSuggestions: false,
                wordBasedSuggestions: false,
                parameterHints: { enabled: false },
                hover: { enabled: false }
            };
        } else if (lineCount > 5000) {
            return {
                ...options,
                renderingOptions: {
                    ...options.renderingOptions,
                    bracketGuides: false,
                    selectionHighlight: false
                },
                quickSuggestions: false,
                wordBasedSuggestions: 'currentDocument'
            };
        }
        
        return options;
    }
    
    createVirtualScrollManager(editor) {
        return {
            getVisibleRange: () => {
                const visibleRanges = editor.getVisibleRanges();
                if (visibleRanges.length === 0) return null;
                
                return {
                    startLineNumber: visibleRanges[0].startLineNumber,
                    endLineNumber: visibleRanges[visibleRanges.length - 1].endLineNumber
                };
            },
            
            preloadLines: (startLine, endLine, direction) => {
                const preloadCount = 100;
                
                if (direction === 'down') {
                    for (let i = endLine; i < Math.min(endLine + preloadCount, editor.getModel().getLineCount()); i++) {
                        editor.getModel().getLineContent(i);
                    }
                } else if (direction === 'up') {
                    for (let i = startLine - 1; i >= Math.max(startLine - preloadCount, 1); i--) {
                        editor.getModel().getLineContent(i);
                    }
                }
            },
            
            throttleScroll: (callback, delay = 100) => {
                let lastCall = 0;
                return (event) => {
                    const now = Date.now();
                    if (now - lastCall >= delay) {
                        lastCall = now;
                        callback(event);
                    }
                };
            }
        };
    }
}

// Monaco大文件处理系统
class LargeFileHandler {
    constructor(monaco, options = {}) {
        this.monaco = monaco;
        this.options = {
            maxFileSize: options.maxFileSize || 10 * 1024 * 1024,
            chunkSize: options.chunkSize || 10000,
            maxDisplayedLines: options.maxDisplayedLines || 5000,
            enableProgressiveLoading: options.enableProgressiveLoading !== false,
            ...options
        };
        
        this.loadedChunks = new Map();
        this.totalLines = 0;
        this.model = null;
    }
    
    checkFileSize(file) {
        if (file.size > this.options.maxFileSize) {
            return {
                tooLarge: true,
                size: file.size,
                maxSize: this.options.maxFileSize,
                recommendation: 'split'
            };
        }
        return { tooLarge: false };
    }
    
    async loadLargeFile(content) {
        const lines = content.split('\n');
        this.totalLines = lines.length;
        
        if (this.totalLines <= this.options.maxDisplayedLines) {
            return this.createModel(content);
        }
        
        if (this.options.enableProgressiveLoading) {
            return this.createProgressiveModel(lines);
        }
        
        return this.createLimitedModel(lines);
    }
    
    createModel(content) {
        return this.monaco.editor.createModel(content, undefined, undefined);
    }
    
    createProgressiveModel(lines) {
        const virtualModel = {
            lines: [],
            chunks: [],
            totalLines: this.totalLines,
            getLineCount: () => this.totalLines,
            getLineContent: (lineNumber) => {
                return this.getLine(lineNumber);
            },
            getValue: () => {
                return this.lines.join('\n');
            }
        };
        
        const middleStart = Math.max(0, Math.floor(this.totalLines / 2) - this.options.chunkSize / 2);
        this.loadChunk(middleStart, this.options.chunkSize);
        
        const model = this.monaco.editor.createModel('', undefined, undefined);
        
        this.model = model;
        this.virtualModel = virtualModel;
        
        this.setupOnDemandLoading(model);
        
        return model;
    }
    
    createLimitedModel(lines) {
        const visibleLines = Math.min(this.options.maxDisplayedLines, this.totalLines);
        const startLine = Math.max(0, Math.floor((this.totalLines - visibleLines) / 2));
        
        const partialContent = lines.slice(startLine, startLine + visibleLines).join('\n');
        const model = this.monaco.editor.createModel(partialContent, undefined, undefined);
        
        const warning = `/* 
 * Large file detected: ${this.totalLines} lines
 * Displaying lines ${startLine + 1} to ${startLine + visibleLines}
 * Full file available in file explorer
 */\n\n`;
        
        model.setValue(warning + partialContent);
        
        return model;
    }
    
    loadChunk(startLine, count) {
        const key = `${startLine}-${count}`;
        if (this.loadedChunks.has(key)) {
            return this.loadedChunks.get(key);
        }
        
        const chunk = [];
        const endLine = Math.min(startLine + count, this.totalLines);
        
        for (let i = startLine; i < endLine; i++) {
            chunk.push(this.virtualModel.lines[i] || '');
        }
        
        this.loadedChunks.set(key, chunk);
        return chunk;
    }
    
    getLine(lineNumber) {
        const chunkSize = this.options.chunkSize;
        const chunkStart = Math.floor((lineNumber - 1) / chunkSize) * chunkSize;
        
        const chunk = this.loadChunk(chunkStart, chunkSize);
        
        const index = (lineNumber - 1) % chunkSize;
        return chunk[index] || '';
    }
    
    getLargeFileOptions() {
        return {
            quickSuggestions: false,
            wordBasedSuggestions: false,
            parameterHints: { enabled: false },
            hover: { enabled: false },
            suggest: { enabled: false },
            renderLineHighlight: 'none',
            renderWhitespace: 'none',
            selectionHighlight: false,
            occurrencesHighlight: 'off',
            matchBrackets: 'never',
            largeFileOptimization: true,
            maxTokenizationLineLength: 10000,
            scrollbar: {
                vertical: 'visible',
                horizontal: 'auto',
                useShadows: false,
                verticalHasArrows: false,
                horizontalHasArrows: false,
                verticalScrollbarSize: 10,
                horizontalScrollbarSize: 10
            }
        };
    }
}

// Monaco WebWorker管理
class MonacoWebWorkerManager {
    constructor() {
        this.workers = new Map();
        this.taskQueue = new Map();
        this.activeTasks = new Map();
    }
    
    registerWorker(name, workerUrl) {
        const worker = new Worker(workerUrl);
        
        worker.onmessage = (event) => {
            this.handleWorkerMessage(name, event);
        };
        
        worker.onerror = (error) => {
            console.error(`Worker ${name} error:`, error);
            this.restartWorker(name, workerUrl);
        };
        
        this.workers.set(name, {
            worker,
            busy: false,
            capabilities: []
        });
        
        return worker;
    }
    
    handleWorkerMessage(name, event) {
        const { type, taskId, data, error } = event.data;
        const workerInfo = this.workers.get(name);
        
        switch (type) {
            case 'ready':
                workerInfo.capabilities = data.capabilities || [];
                workerInfo.busy = false;
                this.processNextTask(name);
                break;
                
            case 'result':
                const resolve = this.activeTasks.get(taskId);
                if (resolve) {
                    resolve(data);
                    this.activeTasks.delete(taskId);
                }
                workerInfo.busy = false;
                this.processNextTask(name);
                break;
                
            case 'error':
                const reject = this.activeTasks.get(taskId);
                if (reject) {
                    reject(new Error(error));
                    this.activeTasks.delete(taskId);
                }
                workerInfo.busy = false;
                this.processNextTask(name);
                break;
        }
    }
    
    async dispatchTask(name, taskType, data, options = {}) {
        return new Promise((resolve, reject) => {
            const taskId = this.generateTaskId();
            
            this.activeTasks.set(taskId, resolve);
            
            if (!this.taskQueue.has(name)) {
                this.taskQueue.set(name, []);
            }
            
            this.taskQueue.get(name).push({
                taskId,
                taskType,
                data,
                timeout: options.timeout || 30000
            });
            
            this.processNextTask(name);
            
            if (options.timeout) {
                setTimeout(() => {
                    if (this.activeTasks.has(taskId)) {
                        this.activeTasks.delete(taskId);
                        reject(new Error(`Task ${taskId} timed out after ${options.timeout}ms`));
                    }
                }, options.timeout);
            }
        });
    }
    
    processNextTask(name) {
        const workerInfo = this.workers.get(name);
        if (!workerInfo || workerInfo.busy) return;
        
        const queue = this.taskQueue.get(name);
        if (!queue || queue.length === 0) return;
        
        const task = queue.shift();
        
        workerInfo.busy = true;
        workerInfo.worker.postMessage({
            type: task.taskType,
            taskId: task.taskId,
            data: task.data
        });
    }
    
    restartWorker(name, workerUrl) {
        const oldInfo = this.workers.get(name);
        if (oldInfo) {
            oldInfo.worker.terminate();
        }
        
        this.registerWorker(name, workerUrl);
    }
    
    dispose() {
        this.workers.forEach(info => {
            info.worker.terminate();
        });
        this.workers.clear();
        this.taskQueue.clear();
        this.activeTasks.clear();
    }
    
    generateTaskId() {
        return `task_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
    }
}

// 语言服务Worker
class LanguageServiceWorker {
    constructor() {
        this.types = new Map();
        this.symbols = new Map();
    }
    
    initialize(capabilities) {
        this.capabilities = capabilities;
    }
    
    computeType(uri, position, content) {
        const line = content.split('\n')[position.lineNumber - 1];
        const beforeCursor = line.substring(0, position.column - 1);
        
        const varMatch = beforeCursor.match(/(?:const|let|var)\s+(\w+)\s*:\s*(\w+)/);
        if (varMatch) {
            return {
                type: varMatch[2],
                documentation: `Variable of type ${varMatch[2]}`
            };
        }
        
        return { type: 'unknown', documentation: '' };
    }
    
    computeDocumentSymbols(content) {
        const symbols = [];
        const lines = content.split('\n');
        
        lines.forEach((line, index) => {
            const classMatch = line.match(/class\s+(\w+)/);
            if (classMatch) {
                symbols.push({
                    name: classMatch[1],
                    kind: 'class',
                    location: { line: index + 1, column: 1 }
                });
            }
            
            const funcMatch = line.match(/(?:function|const|let|var)\s+(\w+)\s*[=\(]/);
            if (funcMatch) {
                symbols.push({
                    name: funcMatch[1],
                    kind: 'function',
                    location: { line: index + 1, column: 1 }
                });
            }
        });
        
        return symbols;
    }
    
    formatCode(content, options) {
        const tabSize = options.tabSize || 4;
        const useSpaces = options.insertSpaces !== false;
        
        let result = '';
        let indent = 0;
        const lines = content.split('\n');
        
        lines.forEach(line => {
            const trimmed = line.trim();
            
            if (trimmed.startsWith('}') || trimmed.startsWith(')')) {
                indent = Math.max(0, indent - 1);
            }
            
            if (trimmed.length > 0) {
                const indentStr = useSpaces ? ' '.repeat(indent * tabSize) : '\t'.repeat(indent);
                result += indentStr + trimmed + '\n';
            } else {
                result += '\n';
            }
            
            if (trimmed.endsWith('{') || trimmed.endsWith('(')) {
                indent++;
            }
        });
        
        return result;
    }
    
    findReferences(uri, position, content) {
        const word = this.getWordAtPosition(content, position);
        const references = [];
        const lines = content.split('\n');
        
        lines.forEach((line, index) => {
            if (line.includes(word)) {
                references.push({
                    uri,
                    line: index + 1,
                    column: line.indexOf(word) + 1
                });
            }
        });
        
        return references;
    }
    
    getWordAtPosition(content, position) {
        const lines = content.split('\n');
        const line = lines[position.lineNumber - 1] || '';
        const before = line.substring(0, position.column - 1);
        const after = line.substring(position.column - 1);
        
        const beforeMatch = before.match(/\w+$/);
        const afterMatch = after.match(/^\w+/);
        
        return (beforeMatch ? beforeMatch[0] : '') + (afterMatch ? afterMatch[0] : '');
    }
}

// WASM加速模块
class WasmAccelerator {
    constructor() {
        this.wasmModule = null;
        this.memory = null;
        this.initialized = false;
    }
    
    async initialize(wasmUrl) {
        try {
            const response = await fetch(wasmUrl);
            const bytes = await response.arrayBuffer();
            
            const { instance } = await WebAssembly.instantiate(bytes, {
                env: {
                    memory: new WebAssembly.Memory({ initial: 256, maximum: 512 }),
                    abort: () => console.error('WASM abort')
                }
            });
            
            this.wasmModule = instance;
            this.memory = instance.exports.memory;
            this.initialized = true;
            
            console.log('WASM module initialized');
            return true;
            
        } catch (error) {
            console.error('Failed to initialize WASM:', error);
            return false;
        }
    }
    
    // 语法高亮加速
    highlightSyntax(code, languageId) {
        if (!this.initialized) {
            return this.jsHighlight(code, languageId);
        }
        
        try {
            const codeBytes = new TextEncoder().encode(code);
            const ptr = this.allocate(codeBytes.length);
            
            const view = new Uint8Array(this.memory.buffer);
            view.set(codeBytes, ptr);
            
            const resultPtr = this.wasmModule.exports.highlight(
                ptr,
                codeBytes.length,
                this.getLanguageId(languageId)
            );
            
            const result = this.readString(resultPtr);
            
            this.deallocate(ptr);
            this.deallocate(resultPtr);
            
            return JSON.parse(result);
            
        } catch (error) {
            console.error('WASM highlight failed, falling back to JS:', error);
            return this.jsHighlight(code, languageId);
        }
    }
    
    // RE2正则表达式匹配
    regexMatch(pattern, text, options = {}) {
        if (!this.initialized) {
            return this.jsRegexMatch(pattern, text, options);
        }
        
        try {
            const regexPtr = this.wasmModule.exports.re2_compile(
                this.allocateString(pattern),
                options.caseInsensitive ? 1 : 0,
                options.multiline ? 1 : 0,
                options.global ? 1 : 0
            );
            
            if (regexPtr === 0) {
                throw new Error('Failed to compile regex');
            }
            
            const textBytes = new TextEncoder().encode(text);
            const textPtr = this.allocate(textBytes.length);
            new Uint8Array(this.memory.buffer).set(textBytes, textPtr);
            
            const matchesPtr = this.wasmModule.exports.re2_match(
                regexPtr,
                textPtr,
                textBytes.length
            );
            
            const matches = this.parseMatches(matchesPtr);
            
            this.wasmModule.exports.re2_delete(regexPtr);
            this.deallocate(textPtr);
            
            return matches;
            
        } catch (error) {
            console.error('WASM regex failed, falling back to JS:', error);
            return this.jsRegexMatch(pattern, text, options);
        }
    }
    
    // 差异计算
    computeDiff(oldText, newText) {
        if (!this.initialized) {
            return this.jsDiff(oldText, newText);
        }
        
        try {
            const oldBytes = new TextEncoder().encode(oldText);
            const newBytes = new TextEncoder().encode(newText);
            
            const oldPtr = this.allocate(oldBytes.length);
            const newPtr = this.allocate(newBytes.length);
            
            new Uint8Array(this.memory.buffer).set(oldBytes, oldPtr);
            new Uint8Array(this.memory.buffer).set(newBytes, newPtr);
            
            const resultPtr = this.wasmModule.exports.diff_compute(
                oldPtr, oldBytes.length,
                newPtr, newBytes.length
            );
            
            const result = this.readString(resultPtr);
            
            this.deallocate(oldPtr);
            this.deallocate(newPtr);
            this.deallocate(resultPtr);
            
            return JSON.parse(result);
            
        } catch (error) {
            console.error('WASM diff failed, falling back to JS:', error);
            return this.jsDiff(oldText, newText);
        }
    }
    
    // 代码Minification
    minify(code, options = {}) {
        if (!this.initialized) {
            return this.jsMinify(code, options);
        }
        
        try {
            const codeBytes = new TextEncoder().encode(code);
            const ptr = this.allocate(codeBytes.length);
            new Uint8Array(this.memory.buffer).set(codeBytes, ptr);
            
            const resultPtr = this.wasmModule.exports.minify(
                ptr,
                codeBytes.length,
                options.removeWhitespace ? 1 : 0,
                options.shortenVariables ? 1 : 0
            );
            
            const result = this.readString(resultPtr);
            
            this.deallocate(ptr);
            this.deallocate(resultPtr);
            
            return result;
            
        } catch (error) {
            console.error('WASM minify failed, falling back to JS:', error);
            return this.jsMinify(code, options);
        }
    }
    
    allocate(size) {
        const ptr = this.wasmModule.exports.allocate(size);
        if (ptr === 0) {
            throw new Error('Failed to allocate memory');
        }
        return ptr;
    }
    
    allocateString(str) {
        const bytes = new TextEncoder().encode(str);
        const ptr = this.allocate(bytes.length + 1);
        new Uint8Array(this.memory.buffer).set(bytes, ptr);
        return ptr;
    }
    
    readString(ptr) {
        const view = new Uint8Array(this.memory.buffer);
        let end = ptr;
        while (view[end] !== 0) end++;
        const bytes = view.slice(ptr, end);
        return new TextDecoder().decode(bytes);
    }
    
    deallocate(ptr) {
        this.wasmModule.exports.deallocate(ptr);
    }
    
    // JavaScript降级实现
    jsHighlight(code, languageId) {
        const tokens = [];
        const keywords = this.getKeywords(languageId);
        
        const lines = code.split('\n');
        lines.forEach((line, lineIndex) => {
            const words = line.split(/(\s+|[{}()\[\];,.])/);
            words.forEach(word => {
                if (word.trim()) {
                    let type = 'plain';
                    if (keywords.has(word)) {
                        type = 'keyword';
                    } else if (/^\d+$/.test(word)) {
                        type = 'number';
                    } else if (/^['"`]/.test(word)) {
                        type = 'string';
                    }
                    tokens.push({ type, value: word });
                }
            });
        });
        
        return tokens;
    }
    
    jsRegexMatch(pattern, text, options) {
        try {
            const flags = (options.caseInsensitive ? 'i' : '') + (options.multiline ? 'm' : '');
            const regex = new RegExp(pattern, flags + (options.global ? 'g' : ''));
            
            const matches = [];
            let match;
            
            if (options.global) {
                while ((match = regex.exec(text)) !== null) {
                    matches.push({
                        index: match.index,
                        length: match[0].length,
                        groups: match.slice(1)
                    });
                }
            } else {
                match = regex.exec(text);
                if (match) {
                    matches.push({
                        index: match.index,
                        length: match[0].length,
                        groups: match.slice(1)
                    });
                }
            }
            
            return matches;
        } catch (error) {
            console.error('Regex error:', error);
            return [];
        }
    }
    
    jsDiff(oldText, newText) {
        const oldLines = oldText.split('\n');
        const newLines = newText.split('\n');
        
        const result = {
            operations: [],
            hunks: []
        };
        
        const lcs = this.longestCommonSubsequence(oldLines, newLines);
        let oldIndex = 0;
        let newIndex = 0;
        let lcsIndex = 0;
        
        while (oldIndex < oldLines.length || newIndex < newLines.length) {
            if (lcsIndex < lcs.length) {
                while (oldIndex < oldLines.length && oldLines[oldIndex] !== lcs[lcsIndex]) {
                    result.operations.push({ type: 'delete', oldIndex });
                    oldIndex++;
                }
                while (newIndex < newLines.length && newLines[newIndex] !== lcs[lcsIndex]) {
                    result.operations.push({ type: 'insert', newIndex });
                    newIndex++;
                }
                result.operations.push({ type: 'equal', index: lcsIndex });
                oldIndex++;
                newIndex++;
                lcsIndex++;
            } else {
                while (oldIndex < oldLines.length) {
                    result.operations.push({ type: 'delete', oldIndex });
                    oldIndex++;
                }
                while (newIndex < newLines.length) {
                    result.operations.push({ type: 'insert', newIndex });
                    newIndex++;
                }
            }
        }
        
        return result;
    }
    
    longestCommonSubsequence(a, b) {
        const m = a.length;
        const n = b.length;
        const dp = Array(m + 1).fill(null).map(() => Array(n + 1).fill(0));
        
        for (let i = 1; i <= m; i++) {
            for (let j = 1; j <= n; j++) {
                if (a[i - 1] === b[j - 1]) {
                    dp[i][j] = dp[i - 1][j - 1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }
        }
        
        const lcs = [];
        let i = m, j = n;
        while (i > 0 && j > 0) {
            if (a[i - 1] === b[j - 1]) {
                lcs.unshift(a[i - 1]);
                i--;
                j--;
            } else if (dp[i - 1][j] > dp[i][j - 1]) {
                i--;
            } else {
                j--;
            }
        }
        
        return lcs;
    }
    
    jsMinify(code, options) {
        let result = code;
        
        if (options.removeWhitespace) {
            result = result
                .replace(/\s+/g, ' ')
                .replace(/\s*([{};,.=+\-*/<>!&|?:])\s*/g, '$1')
                .trim();
        }
        
        return result;
    }
    
    getKeywords(languageId) {
        const keywords = {
            javascript: new Set(['function', 'const', 'let', 'var', 'if', 'else', 'for', 'while', 'return', 'class', 'import', 'export', 'async', 'await']),
            typescript: new Set(['function', 'const', 'let', 'var', 'if', 'else', 'for', 'while', 'return', 'class', 'import', 'export', 'async', 'await', 'interface', 'type', 'enum']),
            python: new Set(['def', 'class', 'if', 'elif', 'else', 'for', 'while', 'return', 'import', 'from', 'as', 'async', 'await', 'lambda'])
        };
        
        return keywords[languageId] || new Set();
    }
    
    getLanguageId(languageId) {
        const ids = {
            javascript: 1,
            typescript: 2,
            python: 3,
            rust: 4,
            go: 5
        };
        return ids[languageId] || 0;
    }
    
    parseMatches(ptr) {
        return [];
    }
}