@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.1

package/vscode/src/vs/sessions/browser/parts/mobile/contributions/mobileDiffView.js

@@ -0,0 +1,675 @@
+
+import { registerCss } from '@codingame/monaco-vscode-api/css';
+import * as mobileOverlayViews from '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/contributions/media/mobileOverlayViews.css';
+import '@codingame/monaco-vscode-api/vscode/vs/sessions/browser/parts/mobile/contributions/mobileDiffColors';
+import { $ as $$1, append, addDisposableListener, EventType, clearNode, createTextNode, createElement } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { Disposable, DisposableStore, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Gesture, EventType as EventType$1 } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/touch';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { ThemeIcon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/themables';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { basename } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { linesDiffComputers } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/diff/linesDiffComputers';
+import { tokenizeToString } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/textToHtmlTokenizer';
+import { TokenizationRegistry } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages';
+import { generateTokensCSSForColorMap } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/languages/supports/tokenization';
+
+registerCss(mobileOverlayViews, 0);
+const $ = $$1;
+const EXTENSION_LANGUAGE_MAP = {
+    ".js": "javascript",
+    ".mjs": "javascript",
+    ".cjs": "javascript",
+    ".jsx": "javascriptreact",
+    ".ts": "typescript",
+    ".mts": "typescript",
+    ".cts": "typescript",
+    ".tsx": "typescriptreact",
+    ".py": "python",
+    ".pyw": "python",
+    ".java": "java",
+    ".c": "c",
+    ".h": "c",
+    ".cpp": "cpp",
+    ".cc": "cpp",
+    ".cxx": "cpp",
+    ".hpp": "cpp",
+    ".cs": "csharp",
+    ".go": "go",
+    ".rs": "rust",
+    ".rb": "ruby",
+    ".php": "php",
+    ".html": "html",
+    ".htm": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".less": "less",
+    ".json": "json",
+    ".jsonc": "jsonc",
+    ".md": "markdown",
+    ".sh": "shellscript",
+    ".bash": "shellscript",
+    ".zsh": "shellscript",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".xml": "xml",
+    ".sql": "sql",
+    ".swift": "swift",
+    ".kt": "kotlin",
+    ".kts": "kotlin",
+    ".r": "r",
+    ".lua": "lua",
+    ".dart": "dart"
+};
+const MOBILE_OPEN_DIFF_VIEW_COMMAND_ID = "sessions.mobile.openDiffView";
+class MobileDiffView extends Disposable {
+    constructor(workbenchContainer, data, textFileService, languageService) {
+        super();
+        this.textFileService = textFileService;
+        this.languageService = languageService;
+        this._onDidDispose = this._register(( new Emitter()));
+        this.onDidDispose = this._onDidDispose.event;
+        this.viewStore = this._register(( new DisposableStore()));
+        this.disposed = false;
+        this.renderGeneration = 0;
+        this.siblings = data.siblings && data.siblings.length > 0 ? data.siblings : [data.diff];
+        const startIndex = data.index ?? this.siblings.indexOf(data.diff);
+        this.currentIndex = startIndex >= 0 ? startIndex : 0;
+        this.render(workbenchContainer);
+        this.renderBodyForCurrent();
+    }
+    render(workbenchContainer) {
+        const overlay = append(workbenchContainer, $("div.mobile-overlay-view"));
+        this.viewStore.add(
+            addDisposableListener(overlay, EventType.CONTEXT_MENU, e => e.preventDefault())
+        );
+        this.viewStore.add(toDisposable(() => overlay.remove()));
+        const header = append(overlay, $("div.mobile-overlay-header"));
+        const backBtn = append(header, $("button.mobile-overlay-back-btn", {
+            type: "button"
+        }));
+        backBtn.setAttribute("aria-label", ( localize(2978, "Back")));
+        append(backBtn, $("span")).classList.add(...ThemeIcon.asClassNameArray(Codicon.chevronLeft));
+        this.viewStore.add(Gesture.addTarget(backBtn));
+        this.viewStore.add(
+            addDisposableListener(backBtn, EventType.CLICK, () => this.dispose())
+        );
+        this.viewStore.add(
+            addDisposableListener(backBtn, EventType$1.Tap, () => this.dispose())
+        );
+        const info = append(header, $("div.mobile-overlay-header-info.inline"));
+        this.titleEl = append(info, $("div.mobile-overlay-header-title"));
+        this.subtitleEl = append(info, $("div.mobile-overlay-header-subtitle"));
+        const nav = append(header, $("div.mobile-diff-nav"));
+        this.prevBtn = append(nav, $("button.mobile-diff-nav-btn.prev", {
+            type: "button"
+        }));
+        this.prevBtn.setAttribute("aria-label", ( localize(2979, "Previous file")));
+        append(this.prevBtn, $("span")).classList.add(...ThemeIcon.asClassNameArray(Codicon.chevronUp));
+        this.positionEl = append(nav, $("span.mobile-diff-nav-position"));
+        this.nextBtn = append(nav, $("button.mobile-diff-nav-btn.next", {
+            type: "button"
+        }));
+        this.nextBtn.setAttribute("aria-label", ( localize(2980, "Next file")));
+        append(this.nextBtn, $("span")).classList.add(...ThemeIcon.asClassNameArray(Codicon.chevronDown));
+        this.viewStore.add(Gesture.addTarget(this.prevBtn));
+        this.viewStore.add(Gesture.addTarget(this.nextBtn));
+        const onPrev = () => this.navigate(-1);
+        const onNext = () => this.navigate(1);
+        this.viewStore.add(addDisposableListener(this.prevBtn, EventType.CLICK, onPrev));
+        this.viewStore.add(addDisposableListener(this.prevBtn, EventType$1.Tap, onPrev));
+        this.viewStore.add(addDisposableListener(this.nextBtn, EventType.CLICK, onNext));
+        this.viewStore.add(addDisposableListener(this.nextBtn, EventType$1.Tap, onNext));
+        nav.style.display = this.siblings.length > 1 ? "" : "none";
+        const body = append(overlay, $("div.mobile-overlay-body"));
+        this.scrollWrapper = append(body, $("div.mobile-overlay-scroll"));
+        this.contentArea = append(this.scrollWrapper, $("div.mobile-diff-output"));
+        this.viewStore.add(this.attachSwipeNavigation(this.scrollWrapper));
+    }
+    attachSwipeNavigation(target) {
+        const store = ( new DisposableStore());
+        if (this.siblings.length <= 1) {
+            return store;
+        }
+        let startX = 0;
+        let startY = 0;
+        let startTime = 0;
+        let tracking = false;
+        const onPointerDown = e => {
+            if (e.pointerType !== "touch") {
+                return;
+            }
+            tracking = true;
+            startX = e.clientX;
+            startY = e.clientY;
+            startTime = Date.now();
+        };
+        const onPointerUp = e => {
+            if (!tracking) {
+                return;
+            }
+            tracking = false;
+            const dx = e.clientX - startX;
+            const dy = e.clientY - startY;
+            const dt = Date.now() - startTime;
+            const absDx = Math.abs(dx);
+            const absDy = Math.abs(dy);
+            const viewportWidth = target.clientWidth;
+            const minDistance = viewportWidth * 0.3;
+            const velocity = absDx / Math.max(dt, 1);
+            if (absDx <= absDy * 1.5) {
+                return;
+            }
+            if (absDx < minDistance && velocity < 0.5) {
+                return;
+            }
+            this.navigate(dx < 0 ? 1 : -1);
+        };
+        store.add(addDisposableListener(target, "pointerdown", onPointerDown));
+        store.add(addDisposableListener(target, "pointerup", onPointerUp));
+        store.add(addDisposableListener(target, "pointercancel", () => {
+            tracking = false;
+        }));
+        return store;
+    }
+    navigate(delta) {
+        const next = this.currentIndex + delta;
+        if (next < 0 || next >= this.siblings.length) {
+            return;
+        }
+        this.currentIndex = next;
+        this.renderBodyForCurrent();
+    }
+    renderBodyForCurrent() {
+        this.renderGeneration++;
+        const diff = this.siblings[this.currentIndex];
+        const fileNameUri = diff.modifiedURI ?? diff.originalURI;
+        const fileName = fileNameUri ? basename(fileNameUri) : "";
+        this.titleEl.textContent = fileName;
+        clearNode(this.subtitleEl);
+        if (!diff.identical) {
+            if (diff.added) {
+                append(this.subtitleEl, $("span.mobile-changes-row-added")).textContent = `+${diff.added}`;
+            }
+            if (diff.added && diff.removed) {
+                append(this.subtitleEl, createTextNode(" "));
+            }
+            if (diff.removed) {
+                append(this.subtitleEl, $("span.mobile-changes-row-removed")).textContent = `-${diff.removed}`;
+            }
+        }
+        if (this.siblings.length > 1) {
+            this.positionEl.textContent = ( localize(2981, "{0} / {1}", this.currentIndex + 1, this.siblings.length));
+            this.prevBtn.disabled = this.currentIndex === 0;
+            this.nextBtn.disabled = this.currentIndex === this.siblings.length - 1;
+            this.prevBtn.setAttribute("aria-disabled", String(this.prevBtn.disabled));
+            this.nextBtn.setAttribute("aria-disabled", String(this.nextBtn.disabled));
+        }
+        this.scrollWrapper.scrollTop = 0;
+        this.scrollWrapper.scrollLeft = 0;
+        clearNode(this.contentArea);
+        this.loadDiffContent(this.contentArea, diff);
+    }
+    loadDiffContent(container, diff) {
+        if (diff.identical) {
+            const empty = append(container, $("div.mobile-diff-empty-state"));
+            empty.textContent = ( localize(2982, "No changes in this file."));
+            return;
+        }
+        const loadingEl = append(container, $("div.mobile-diff-empty-state"));
+        loadingEl.textContent = ( localize(2983, "Loading…"));
+        const generation = this.renderGeneration;
+        const languageId = this.resolveLanguageId(diff);
+        void this.loadAndRender(container, diff, languageId, generation);
+    }
+    async loadAndRender(container, diff, languageId, generation) {
+        const [originalText, modifiedText] = await Promise.all([diff.originalURI ? this.textFileService.read(diff.originalURI, {
+            acceptTextOnly: true
+        }).then(m => m.value).catch(() => "") : Promise.resolve(""), diff.modifiedURI ? this.textFileService.read(diff.modifiedURI, {
+            acceptTextOnly: true
+        }).then(m => m.value).catch(() => "") : Promise.resolve("")]);
+        if (this.disposed || generation !== this.renderGeneration) {
+            return;
+        }
+        const hunks = computeUnifiedDiff(originalText, modifiedText);
+        if (hunks.length === 0) {
+            clearNode(container);
+            const empty = append(container, $("div.mobile-diff-empty-state"));
+            empty.textContent = ( localize(2982, "No changes in this file."));
+            return;
+        }
+        const [origLineHtml, modLineHtml] = await Promise.all([
+            tokenizeFileLines(this.languageService, originalText, languageId),
+            tokenizeFileLines(this.languageService, modifiedText, languageId)
+        ]);
+        const hasRealTokens = hasMultipleTokenClasses(origLineHtml) || hasMultipleTokenClasses(modLineHtml);
+        const origLines = hasRealTokens ? origLineHtml : regexTokenizeLines(originalText, languageId);
+        const modLines = hasRealTokens ? modLineHtml : regexTokenizeLines(modifiedText, languageId);
+        if (this.disposed || generation !== this.renderGeneration) {
+            return;
+        }
+        clearNode(container);
+        const colorMap = TokenizationRegistry.getColorMap();
+        if (colorMap && hasRealTokens) {
+            const styleEl = createElement("style");
+            styleEl.textContent = generateTokensCSSForColorMap(colorMap);
+            container.appendChild(styleEl);
+        }
+        this.renderHunks(container, hunks, origLines, modLines);
+    }
+    resolveLanguageId(diff) {
+        const uri = diff.modifiedURI ?? diff.originalURI;
+        if (!uri) {
+            return "plaintext";
+        }
+        const guessed = this.languageService.guessLanguageIdByFilepathOrFirstLine(uri);
+        if (guessed && guessed !== "unknown") {
+            return guessed;
+        }
+        const name = basename(uri);
+        const ext = name.includes(".") ? name.slice(name.lastIndexOf(".")).toLowerCase() : "";
+        return EXTENSION_LANGUAGE_MAP[ext] ?? "plaintext";
+    }
+    renderHunks(container, hunks, origLineHtml, modLineHtml) {
+        for (const hunk of hunks) {
+            const headerEl = append(container, $("div.mobile-diff-hunk-header"));
+            headerEl.textContent = hunk.header;
+            for (const line of hunk.lines) {
+                const row = append(container, $("div.mobile-diff-line"));
+                row.classList.add(line.type);
+                const numEl = append(row, $("span.mobile-diff-line-num"));
+                numEl.textContent = line.lineNum !== undefined ? String(line.lineNum) : "";
+                const gutter = append(row, $("span.mobile-diff-gutter"));
+                gutter.textContent = line.type === "added" ? "+" : line.type === "removed" ? "-" : " ";
+                const content = append(row, $("span.mobile-diff-content"));
+                if (line.lineNum !== undefined) {
+                    const source = line.type === "added" ? modLineHtml : origLineHtml;
+                    const html = source[line.lineNum - 1];
+                    if (html !== undefined) {
+                        content.innerHTML = html;
+                    } else if (line.text) {
+                        content.textContent = line.text;
+                    }
+                } else if (line.text) {
+                    content.textContent = line.text;
+                }
+            }
+        }
+    }
+    dispose() {
+        this.disposed = true;
+        this._onDidDispose.fire();
+        this.viewStore.dispose();
+        super.dispose();
+    }
+}
+async function tokenizeFileLines(languageService, text, languageId) {
+    if (!text) {
+        return [""];
+    }
+    const html = await tokenizeToString(languageService, text, languageId);
+    const inner = stripTokenizedWrapper(html);
+    return inner.split("<br/>");
+}
+function stripTokenizedWrapper(html) {
+    const openTag = "<div class=\"monaco-tokenized-source\">";
+    const closeTag = "</div>";
+    if (html.startsWith(openTag) && html.endsWith(closeTag)) {
+        return html.slice(openTag.length, html.length - closeTag.length);
+    }
+    return html;
+}
+function hasMultipleTokenClasses(lines) {
+    for (const line of lines) {
+        if (line && /class="mtk[2-9]|class="mtk[1-9][0-9]/.test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
+const LANG_FAMILY = {
+    javascript: "js",
+    javascriptreact: "js",
+    typescript: "js",
+    typescriptreact: "js",
+    java: "js",
+    csharp: "js",
+    go: "js",
+    rust: "js",
+    cpp: "js",
+    c: "js",
+    swift: "js",
+    kotlin: "js",
+    dart: "js",
+    php: "js",
+    ruby: "js",
+    python: "python",
+    css: "css",
+    scss: "css",
+    less: "css",
+    html: "html",
+    xml: "html",
+    json: "json",
+    jsonc: "json",
+    shellscript: "shell",
+    powershell: "shell"
+};
+const JS_KEYWORDS = ( new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "let",
+    "new",
+    "null",
+    "of",
+    "return",
+    "static",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "undefined",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield",
+    "async",
+    "await",
+    "from",
+    "as",
+    "interface",
+    "type",
+    "enum",
+    "declare",
+    "abstract",
+    "override",
+    "readonly",
+    "namespace",
+    "module",
+    "public",
+    "private",
+    "protected"
+]));
+const PY_KEYWORDS = ( new Set([
+    "False",
+    "None",
+    "True",
+    "and",
+    "as",
+    "assert",
+    "async",
+    "await",
+    "break",
+    "class",
+    "continue",
+    "def",
+    "del",
+    "elif",
+    "else",
+    "except",
+    "finally",
+    "for",
+    "from",
+    "global",
+    "if",
+    "import",
+    "in",
+    "is",
+    "lambda",
+    "nonlocal",
+    "not",
+    "or",
+    "pass",
+    "raise",
+    "return",
+    "try",
+    "while",
+    "with",
+    "yield"
+]));
+function escapeHtml(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function buildSpan(kind, text) {
+    if (kind === "default" || !text) {
+        return escapeHtml(text);
+    }
+    return `<span class="mobile-diff-tok-${kind}">${escapeHtml(text)}</span>`;
+}
+function regexTokenizeLine(line, lang) {
+    const tokens = [];
+    let pos = 0;
+    const len = line.length;
+    while (pos < len) {
+        let matched = false;
+        const commentPfx = lang === "python" ? "#" : lang === "shell" ? "#" : "//";
+        if (line.startsWith(commentPfx, pos) || (lang === "generic" && line.startsWith("#", pos))) {
+            tokens.push({
+                start: pos,
+                end: len,
+                kind: "comment"
+            });
+            pos = len;
+            matched = true;
+        }
+        if (!matched && lang !== "python" && lang !== "shell" && line.startsWith("/*", pos)) {
+            const end = line.indexOf("*/", pos + 2);
+            const tokenEnd = end === -1 ? len : end + 2;
+            tokens.push({
+                start: pos,
+                end: tokenEnd,
+                kind: "comment"
+            });
+            pos = tokenEnd;
+            matched = true;
+        }
+        if (!matched && (lang === "js") && line[pos] === "`") {
+            let i = pos + 1;
+            while (i < len) {
+                if (line[i] === "\\") {
+                    i += 2;
+                    continue;
+                }
+                if (line[i] === "`") {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            tokens.push({
+                start: pos,
+                end: i,
+                kind: "string"
+            });
+            pos = i;
+            matched = true;
+        }
+        if (!matched && (line[pos] === "\"" || line[pos] === "'")) {
+            const q = line[pos];
+            let i = pos + 1;
+            while (i < len) {
+                if (line[i] === "\\") {
+                    i += 2;
+                    continue;
+                }
+                if (line[i] === q) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            tokens.push({
+                start: pos,
+                end: i,
+                kind: "string"
+            });
+            pos = i;
+            matched = true;
+        }
+        if (!matched && /[0-9]/.test(line[pos])) {
+            const m = line.slice(pos).match(/^0x[0-9a-fA-F]+|^[0-9]+\.?[0-9]*(?:[eE][+-]?[0-9]+)?/);
+            if (m) {
+                tokens.push({
+                    start: pos,
+                    end: pos + m[0].length,
+                    kind: "number"
+                });
+                pos += m[0].length;
+                matched = true;
+            }
+        }
+        if (!matched && /[a-zA-Z_$]/.test(line[pos])) {
+            const m = line.slice(pos).match(/^[a-zA-Z_$][a-zA-Z0-9_$]*/);
+            if (m) {
+                const word = m[0];
+                const keywords = lang === "python" ? PY_KEYWORDS : JS_KEYWORDS;
+                const kind = ( keywords.has(word)) ? "keyword" : "default";
+                tokens.push({
+                    start: pos,
+                    end: pos + word.length,
+                    kind
+                });
+                pos += word.length;
+                matched = true;
+            }
+        }
+        if (!matched) {
+            const prevTok = tokens[tokens.length - 1];
+            if (prevTok && prevTok.kind === "default") {
+                prevTok.end = pos + 1;
+            } else {
+                tokens.push({
+                    start: pos,
+                    end: pos + 1,
+                    kind: "default"
+                });
+            }
+            pos++;
+        }
+    }
+    return tokens.map(t => buildSpan(t.kind, line.slice(t.start, t.end))).join("");
+}
+function regexTokenizeLines(text, languageId) {
+    if (!text) {
+        return [""];
+    }
+    const lang = LANG_FAMILY[languageId] ?? "generic";
+    return text.split(/\r?\n/).map(line => regexTokenizeLine(line, lang));
+}
+const CONTEXT_LINES = 3;
+function computeUnifiedDiff(original, modified) {
+    const origLines = original.split(/\r?\n/);
+    const modLines = modified.split(/\r?\n/);
+    const result = linesDiffComputers.getDefault().computeDiff(origLines, modLines, {
+        ignoreTrimWhitespace: false,
+        maxComputationTimeMs: 1000,
+        computeMoves: false
+    });
+    if (result.changes.length === 0) {
+        return [];
+    }
+    const groups = [];
+    for (const change of result.changes) {
+        const sub = {
+            origStart: change.original.startLineNumber,
+            origEnd: change.original.endLineNumberExclusive,
+            modStart: change.modified.startLineNumber,
+            modEnd: change.modified.endLineNumberExclusive
+        };
+        const last = groups[groups.length - 1];
+        const lastSub = last?.subs[last.subs.length - 1];
+        if (lastSub && sub.origStart - lastSub.origEnd <= CONTEXT_LINES * 2) {
+            last.subs.push(sub);
+        } else {
+            groups.push({
+                subs: [sub]
+            });
+        }
+    }
+    const hunks = [];
+    for (const group of groups) {
+        const first = group.subs[0];
+        const last = group.subs[group.subs.length - 1];
+        const origLeading = Math.max(1, first.origStart - CONTEXT_LINES);
+        const modLeading = Math.max(1, first.modStart - CONTEXT_LINES);
+        const origTrailing = Math.min(origLines.length + 1, last.origEnd + CONTEXT_LINES);
+        const modTrailing = Math.min(modLines.length + 1, last.modEnd + CONTEXT_LINES);
+        const lines = [];
+        for (let i = origLeading; i < first.origStart; i++) {
+            lines.push({
+                type: "context",
+                lineNum: i,
+                text: origLines[i - 1] ?? ""
+            });
+        }
+        for (let s = 0; s < group.subs.length; s++) {
+            const sub = group.subs[s];
+            for (let i = sub.origStart; i < sub.origEnd; i++) {
+                lines.push({
+                    type: "removed",
+                    lineNum: i,
+                    text: origLines[i - 1] ?? ""
+                });
+            }
+            for (let i = sub.modStart; i < sub.modEnd; i++) {
+                lines.push({
+                    type: "added",
+                    lineNum: i,
+                    text: modLines[i - 1] ?? ""
+                });
+            }
+            const next = group.subs[s + 1];
+            if (next) {
+                for (let i = sub.origEnd; i < next.origStart; i++) {
+                    lines.push({
+                        type: "context",
+                        lineNum: i,
+                        text: origLines[i - 1] ?? ""
+                    });
+                }
+            }
+        }
+        for (let i = last.origEnd; i < origTrailing; i++) {
+            lines.push({
+                type: "context",
+                lineNum: i,
+                text: origLines[i - 1] ?? ""
+            });
+        }
+        const origCount = origTrailing - origLeading;
+        const modCount = modTrailing - modLeading;
+        hunks.push({
+            header: `@@ -${origLeading},${origCount} +${modLeading},${modCount} @@`,
+            lines
+        });
+    }
+    return hunks;
+}
+function openMobileDiffView(workbenchContainer, data, textFileService, languageService) {
+    return ( new MobileDiffView(workbenchContainer, data, textFileService, languageService));
+}
+
+export { MOBILE_OPEN_DIFF_VIEW_COMMAND_ID, MobileDiffView, openMobileDiffView };