@git-diff-view/react 0.0.11 → 0.0.12

package/dist/cjs/index.development.js

@@ -72,334 +72,79 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-const processAST = (ast) => {
-    let lineNumber = 1;
-    const syntaxObj = {};
-    const loopAST = (nodes, wrapper) => {
-        nodes.forEach((node) => {
-            if (node.type === "text") {
-                if (node.value.indexOf("\n") === -1) {
-                    const valueLength = node.value.length;
-                    if (!syntaxObj[lineNumber]) {
-                        node.startIndex = 0;
-                        node.endIndex = valueLength - 1;
-                        const item = {
-                            value: node.value,
-                            lineNumber,
-                            valueLength,
-                            nodeList: [{ node, wrapper }],
-                        };
-                        syntaxObj[lineNumber] = item;
-                    }
-                    else {
-                        node.startIndex = syntaxObj[lineNumber].valueLength;
-                        node.endIndex = node.startIndex + valueLength - 1;
-                        syntaxObj[lineNumber].value += node.value;
-                        syntaxObj[lineNumber].valueLength += valueLength;
-                        syntaxObj[lineNumber].nodeList.push({ node, wrapper });
-                    }
-                    node.lineNumber = lineNumber;
-                    return;
-                }
-                const lines = node.value.split("\n");
-                node.children = node.children || [];
-                for (let i = 0; i < lines.length; i++) {
-                    const _value = i === lines.length - 1 ? lines[i] : lines[i] + "\n";
-                    const _lineNumber = i === 0 ? lineNumber : ++lineNumber;
-                    const _valueLength = _value.length;
-                    const _node = {
-                        type: "text",
-                        value: _value,
-                        startIndex: Infinity,
-                        endIndex: Infinity,
-                        lineNumber: _lineNumber,
-                    };
-                    if (!syntaxObj[_lineNumber]) {
-                        _node.startIndex = 0;
-                        _node.endIndex = _valueLength - 1;
-                        const item = {
-                            value: _value,
-                            lineNumber: _lineNumber,
-                            valueLength: _valueLength,
-                            nodeList: [{ node: _node, wrapper }],
-                        };
-                        syntaxObj[_lineNumber] = item;
-                    }
-                    else {
-                        _node.startIndex = syntaxObj[_lineNumber].valueLength;
-                        _node.endIndex = _node.startIndex + _valueLength - 1;
-                        syntaxObj[_lineNumber].value += _value;
-                        syntaxObj[_lineNumber].valueLength += _valueLength;
-                        syntaxObj[_lineNumber].nodeList.push({ node: _node, wrapper });
-                    }
-                    node.children.push(_node);
-                }
-                node.lineNumber = lineNumber;
-                return;
-            }
-            if (node.children) {
-                loopAST(node.children, node);
-                node.lineNumber = lineNumber;
-            }
-        });
-    };
-    loopAST(ast.children);
-    return { syntaxFileObject: syntaxObj, syntaxFileLineNumber: lineNumber };
-};
-
-const lowlight = lowlight$1.createLowlight(lowlight$1.all);
-// !SEE https://github.com/highlightjs/highlightjs-vue
-lowlight.register("vue", function hljsDefineVue(hljs) {
-    return {
-        subLanguage: "xml",
-        contains: [
-            hljs.COMMENT("<!--", "-->", {
-                relevance: 10,
-            }),
-            {
-                begin: /^(\s*)(<script>)/gm,
-                end: /^(\s*)(<\/script>)/gm,
-                subLanguage: "javascript",
-                excludeBegin: true,
-                excludeEnd: true,
-            },
-            {
-                begin: /^(?:\s*)(?:<script\s+lang=(["'])ts\1>)/gm,
-                end: /^(\s*)(<\/script>)/gm,
-                subLanguage: "typescript",
-                excludeBegin: true,
-                excludeEnd: true,
-            },
-            {
-                begin: /^(\s*)(<style(\s+scoped)?>)/gm,
-                end: /^(\s*)(<\/style>)/gm,
-                subLanguage: "css",
-                excludeBegin: true,
-                excludeEnd: true,
-            },
-            {
-                begin: /^(?:\s*)(?:<style(?:\s+scoped)?\s+lang=(["'])(?:s[ca]ss)\1(?:\s+scoped)?>)/gm,
-                end: /^(\s*)(<\/style>)/gm,
-                subLanguage: "scss",
-                excludeBegin: true,
-                excludeEnd: true,
-            },
-            {
-                begin: /^(?:\s*)(?:<style(?:\s+scoped)?\s+lang=(["'])stylus\1(?:\s+scoped)?>)/gm,
-                end: /^(\s*)(<\/style>)/gm,
-                subLanguage: "stylus",
-                excludeBegin: true,
-                excludeEnd: true,
-            },
-        ],
-    };
-});
-const instance = { name: "lowlight" };
-let _maxLineToIgnoreSyntax = 2000;
-const _ignoreSyntaxHighlightList = [];
-Object.defineProperty(instance, "maxLineToIgnoreSyntax", {
-    get: () => _maxLineToIgnoreSyntax,
-});
-Object.defineProperty(instance, "setMaxLineToIgnoreSyntax", {
-    value: (v) => {
-        _maxLineToIgnoreSyntax = v;
-    },
-});
-Object.defineProperty(instance, "ignoreSyntaxHighlightList", {
-    get: () => _ignoreSyntaxHighlightList,
-});
-Object.defineProperty(instance, "setIgnoreSyntaxHighlightList", {
-    value: (v) => {
-        _ignoreSyntaxHighlightList.length = 0;
-        _ignoreSyntaxHighlightList.push(...v);
-    },
-});
-Object.defineProperty(instance, "getAST", {
-    value: (raw, fileName, lang) => {
-        let hasRegisteredLang = true;
-        if (!lowlight.registered(lang)) {
-            console.warn(`not support current lang: ${lang} yet`);
-            hasRegisteredLang = false;
-        }
-        if (fileName &&
-            highlighter.ignoreSyntaxHighlightList.some((item) => item instanceof RegExp ? item.test(fileName) : fileName === item)) {
-            console.warn(`ignore syntax for current file, because the fileName is in the ignoreSyntaxHighlightList: ${fileName}`);
-            return;
-        }
-        if (hasRegisteredLang) {
-            return lowlight.highlight(lang, raw);
-        }
-        else {
-            return lowlight.highlightAuto(raw);
-        }
-    },
-});
-Object.defineProperty(instance, "processAST", {
-    value: (ast) => {
-        return processAST(ast);
-    },
-});
-const highlighter = instance;
-
-var _Cache_keyArray, _Cache_maxLength;
-class Cache extends Map {
-    constructor() {
-        super(...arguments);
-        _Cache_keyArray.set(this, []);
-        _Cache_maxLength.set(this, 30);
-    }
-    setMaxLength(length) {
-        __classPrivateFieldSet(this, _Cache_maxLength, length, "f");
-        this._checkLength();
-    }
-    set(key, value) {
-        if (this.has(key))
-            return this;
-        __classPrivateFieldGet(this, _Cache_keyArray, "f").push(key);
-        this._checkLength();
-        return super.set(key, value);
-    }
-    _checkLength() {
-        while (__classPrivateFieldGet(this, _Cache_keyArray, "f").length > __classPrivateFieldGet(this, _Cache_maxLength, "f")) {
-            const key = __classPrivateFieldGet(this, _Cache_keyArray, "f").shift();
-            this.delete(key);
-        }
-    }
-}
-_Cache_keyArray = new WeakMap(), _Cache_maxLength = new WeakMap();
-
-var _File_instances, _File_doCheck;
-const map = new Cache();
-const devKey = "@git-diff-cache";
-map.setMaxLength(50);
-map.name = "@git-diff-view/core";
-if (typeof globalThis !== "undefined") {
-    if (Array.isArray(globalThis[devKey])) {
-        globalThis[devKey] = globalThis[devKey].filter((i) => i !== map);
-        if (globalThis[devKey].length > 0) {
-            console.warn("there are multiple instance of @git-diff-view/core in the one environment!");
-        }
-        globalThis[devKey].push(map);
-    }
-    else {
-        globalThis[devKey] = [map];
-    }
-}
-class File {
-    constructor(raw, lang, fileName) {
-        _File_instances.add(this);
-        this.raw = raw;
-        this.lang = lang;
-        this.fileName = fileName;
-        this.rawFile = {};
-        this.hasDoRaw = false;
-        this.syntaxFile = {};
-        this.hasDoSyntax = false;
-        this.maxLineNumber = 0;
-        Object.defineProperty(this, "__v_skip", { value: true });
-    }
-    doSyntax({ registerHighlighter }) {
-        if (!this.raw || this.hasDoSyntax)
-            return;
-        const _highlighter = registerHighlighter || highlighter;
-        if (this.syntaxLength) {
-            console.error("current file already doSyntax before!");
-            return;
-        }
-        if (this.rawLength > _highlighter.maxLineToIgnoreSyntax) {
-            console.warn(`ignore syntax for current file, because the rawLength is too long: ${this.rawLength}`);
-            return;
-        }
-        this.ast = _highlighter.getAST(this.raw, this.fileName, this.lang);
-        if (!this.ast)
-            return;
-        const { syntaxFileObject, syntaxFileLineNumber } = _highlighter.processAST(this.ast);
-        this.syntaxFile = syntaxFileObject;
-        this.syntaxLength = syntaxFileLineNumber;
-        this.highlighterName = _highlighter.name;
-        {
-            __classPrivateFieldGet(this, _File_instances, "m", _File_doCheck).call(this);
-        }
-        this.hasDoSyntax = true;
+exports.DiffHunkExpansionType = void 0;
+(function (DiffHunkExpansionType) {
+    /** The hunk header cannot be expanded at all. */
+    DiffHunkExpansionType["None"] = "None";
+    /**
+     * The hunk header can be expanded up exclusively. Only the first hunk can be
+     * expanded up exclusively.
+     */
+    DiffHunkExpansionType["Up"] = "Up";
+    /**
+     * The hunk header can be expanded down exclusively. Only the last hunk (if
+     * it's the dummy hunk with only one line) can be expanded down exclusively.
+     */
+    DiffHunkExpansionType["Down"] = "Down";
+    /** The hunk header can be expanded both up and down. */
+    DiffHunkExpansionType["Both"] = "Both";
+    /**
+     * The hunk header represents a short gap that, when expanded, will
+     * result in merging this hunk and the hunk above.
+     */
+    DiffHunkExpansionType["Short"] = "Short";
+})(exports.DiffHunkExpansionType || (exports.DiffHunkExpansionType = {}));
+/** each diff is made up of a number of hunks */
+class DiffHunk {
+    /**
+     * @param header The details from the diff hunk header about the line start and patch length.
+     * @param lines The contents - context and changes - of the diff section.
+     * @param unifiedDiffStart The diff hunk's start position in the overall file diff.
+     * @param unifiedDiffEnd The diff hunk's end position in the overall file diff.
+     */
+    constructor(header, lines, unifiedDiffStart, unifiedDiffEnd, expansionType) {
+        this.header = header;
+        this.lines = lines;
+        this.unifiedDiffStart = unifiedDiffStart;
+        this.unifiedDiffEnd = unifiedDiffEnd;
+        this.expansionType = expansionType;
     }
-    doRaw() {
-        if (!this.raw || this.hasDoRaw)
-            return;
-        const rawString = this.raw;
-        const rawArray = rawString.split("\n");
-        this.rawLength = rawArray.length;
-        this.maxLineNumber = rawArray.length;
-        this.rawFile = {};
-        for (let i = 0; i < rawArray.length; i++) {
-            this.rawFile[i + 1] = i < rawArray.length - 1 ? rawArray[i] + "\n" : rawArray[i];
+    equals(other) {
+        if (this === other) {
+            return true;
         }
-        // reduce 对于大数组性能很差
-        // this.rawFile = rawArray.reduce(
-        //   (p, item, index) => ({
-        //     ...p,
-        //     [index + 1]: index < rawArray.length - 1 ? item + "\n" : item,
-        //   }),
-        //   {}
-        // );
-        this.hasDoRaw = true;
+        return (this.header.equals(other.header) &&
+            this.unifiedDiffStart === other.unifiedDiffStart &&
+            this.unifiedDiffEnd === other.unifiedDiffEnd &&
+            this.expansionType === other.expansionType &&
+            this.lines.length === other.lines.length &&
+            this.lines.every((xLine, ix) => xLine.equals(other.lines[ix])));
     }
 }
-_File_instances = new WeakSet(), _File_doCheck = function _File_doCheck() {
-    if (this.rawLength && this.syntaxLength) {
-        if (this.rawLength !== this.syntaxLength) {
-            console.warn("the rawLength not match for the syntaxLength");
-        }
-        Object.values(this.syntaxFile).forEach(({ value, lineNumber }) => {
-            if (value !== this.rawFile[lineNumber]) {
-                console.log("some line not match:" + value + " __ " + this.rawFile[lineNumber] + " __ at: " + lineNumber + " lineNumber");
-            }
-        });
+/** details about the start and end of a diff hunk */
+class DiffHunkHeader {
+    /**
+     * @param oldStartLine The line in the old (or original) file where this diff hunk starts.
+     * @param oldLineCount The number of lines in the old (or original) file that this diff hunk covers
+     * @param newStartLine The line in the new file where this diff hunk starts.
+     * @param newLineCount The number of lines in the new file that this diff hunk covers.
+     */
+    constructor(oldStartLine, oldLineCount, newStartLine, newLineCount) {
+        this.oldStartLine = oldStartLine;
+        this.oldLineCount = oldLineCount;
+        this.newStartLine = newStartLine;
+        this.newLineCount = newLineCount;
     }
-};
-const getFile = (raw, lang, fileName) => {
-    const key = raw + "--" + "0.0.11" + "--" + lang;
-    if (map.has(key))
-        return map.get(key);
-    const file = new File(raw, lang, fileName);
-    map.set(key, file);
-    return file;
-};
-const _cacheMap = map;
+    toDiffLineRepresentation() {
+        return `@@ -${this.oldStartLine},${this.oldLineCount} +${this.newStartLine},${this.newLineCount} @@`;
+    }
+    equals(other) {
+        return (this.oldStartLine === other.oldStartLine &&
+            this.oldLineCount === other.oldLineCount &&
+            this.newStartLine === other.newStartLine &&
+            this.oldStartLine === other.oldStartLine);
+    }
+}
 
 exports.NewLineSymbol = void 0;
 (function (NewLineSymbol) {
@@ -443,29 +188,19 @@ function relativeChanges(addition, deletion) {
     const aEndStr = stringA.slice(-2);
     const bEndStr = stringB.slice(-2);
     const hasNewLineChanged = addition.noTrailingNewLine !== deletion.noTrailingNewLine;
-    if (_stringA === _stringB && (hasNewLineChanged || aEndStr !== bEndStr)) {
+    const aSymbol = aEndStr === "\r\n" ? exports.NewLineSymbol.CRLF : aEndStr.endsWith("\r") ? exports.NewLineSymbol.CR : exports.NewLineSymbol.LF;
+    const bSymbol = bEndStr === "\r\n" ? exports.NewLineSymbol.CRLF : bEndStr.endsWith("\r") ? exports.NewLineSymbol.CR : exports.NewLineSymbol.LF;
+    if (_stringA === _stringB && (hasNewLineChanged || aSymbol !== bSymbol)) {
         return {
             stringARange: {
                 location: _stringA.length,
                 length: stringA.length - _stringA.length,
-                newLineSymbol: hasNewLineChanged
-                    ? exports.NewLineSymbol.NEWLINE
-                    : aEndStr === "\r\n"
-                        ? exports.NewLineSymbol.CRLF
-                        : aEndStr.endsWith("\r")
-                            ? exports.NewLineSymbol.CR
-                            : exports.NewLineSymbol.LF,
+                newLineSymbol: hasNewLineChanged ? exports.NewLineSymbol.NEWLINE : aSymbol,
             },
             stringBRange: {
                 location: _stringB.length,
                 length: stringB.length - _stringB.length,
-                newLineSymbol: hasNewLineChanged
-                    ? exports.NewLineSymbol.NEWLINE
-                    : bEndStr === "\r\n"
-                        ? exports.NewLineSymbol.CRLF
-                        : bEndStr.endsWith("\r")
-                            ? exports.NewLineSymbol.CR
-                            : exports.NewLineSymbol.LF,
+                newLineSymbol: hasNewLineChanged ? exports.NewLineSymbol.NEWLINE : bSymbol,
             },
         };
     }
@@ -527,530 +262,801 @@ class DiffLine {
     withNoTrailingNewLine(noTrailingNewLine) {
         return new DiffLine(this.text, this.type, this.originalLineNumber, this.oldLineNumber, this.newLineNumber, noTrailingNewLine);
     }
-    isIncludeableLine() {
-        return this.type === exports.DiffLineType.Add || this.type === exports.DiffLineType.Delete;
+    isIncludeableLine() {
+        return this.type === exports.DiffLineType.Add || this.type === exports.DiffLineType.Delete;
+    }
+    /** The content of the line, i.e., without the line type marker. */
+    get content() {
+        return this.text.substring(1);
+    }
+    equals(other) {
+        return (this.text === other.text &&
+            this.type === other.type &&
+            this.originalLineNumber === other.originalLineNumber &&
+            this.oldLineNumber === other.oldLineNumber &&
+            this.newLineNumber === other.newLineNumber &&
+            this.noTrailingNewLine === other.noTrailingNewLine);
+    }
+    clone(text) {
+        return new DiffLine(text, this.type, this.originalLineNumber, this.oldLineNumber, this.newLineNumber);
+    }
+}
+const checkDiffLineIncludeChange = (diffLine) => {
+    if (!diffLine)
+        return false;
+    return diffLine.type === exports.DiffLineType.Add || diffLine.type === exports.DiffLineType.Delete;
+};
+
+/** How many new lines will be added to a diff hunk by default. */
+const DefaultDiffExpansionStep = 40;
+function assertNever(_, message) {
+    throw new Error(message);
+}
+/** Utility function for getting the digit count of the largest line number in an array of diff hunks */
+function getLargestLineNumber(hunks) {
+    var _a, _b;
+    if (hunks.length === 0) {
+        return 0;
+    }
+    for (let i = hunks.length - 1; i >= 0; i--) {
+        const hunk = hunks[i];
+        for (let j = hunk.lines.length - 1; j >= 0; j--) {
+            const line = hunk.lines[j];
+            if (line.type === exports.DiffLineType.Hunk) {
+                continue;
+            }
+            const newLineNumber = (_a = line.newLineNumber) !== null && _a !== void 0 ? _a : 0;
+            const oldLineNumber = (_b = line.oldLineNumber) !== null && _b !== void 0 ? _b : 0;
+            return newLineNumber > oldLineNumber ? newLineNumber : oldLineNumber;
+        }
+    }
+    return 0;
+}
+/**
+ * Calculates whether or not a hunk header can be expanded up, down, both, or if
+ * the space represented by the hunk header is short and expansion there would
+ * mean merging with the hunk above.
+ *
+ * @param hunkIndex     Index of the hunk to evaluate within the whole diff.
+ * @param hunkHeader    Header of the hunk to evaluate.
+ * @param previousHunk  Hunk previous to the one to evaluate. Null if the
+ *                      evaluated hunk is the first one.
+ */
+function getHunkHeaderExpansionType(hunkIndex, hunkHeader, previousHunk) {
+    const distanceToPrevious = previousHunk === null
+        ? Infinity
+        : hunkHeader.oldStartLine - previousHunk.header.oldStartLine - previousHunk.header.oldLineCount;
+    // In order to simplify the whole logic around expansion, only the hunk at the
+    // top can be expanded up exclusively, and only the hunk at the bottom (the
+    // dummy one, see getTextDiffWithBottomDummyHunk) can be expanded down
+    // exclusively.
+    // The rest of the hunks can be expanded both ways, except those which are too
+    // short and therefore the direction of expansion doesn't matter.
+    if (hunkIndex === 0) {
+        // The top hunk can only be expanded if there is content above it
+        if (hunkHeader.oldStartLine > 1 && hunkHeader.newStartLine > 1) {
+            return exports.DiffHunkExpansionType.Up;
+        }
+        else {
+            return exports.DiffHunkExpansionType.None;
+        }
+    }
+    else if (distanceToPrevious <= DefaultDiffExpansionStep) {
+        return exports.DiffHunkExpansionType.Short;
+    }
+    else {
+        return exports.DiffHunkExpansionType.Both;
+    }
+}
+const numIterator = (num, cb) => {
+    const re = [];
+    for (let i = 0; i < num; i++) {
+        re.push(cb(i));
+    }
+    return re;
+};
+const getLang = (fileName) => {
+    const dotIndex = fileName.lastIndexOf(".");
+    const extension = fileName.slice(dotIndex + 1);
+    return extension;
+};
+const getDiffRange = (additions, deletions) => {
+    if (additions.length === deletions.length) {
+        const len = additions.length;
+        for (let i = 0; i < len; i++) {
+            const addition = additions[i];
+            const deletion = deletions[i];
+            const hasDiffRange = hasRelativeChange(addition, deletion);
+            if (hasDiffRange) {
+                const { stringARange, stringBRange } = relativeChanges(addition, deletion);
+                addition.needRematch = true;
+                addition.range = stringARange;
+                deletion.needRematch = true;
+                deletion.range = stringBRange;
+            }
+        }
+    }
+};
+
+/* eslint-disable max-lines */
+// !NOTE: ALL of the diff parse logic copy from desktop, SEE https://github.com/desktop/desktop
+// https://en.wikipedia.org/wiki/Diff_utility
+//
+// @@ -l,s +l,s @@ optional section heading
+//
+// The hunk range information contains two hunk ranges. The range for the hunk of the original
+// file is preceded by a minus symbol, and the range for the new file is preceded by a plus
+// symbol. Each hunk range is of the format l,s where l is the starting line number and s is
+// the number of lines the change hunk applies to for each respective file.
+//
+// In many versions of GNU diff, each range can omit the comma and trailing value s,
+// in which case s defaults to 1
+const diffHeaderRe = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
+/**
+ * Regular expression matching invisible bidirectional Unicode characters that
+ * may be interpreted or compiled differently than what it appears. More info:
+ * https://github.co/hiddenchars
+ */
+const HiddenBidiCharsRegex = /[\u202A-\u202E]|[\u2066-\u2069]/;
+const DiffPrefixAdd = "+";
+const DiffPrefixDelete = "-";
+const DiffPrefixContext = " ";
+const DiffPrefixNoNewline = "\\";
+const DiffLinePrefixChars = new Set([
+    DiffPrefixAdd,
+    DiffPrefixDelete,
+    DiffPrefixContext,
+    DiffPrefixNoNewline,
+]);
+/**
+ * A parser for the GNU unified diff format
+ *
+ * See https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html
+ */
+class DiffParser {
+    constructor() {
+        Object.defineProperty(this, "__v_skip", { value: true });
+        this.reset();
+    }
+    /**
+     * Resets the internal parser state so that it can be reused.
+     *
+     * This is done automatically at the end of each parse run.
+     */
+    reset() {
+        this.ls = 0;
+        this.le = -1;
+        this.text = "";
+    }
+    /**
+     * Aligns the internal character pointers at the boundaries of
+     * the next line.
+     *
+     * Returns true if successful or false if the end of the diff
+     * has been reached.
+     */
+    nextLine() {
+        this.ls = this.le + 1;
+        // We've reached the end of the diff
+        if (this.ls >= this.text.length) {
+            return false;
+        }
+        this.le = this.text.indexOf("\n", this.ls);
+        // If we can't find the next newline character we'll put our
+        // end pointer at the end of the diff string
+        if (this.le === -1) {
+            this.le = this.text.length;
+        }
+        // We've succeeded if there's anything to read in between the
+        // start and the end
+        return this.ls !== this.le;
+    }
+    /**
+     * Advances to the next line and returns it as a substring
+     * of the raw diff text. Returns null if end of diff was
+     * reached.
+     */
+    readLine(header) {
+        if (header) {
+            return this.nextLine() ? this.text.substring(this.ls, this.le) : null;
+        }
+        else {
+            return this.nextLine() ? this.text.substring(this.ls + 1, this.le + 1) : null;
+        }
+    }
+    /** Tests if the current line starts with the given search text */
+    lineStartsWith(searchString) {
+        return this.text.startsWith(searchString, this.ls);
     }
-    /** The content of the line, i.e., without the line type marker. */
-    get content() {
-        return this.text.substring(1);
+    /** Tests if the current line ends with the given search text */
+    lineEndsWith(searchString) {
+        return this.text.endsWith(searchString, this.le);
     }
-    equals(other) {
-        return (this.text === other.text &&
-            this.type === other.type &&
-            this.originalLineNumber === other.originalLineNumber &&
-            this.oldLineNumber === other.oldLineNumber &&
-            this.newLineNumber === other.newLineNumber &&
-            this.noTrailingNewLine === other.noTrailingNewLine);
+    /**
+     * Returns the starting character of the next line without
+     * advancing the internal state. Returns null if advancing
+     * would mean reaching the end of the diff.
+     */
+    peek() {
+        const p = this.le + 1;
+        return p < this.text.length ? this.text[p] : null;
     }
-    clone(text) {
-        return new DiffLine(text, this.type, this.originalLineNumber, this.oldLineNumber, this.newLineNumber);
+    /**
+     * Parse the diff header, meaning everything from the
+     * start of the diff output to the end of the line beginning
+     * with +++
+     *
+     * Example diff header:
+     *
+     *   diff --git a/app/src/lib/diff-parser.ts b/app/src/lib/diff-parser.ts
+     *   index e1d4871..3bd3ee0 100644
+     *   --- a/app/src/lib/diff-parser.ts
+     *   +++ b/app/src/lib/diff-parser.ts
+     *
+     * Returns an object with information extracted from the diff
+     * header (currently whether it's a binary patch) or null if
+     * the end of the diff was reached before the +++ line could be
+     * found (which is a valid state).
+     */
+    parseDiffHeader() {
+        // TODO: There's information in here that we might want to
+        // capture, such as mode changes
+        while (this.nextLine()) {
+            if (this.lineStartsWith("Binary files ") && this.lineEndsWith("differ")) {
+                return { isBinary: true };
+            }
+            if (this.lineStartsWith("+++")) {
+                return { isBinary: false };
+            }
+        }
+        // It's not an error to not find the +++ line, see the
+        // 'parses diff of empty file' test in diff-parser-tests.ts
+        return null;
     }
-}
-const checkDiffLineIncludeChange = (diffLine) => {
-    if (!diffLine)
-        return false;
-    return diffLine.type === exports.DiffLineType.Add || diffLine.type === exports.DiffLineType.Delete;
-};
-
-var DiffHunkExpansionType;
-(function (DiffHunkExpansionType) {
-    /** The hunk header cannot be expanded at all. */
-    DiffHunkExpansionType["None"] = "None";
     /**
-     * The hunk header can be expanded up exclusively. Only the first hunk can be
-     * expanded up exclusively.
+     * Attempts to convert a RegExp capture group into a number.
+     * If the group doesn't exist or wasn't captured the function
+     * will return the value of the defaultValue parameter or throw
+     * an error if no default value was provided. If the captured
+     * string can't be converted to a number an error will be thrown.
      */
-    DiffHunkExpansionType["Up"] = "Up";
+    numberFromGroup(m, group, defaultValue = null) {
+        const str = m[group];
+        if (!str) {
+            if (!defaultValue) {
+                throw new Error(`Group ${group} missing from regexp match and no defaultValue was provided`);
+            }
+            return defaultValue;
+        }
+        const num = parseInt(str, 10);
+        if (isNaN(num)) {
+            throw new Error(`Could not parse capture group ${group} into number: ${str}`);
+        }
+        return num;
+    }
     /**
-     * The hunk header can be expanded down exclusively. Only the last hunk (if
-     * it's the dummy hunk with only one line) can be expanded down exclusively.
+     * Parses a hunk header or throws an error if the given line isn't
+     * a well-formed hunk header.
+     *
+     * We currently only extract the line number information and
+     * ignore any hunk headings.
+     *
+     * Example hunk header (text within ``):
+     *
+     * `@@ -84,10 +82,8 @@ export function parseRawDiff(lines: ReadonlyArray<string>): Diff {`
+     *
+     * Where everything after the last @@ is what's known as the hunk, or section, heading
      */
-    DiffHunkExpansionType["Down"] = "Down";
-    /** The hunk header can be expanded both up and down. */
-    DiffHunkExpansionType["Both"] = "Both";
+    parseHunkHeader(line) {
+        const m = diffHeaderRe.exec(line);
+        if (!m) {
+            throw new Error(`Invalid hunk header format`);
+        }
+        // If endLines are missing default to 1, see diffHeaderRe docs
+        const oldStartLine = this.numberFromGroup(m, 1);
+        const oldLineCount = this.numberFromGroup(m, 2, 1);
+        const newStartLine = this.numberFromGroup(m, 3);
+        const newLineCount = this.numberFromGroup(m, 4, 1);
+        return new DiffHunkHeader(oldStartLine, oldLineCount, newStartLine, newLineCount);
+    }
     /**
-     * The hunk header represents a short gap that, when expanded, will
-     * result in merging this hunk and the hunk above.
+     * Convenience function which lets us leverage the type system to
+     * prove exhaustive checks in parseHunk.
+     *
+     * Takes an arbitrary string and checks to see if the first character
+     * of that string is one of the allowed prefix characters for diff
+     * lines (ie lines in between hunk headers).
      */
-    DiffHunkExpansionType["Short"] = "Short";
-})(DiffHunkExpansionType || (DiffHunkExpansionType = {}));
-/** each diff is made up of a number of hunks */
-class DiffHunk {
+    parseLinePrefix(c) {
+        // Since we know that DiffLinePrefixChars and the DiffLinePrefix type
+        // include the same characters we can tell the type system that we
+        // now know that c[0] is one of the characters in the DifflinePrefix set
+        if (c && c.length && DiffLinePrefixChars.has(c[0])) {
+            return c[0];
+        }
+        return null;
+    }
     /**
-     * @param header The details from the diff hunk header about the line start and patch length.
-     * @param lines The contents - context and changes - of the diff section.
-     * @param unifiedDiffStart The diff hunk's start position in the overall file diff.
-     * @param unifiedDiffEnd The diff hunk's end position in the overall file diff.
+     * Parses a hunk, including its header or throws an error if the diff doesn't
+     * contain a well-formed diff hunk at the current position.
+     *
+     * Expects that the position has been advanced to the beginning of a presumed
+     * diff hunk header.
+     *
+     * @param linesConsumed The number of unified diff lines consumed up until
+     *                      this point by the diff parser. Used to give the
+     *                      position and length (in lines) of the parsed hunk
+     *                      relative to the overall parsed diff. These numbers
+     *                      have no real meaning in the context of a diff and
+     *                      are only used to aid the app in line-selections.
      */
-    constructor(header, lines, unifiedDiffStart, unifiedDiffEnd, expansionType) {
-        this.header = header;
-        this.lines = lines;
-        this.unifiedDiffStart = unifiedDiffStart;
-        this.unifiedDiffEnd = unifiedDiffEnd;
-        this.expansionType = expansionType;
+    parseHunk(linesConsumed, hunkIndex, previousHunk) {
+        const headerLine = this.readLine(true);
+        if (!headerLine) {
+            throw new Error("Expected hunk header but reached end of diff");
+        }
+        const header = this.parseHunkHeader(headerLine);
+        const lines = new Array();
+        lines.push(new DiffLine(headerLine, exports.DiffLineType.Hunk, 1, null, null));
+        let c;
+        let rollingDiffBeforeCounter = header.oldStartLine;
+        let rollingDiffAfterCounter = header.newStartLine;
+        let diffLineNumber = linesConsumed;
+        while ((c = this.parseLinePrefix(this.peek()))) {
+            const line = this.readLine(false);
+            diffLineNumber++;
+            if (!line) {
+                throw new Error("Expected unified diff line but reached end of diff");
+            }
+            // A marker indicating that the last line in the original or the new file
+            // is missing a trailing newline. In other words, the presence of this marker
+            // means that the new and/or original file lacks a trailing newline.
+            //
+            // When we find it we have to look up the previous line and set the
+            // noTrailingNewLine flag
+            if (c === DiffPrefixNoNewline) {
+                // See https://github.com/git/git/blob/21f862b498925194f8f1ebe8203b7a7df756555b/apply.c#L1725-L1732
+                if (line.length < 12) {
+                    throw new Error(`Expected "no newline at end of file" marker to be at least 12 bytes long`);
+                }
+                const previousLineIndex = lines.length - 1;
+                const previousLine = lines[previousLineIndex];
+                lines[previousLineIndex] = previousLine.withNoTrailingNewLine(true);
+                continue;
+            }
+            let diffLine;
+            if (c === DiffPrefixAdd) {
+                diffLine = new DiffLine(line, exports.DiffLineType.Add, diffLineNumber, null, rollingDiffAfterCounter++);
+            }
+            else if (c === DiffPrefixDelete) {
+                diffLine = new DiffLine(line, exports.DiffLineType.Delete, diffLineNumber, rollingDiffBeforeCounter++, null);
+            }
+            else if (c === DiffPrefixContext) {
+                diffLine = new DiffLine(line, exports.DiffLineType.Context, diffLineNumber, rollingDiffBeforeCounter++, rollingDiffAfterCounter++);
+            }
+            else {
+                return assertNever(c, `Unknown DiffLinePrefix: ${c}`);
+            }
+            lines.push(diffLine);
+        }
+        if (lines.length === 1) {
+            throw new Error("Malformed diff, empty hunk");
+        }
+        return new DiffHunk(header, lines, linesConsumed, linesConsumed + lines.length - 1, getHunkHeaderExpansionType(hunkIndex, header, previousHunk));
     }
-    equals(other) {
-        if (this === other) {
-            return true;
+    /**
+     * Parse a well-formed unified diff into hunks and lines.
+     *
+     * @param text A unified diff produced by git diff, git log --patch
+     *             or any other git plumbing command that produces unified
+     *             diffs.
+     */
+    parse(text) {
+        this.text = text;
+        try {
+            const headerInfo = this.parseDiffHeader();
+            const headerEnd = this.le;
+            const header = this.text.substring(0, headerEnd);
+            // empty diff
+            if (!headerInfo) {
+                return {
+                    header,
+                    contents: "",
+                    hunks: [],
+                    isBinary: false,
+                    maxLineNumber: 0,
+                    hasHiddenBidiChars: false,
+                };
+            }
+            if (headerInfo.isBinary) {
+                return {
+                    header,
+                    contents: "",
+                    hunks: [],
+                    isBinary: true,
+                    maxLineNumber: 0,
+                    hasHiddenBidiChars: false,
+                };
+            }
+            const hunks = new Array();
+            let linesConsumed = 0;
+            let previousHunk = null;
+            do {
+                const hunk = this.parseHunk(linesConsumed, hunks.length, previousHunk);
+                hunks.push(hunk);
+                previousHunk = hunk;
+                linesConsumed += hunk.lines.length;
+            } while (this.peek());
+            const contents = this.text
+                .substring(headerEnd + 1, this.le)
+                // Note that this simply returns a reference to the
+                // substring if no match is found, it does not create
+                // a new string instance.
+                .replace(/\n\/g, "");
+            return {
+                header,
+                contents,
+                hunks,
+                isBinary: headerInfo.isBinary,
+                maxLineNumber: getLargestLineNumber(hunks),
+                hasHiddenBidiChars: HiddenBidiCharsRegex.test(text),
+            };
+        }
+        finally {
+            this.reset();
         }
-        return (this.header.equals(other.header) &&
-            this.unifiedDiffStart === other.unifiedDiffStart &&
-            this.unifiedDiffEnd === other.unifiedDiffEnd &&
-            this.expansionType === other.expansionType &&
-            this.lines.length === other.lines.length &&
-            this.lines.every((xLine, ix) => xLine.equals(other.lines[ix])));
-    }
-}
-/** details about the start and end of a diff hunk */
-class DiffHunkHeader {
-    /**
-     * @param oldStartLine The line in the old (or original) file where this diff hunk starts.
-     * @param oldLineCount The number of lines in the old (or original) file that this diff hunk covers
-     * @param newStartLine The line in the new file where this diff hunk starts.
-     * @param newLineCount The number of lines in the new file that this diff hunk covers.
-     */
-    constructor(oldStartLine, oldLineCount, newStartLine, newLineCount) {
-        this.oldStartLine = oldStartLine;
-        this.oldLineCount = oldLineCount;
-        this.newStartLine = newStartLine;
-        this.newLineCount = newLineCount;
-    }
-    toDiffLineRepresentation() {
-        return `@@ -${this.oldStartLine},${this.oldLineCount} +${this.newStartLine},${this.newLineCount} @@`;
-    }
-    equals(other) {
-        return (this.oldStartLine === other.oldStartLine &&
-            this.oldLineCount === other.oldLineCount &&
-            this.newStartLine === other.newStartLine &&
-            this.oldStartLine === other.oldStartLine);
     }
 }
+const parseInstance = new DiffParser();
 
-/** How many new lines will be added to a diff hunk by default. */
-const DefaultDiffExpansionStep = 20;
-function assertNever(_, message) {
-    throw new Error(message);
-}
-/** Utility function for getting the digit count of the largest line number in an array of diff hunks */
-function getLargestLineNumber(hunks) {
-    var _a, _b;
-    if (hunks.length === 0) {
-        return 0;
-    }
-    for (let i = hunks.length - 1; i >= 0; i--) {
-        const hunk = hunks[i];
-        for (let j = hunk.lines.length - 1; j >= 0; j--) {
-            const line = hunk.lines[j];
-            if (line.type === exports.DiffLineType.Hunk) {
-                continue;
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const processAST = (ast) => {
+    let lineNumber = 1;
+    const syntaxObj = {};
+    const loopAST = (nodes, wrapper) => {
+        nodes.forEach((node) => {
+            if (node.type === "text") {
+                if (node.value.indexOf("\n") === -1) {
+                    const valueLength = node.value.length;
+                    if (!syntaxObj[lineNumber]) {
+                        node.startIndex = 0;
+                        node.endIndex = valueLength - 1;
+                        const item = {
+                            value: node.value,
+                            lineNumber,
+                            valueLength,
+                            nodeList: [{ node, wrapper }],
+                        };
+                        syntaxObj[lineNumber] = item;
+                    }
+                    else {
+                        node.startIndex = syntaxObj[lineNumber].valueLength;
+                        node.endIndex = node.startIndex + valueLength - 1;
+                        syntaxObj[lineNumber].value += node.value;
+                        syntaxObj[lineNumber].valueLength += valueLength;
+                        syntaxObj[lineNumber].nodeList.push({ node, wrapper });
+                    }
+                    node.lineNumber = lineNumber;
+                    return;
+                }
+                const lines = node.value.split("\n");
+                node.children = node.children || [];
+                for (let i = 0; i < lines.length; i++) {
+                    const _value = i === lines.length - 1 ? lines[i] : lines[i] + "\n";
+                    const _lineNumber = i === 0 ? lineNumber : ++lineNumber;
+                    const _valueLength = _value.length;
+                    const _node = {
+                        type: "text",
+                        value: _value,
+                        startIndex: Infinity,
+                        endIndex: Infinity,
+                        lineNumber: _lineNumber,
+                    };
+                    if (!syntaxObj[_lineNumber]) {
+                        _node.startIndex = 0;
+                        _node.endIndex = _valueLength - 1;
+                        const item = {
+                            value: _value,
+                            lineNumber: _lineNumber,
+                            valueLength: _valueLength,
+                            nodeList: [{ node: _node, wrapper }],
+                        };
+                        syntaxObj[_lineNumber] = item;
+                    }
+                    else {
+                        _node.startIndex = syntaxObj[_lineNumber].valueLength;
+                        _node.endIndex = _node.startIndex + _valueLength - 1;
+                        syntaxObj[_lineNumber].value += _value;
+                        syntaxObj[_lineNumber].valueLength += _valueLength;
+                        syntaxObj[_lineNumber].nodeList.push({ node: _node, wrapper });
+                    }
+                    node.children.push(_node);
+                }
+                node.lineNumber = lineNumber;
+                return;
             }
-            const newLineNumber = (_a = line.newLineNumber) !== null && _a !== void 0 ? _a : 0;
-            const oldLineNumber = (_b = line.oldLineNumber) !== null && _b !== void 0 ? _b : 0;
-            return newLineNumber > oldLineNumber ? newLineNumber : oldLineNumber;
+            if (node.children) {
+                loopAST(node.children, node);
+                node.lineNumber = lineNumber;
+            }
+        });
+    };
+    loopAST(ast.children);
+    return { syntaxFileObject: syntaxObj, syntaxFileLineNumber: lineNumber };
+};
+
+const lowlight = lowlight$1.createLowlight(lowlight$1.all);
+// !SEE https://github.com/highlightjs/highlightjs-vue
+lowlight.register("vue", function hljsDefineVue(hljs) {
+    return {
+        subLanguage: "xml",
+        contains: [
+            hljs.COMMENT("<!--", "-->", {
+                relevance: 10,
+            }),
+            {
+                begin: /^(\s*)(<script>)/gm,
+                end: /^(\s*)(<\/script>)/gm,
+                subLanguage: "javascript",
+                excludeBegin: true,
+                excludeEnd: true,
+            },
+            {
+                begin: /^(?:\s*)(?:<script\s+lang=(["'])ts\1>)/gm,
+                end: /^(\s*)(<\/script>)/gm,
+                subLanguage: "typescript",
+                excludeBegin: true,
+                excludeEnd: true,
+            },
+            {
+                begin: /^(\s*)(<style(\s+scoped)?>)/gm,
+                end: /^(\s*)(<\/style>)/gm,
+                subLanguage: "css",
+                excludeBegin: true,
+                excludeEnd: true,
+            },
+            {
+                begin: /^(?:\s*)(?:<style(?:\s+scoped)?\s+lang=(["'])(?:s[ca]ss)\1(?:\s+scoped)?>)/gm,
+                end: /^(\s*)(<\/style>)/gm,
+                subLanguage: "scss",
+                excludeBegin: true,
+                excludeEnd: true,
+            },
+            {
+                begin: /^(?:\s*)(?:<style(?:\s+scoped)?\s+lang=(["'])stylus\1(?:\s+scoped)?>)/gm,
+                end: /^(\s*)(<\/style>)/gm,
+                subLanguage: "stylus",
+                excludeBegin: true,
+                excludeEnd: true,
+            },
+        ],
+    };
+});
+const instance = { name: "lowlight" };
+let _maxLineToIgnoreSyntax = 2000;
+const _ignoreSyntaxHighlightList = [];
+Object.defineProperty(instance, "maxLineToIgnoreSyntax", {
+    get: () => _maxLineToIgnoreSyntax,
+});
+Object.defineProperty(instance, "setMaxLineToIgnoreSyntax", {
+    value: (v) => {
+        _maxLineToIgnoreSyntax = v;
+    },
+});
+Object.defineProperty(instance, "ignoreSyntaxHighlightList", {
+    get: () => _ignoreSyntaxHighlightList,
+});
+Object.defineProperty(instance, "setIgnoreSyntaxHighlightList", {
+    value: (v) => {
+        _ignoreSyntaxHighlightList.length = 0;
+        _ignoreSyntaxHighlightList.push(...v);
+    },
+});
+Object.defineProperty(instance, "getAST", {
+    value: (raw, fileName, lang) => {
+        let hasRegisteredLang = true;
+        if (!lowlight.registered(lang)) {
+            console.warn(`not support current lang: ${lang} yet`);
+            hasRegisteredLang = false;
+        }
+        if (fileName &&
+            highlighter.ignoreSyntaxHighlightList.some((item) => item instanceof RegExp ? item.test(fileName) : fileName === item)) {
+            console.warn(`ignore syntax for current file, because the fileName is in the ignoreSyntaxHighlightList: ${fileName}`);
+            return;
         }
-    }
-    return 0;
-}
-/**
- * Calculates whether or not a hunk header can be expanded up, down, both, or if
- * the space represented by the hunk header is short and expansion there would
- * mean merging with the hunk above.
- *
- * @param hunkIndex     Index of the hunk to evaluate within the whole diff.
- * @param hunkHeader    Header of the hunk to evaluate.
- * @param previousHunk  Hunk previous to the one to evaluate. Null if the
- *                      evaluated hunk is the first one.
- */
-function getHunkHeaderExpansionType(hunkIndex, hunkHeader, previousHunk) {
-    const distanceToPrevious = previousHunk === null
-        ? Infinity
-        : hunkHeader.oldStartLine - previousHunk.header.oldStartLine - previousHunk.header.oldLineCount;
-    // In order to simplify the whole logic around expansion, only the hunk at the
-    // top can be expanded up exclusively, and only the hunk at the bottom (the
-    // dummy one, see getTextDiffWithBottomDummyHunk) can be expanded down
-    // exclusively.
-    // The rest of the hunks can be expanded both ways, except those which are too
-    // short and therefore the direction of expansion doesn't matter.
-    if (hunkIndex === 0) {
-        // The top hunk can only be expanded if there is content above it
-        if (hunkHeader.oldStartLine > 1 && hunkHeader.newStartLine > 1) {
-            return DiffHunkExpansionType.Up;
+        if (hasRegisteredLang) {
+            return lowlight.highlight(lang, raw);
         }
         else {
-            return DiffHunkExpansionType.None;
-        }
-    }
-    else if (distanceToPrevious <= DefaultDiffExpansionStep) {
-        return DiffHunkExpansionType.Short;
-    }
-    else {
-        return DiffHunkExpansionType.Both;
-    }
-}
-const numIterator = (num, cb) => {
-    const re = [];
-    for (let i = 0; i < num; i++) {
-        re.push(cb(i));
-    }
-    return re;
-};
-const getLang = (fileName) => {
-    const dotIndex = fileName.lastIndexOf(".");
-    const extension = fileName.slice(dotIndex + 1);
-    return extension;
-};
-const getDiffRange = (additions, deletions) => {
-    if (additions.length === deletions.length) {
-        const len = additions.length;
-        for (let i = 0; i < len; i++) {
-            const addition = additions[i];
-            const deletion = deletions[i];
-            const hasDiffRange = hasRelativeChange(addition, deletion);
-            if (hasDiffRange) {
-                const { stringARange, stringBRange } = relativeChanges(addition, deletion);
-                addition.needRematch = true;
-                addition.range = stringARange;
-                deletion.needRematch = true;
-                deletion.range = stringBRange;
-            }
+            return lowlight.highlightAuto(raw);
         }
-    }
-};
+    },
+});
+Object.defineProperty(instance, "processAST", {
+    value: (ast) => {
+        return processAST(ast);
+    },
+});
+Object.defineProperty(instance, "hasRegisteredCurrentLang", {
+    value: (lang) => {
+        return lowlight.registered(lang);
+    },
+});
+const highlighter = instance;
 
-/* eslint-disable max-lines */
-// !NOTE: ALL of the diff parse logic copy from desktop, SEE https://github.com/desktop/desktop
-// https://en.wikipedia.org/wiki/Diff_utility
-//
-// @@ -l,s +l,s @@ optional section heading
-//
-// The hunk range information contains two hunk ranges. The range for the hunk of the original
-// file is preceded by a minus symbol, and the range for the new file is preceded by a plus
-// symbol. Each hunk range is of the format l,s where l is the starting line number and s is
-// the number of lines the change hunk applies to for each respective file.
-//
-// In many versions of GNU diff, each range can omit the comma and trailing value s,
-// in which case s defaults to 1
-const diffHeaderRe = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/;
-/**
- * Regular expression matching invisible bidirectional Unicode characters that
- * may be interpreted or compiled differently than what it appears. More info:
- * https://github.co/hiddenchars
- */
-const HiddenBidiCharsRegex = /[\u202A-\u202E]|[\u2066-\u2069]/;
-const DiffPrefixAdd = "+";
-const DiffPrefixDelete = "-";
-const DiffPrefixContext = " ";
-const DiffPrefixNoNewline = "\\";
-const DiffLinePrefixChars = new Set([
-    DiffPrefixAdd,
-    DiffPrefixDelete,
-    DiffPrefixContext,
-    DiffPrefixNoNewline,
-]);
-/**
- * A parser for the GNU unified diff format
- *
- * See https://www.gnu.org/software/diffutils/manual/html_node/Detailed-Unified.html
- */
-class DiffParser {
+var _Cache_keyArray, _Cache_maxLength;
+class Cache extends Map {
     constructor() {
-        Object.defineProperty(this, "__v_skip", { value: true });
-        this.reset();
-    }
-    /**
-     * Resets the internal parser state so that it can be reused.
-     *
-     * This is done automatically at the end of each parse run.
-     */
-    reset() {
-        this.ls = 0;
-        this.le = -1;
-        this.text = "";
-    }
-    /**
-     * Aligns the internal character pointers at the boundaries of
-     * the next line.
-     *
-     * Returns true if successful or false if the end of the diff
-     * has been reached.
-     */
-    nextLine() {
-        this.ls = this.le + 1;
-        // We've reached the end of the diff
-        if (this.ls >= this.text.length) {
-            return false;
-        }
-        this.le = this.text.indexOf("\n", this.ls);
-        // If we can't find the next newline character we'll put our
-        // end pointer at the end of the diff string
-        if (this.le === -1) {
-            this.le = this.text.length;
-        }
-        // We've succeeded if there's anything to read in between the
-        // start and the end
-        return this.ls !== this.le;
-    }
-    /**
-     * Advances to the next line and returns it as a substring
-     * of the raw diff text. Returns null if end of diff was
-     * reached.
-     */
-    readLine(header) {
-        if (header) {
-            return this.nextLine() ? this.text.substring(this.ls, this.le) : null;
-        }
-        else {
-            return this.nextLine() ? this.text.substring(this.ls + 1, this.le + 1) : null;
-        }
-    }
-    /** Tests if the current line starts with the given search text */
-    lineStartsWith(searchString) {
-        return this.text.startsWith(searchString, this.ls);
-    }
-    /** Tests if the current line ends with the given search text */
-    lineEndsWith(searchString) {
-        return this.text.endsWith(searchString, this.le);
-    }
-    /**
-     * Returns the starting character of the next line without
-     * advancing the internal state. Returns null if advancing
-     * would mean reaching the end of the diff.
-     */
-    peek() {
-        const p = this.le + 1;
-        return p < this.text.length ? this.text[p] : null;
-    }
-    /**
-     * Parse the diff header, meaning everything from the
-     * start of the diff output to the end of the line beginning
-     * with +++
-     *
-     * Example diff header:
-     *
-     *   diff --git a/app/src/lib/diff-parser.ts b/app/src/lib/diff-parser.ts
-     *   index e1d4871..3bd3ee0 100644
-     *   --- a/app/src/lib/diff-parser.ts
-     *   +++ b/app/src/lib/diff-parser.ts
-     *
-     * Returns an object with information extracted from the diff
-     * header (currently whether it's a binary patch) or null if
-     * the end of the diff was reached before the +++ line could be
-     * found (which is a valid state).
-     */
-    parseDiffHeader() {
-        // TODO: There's information in here that we might want to
-        // capture, such as mode changes
-        while (this.nextLine()) {
-            if (this.lineStartsWith("Binary files ") && this.lineEndsWith("differ")) {
-                return { isBinary: true };
-            }
-            if (this.lineStartsWith("+++")) {
-                return { isBinary: false };
-            }
-        }
-        // It's not an error to not find the +++ line, see the
-        // 'parses diff of empty file' test in diff-parser-tests.ts
-        return null;
+        super(...arguments);
+        _Cache_keyArray.set(this, []);
+        _Cache_maxLength.set(this, 30);
     }
-    /**
-     * Attempts to convert a RegExp capture group into a number.
-     * If the group doesn't exist or wasn't captured the function
-     * will return the value of the defaultValue parameter or throw
-     * an error if no default value was provided. If the captured
-     * string can't be converted to a number an error will be thrown.
-     */
-    numberFromGroup(m, group, defaultValue = null) {
-        const str = m[group];
-        if (!str) {
-            if (!defaultValue) {
-                throw new Error(`Group ${group} missing from regexp match and no defaultValue was provided`);
-            }
-            return defaultValue;
-        }
-        const num = parseInt(str, 10);
-        if (isNaN(num)) {
-            throw new Error(`Could not parse capture group ${group} into number: ${str}`);
-        }
-        return num;
+    setMaxLength(length) {
+        __classPrivateFieldSet(this, _Cache_maxLength, length, "f");
+        this._checkLength();
     }
-    /**
-     * Parses a hunk header or throws an error if the given line isn't
-     * a well-formed hunk header.
-     *
-     * We currently only extract the line number information and
-     * ignore any hunk headings.
-     *
-     * Example hunk header (text within ``):
-     *
-     * `@@ -84,10 +82,8 @@ export function parseRawDiff(lines: ReadonlyArray<string>): Diff {`
-     *
-     * Where everything after the last @@ is what's known as the hunk, or section, heading
-     */
-    parseHunkHeader(line) {
-        const m = diffHeaderRe.exec(line);
-        if (!m) {
-            throw new Error(`Invalid hunk header format`);
+    set(key, value) {
+        if (this.has(key))
+            return this;
+        __classPrivateFieldGet(this, _Cache_keyArray, "f").push(key);
+        this._checkLength();
+        return super.set(key, value);
+    }
+    _checkLength() {
+        while (__classPrivateFieldGet(this, _Cache_keyArray, "f").length > __classPrivateFieldGet(this, _Cache_maxLength, "f")) {
+            const key = __classPrivateFieldGet(this, _Cache_keyArray, "f").shift();
+            this.delete(key);
         }
-        // If endLines are missing default to 1, see diffHeaderRe docs
-        const oldStartLine = this.numberFromGroup(m, 1);
-        const oldLineCount = this.numberFromGroup(m, 2, 1);
-        const newStartLine = this.numberFromGroup(m, 3);
-        const newLineCount = this.numberFromGroup(m, 4, 1);
-        return new DiffHunkHeader(oldStartLine, oldLineCount, newStartLine, newLineCount);
     }
-    /**
-     * Convenience function which lets us leverage the type system to
-     * prove exhaustive checks in parseHunk.
-     *
-     * Takes an arbitrary string and checks to see if the first character
-     * of that string is one of the allowed prefix characters for diff
-     * lines (ie lines in between hunk headers).
-     */
-    parseLinePrefix(c) {
-        // Since we know that DiffLinePrefixChars and the DiffLinePrefix type
-        // include the same characters we can tell the type system that we
-        // now know that c[0] is one of the characters in the DifflinePrefix set
-        if (c && c.length && DiffLinePrefixChars.has(c[0])) {
-            return c[0];
+}
+_Cache_keyArray = new WeakMap(), _Cache_maxLength = new WeakMap();
+
+var _File_instances, _File_doCheck;
+const map = new Cache();
+const devKey = "@git-diff-cache";
+map.setMaxLength(50);
+map.name = "@git-diff-view/core";
+if (typeof globalThis !== "undefined") {
+    if (Array.isArray(globalThis[devKey])) {
+        globalThis[devKey] = globalThis[devKey].filter((i) => i !== map);
+        if (globalThis[devKey].length > 0) {
+            console.warn("there are multiple instance of @git-diff-view/core in the one environment!");
         }
-        return null;
+        globalThis[devKey].push(map);
     }
-    /**
-     * Parses a hunk, including its header or throws an error if the diff doesn't
-     * contain a well-formed diff hunk at the current position.
-     *
-     * Expects that the position has been advanced to the beginning of a presumed
-     * diff hunk header.
-     *
-     * @param linesConsumed The number of unified diff lines consumed up until
-     *                      this point by the diff parser. Used to give the
-     *                      position and length (in lines) of the parsed hunk
-     *                      relative to the overall parsed diff. These numbers
-     *                      have no real meaning in the context of a diff and
-     *                      are only used to aid the app in line-selections.
-     */
-    parseHunk(linesConsumed, hunkIndex, previousHunk) {
-        const headerLine = this.readLine(true);
-        if (!headerLine) {
-            throw new Error("Expected hunk header but reached end of diff");
+    else {
+        globalThis[devKey] = [map];
+    }
+}
+class File {
+    static createInstance(data) {
+        const file = new File(data === null || data === void 0 ? void 0 : data.raw, data === null || data === void 0 ? void 0 : data.lang, data === null || data === void 0 ? void 0 : data.fileName);
+        file.ast = data === null || data === void 0 ? void 0 : data.ast;
+        file.rawFile = data === null || data === void 0 ? void 0 : data.rawFile;
+        file.hasDoRaw = data === null || data === void 0 ? void 0 : data.hasDoRaw;
+        file.rawLength = data === null || data === void 0 ? void 0 : data.rawLength;
+        file.syntaxFile = data === null || data === void 0 ? void 0 : data.syntaxFile;
+        file.hasDoSyntax = data === null || data === void 0 ? void 0 : data.hasDoSyntax;
+        file.syntaxLength = data === null || data === void 0 ? void 0 : data.syntaxLength;
+        file.highlighterName = data === null || data === void 0 ? void 0 : data.highlighterName;
+        file.maxLineNumber = data === null || data === void 0 ? void 0 : data.maxLineNumber;
+        return file;
+    }
+    constructor(raw, lang, fileName) {
+        _File_instances.add(this);
+        this.raw = raw;
+        this.lang = lang;
+        this.fileName = fileName;
+        this.rawFile = {};
+        this.hasDoRaw = false;
+        this.syntaxFile = {};
+        this.hasDoSyntax = false;
+        this.maxLineNumber = 0;
+        Object.defineProperty(this, "__v_skip", { value: true });
+    }
+    doSyntax({ registerHighlighter }) {
+        if (!this.raw || this.hasDoSyntax)
+            return;
+        const _highlighter = registerHighlighter || highlighter;
+        if (this.syntaxLength) {
+            console.error("current file already doSyntax before!");
+            return;
         }
-        const header = this.parseHunkHeader(headerLine);
-        const lines = new Array();
-        lines.push(new DiffLine(headerLine, exports.DiffLineType.Hunk, 1, null, null));
-        let c;
-        let rollingDiffBeforeCounter = header.oldStartLine;
-        let rollingDiffAfterCounter = header.newStartLine;
-        let diffLineNumber = linesConsumed;
-        while ((c = this.parseLinePrefix(this.peek()))) {
-            const line = this.readLine(false);
-            diffLineNumber++;
-            if (!line) {
-                throw new Error("Expected unified diff line but reached end of diff");
-            }
-            // A marker indicating that the last line in the original or the new file
-            // is missing a trailing newline. In other words, the presence of this marker
-            // means that the new and/or original file lacks a trailing newline.
-            //
-            // When we find it we have to look up the previous line and set the
-            // noTrailingNewLine flag
-            if (c === DiffPrefixNoNewline) {
-                // See https://github.com/git/git/blob/21f862b498925194f8f1ebe8203b7a7df756555b/apply.c#L1725-L1732
-                if (line.length < 12) {
-                    throw new Error(`Expected "no newline at end of file" marker to be at least 12 bytes long`);
-                }
-                const previousLineIndex = lines.length - 1;
-                const previousLine = lines[previousLineIndex];
-                lines[previousLineIndex] = previousLine.withNoTrailingNewLine(true);
-                continue;
-            }
-            let diffLine;
-            if (c === DiffPrefixAdd) {
-                diffLine = new DiffLine(line, exports.DiffLineType.Add, diffLineNumber, null, rollingDiffAfterCounter++);
-            }
-            else if (c === DiffPrefixDelete) {
-                diffLine = new DiffLine(line, exports.DiffLineType.Delete, diffLineNumber, rollingDiffBeforeCounter++, null);
-            }
-            else if (c === DiffPrefixContext) {
-                diffLine = new DiffLine(line, exports.DiffLineType.Context, diffLineNumber, rollingDiffBeforeCounter++, rollingDiffAfterCounter++);
-            }
-            else {
-                return assertNever(c, `Unknown DiffLinePrefix: ${c}`);
-            }
-            lines.push(diffLine);
+        if (this.rawLength > _highlighter.maxLineToIgnoreSyntax) {
+            console.warn(`ignore syntax for current file, because the rawLength is too long: ${this.rawLength}`);
+            return;
         }
-        if (lines.length === 1) {
-            throw new Error("Malformed diff, empty hunk");
+        this.ast = _highlighter.getAST(this.raw, this.fileName, this.lang);
+        if (!this.ast)
+            return;
+        const { syntaxFileObject, syntaxFileLineNumber } = _highlighter.processAST(this.ast);
+        this.syntaxFile = syntaxFileObject;
+        this.syntaxLength = syntaxFileLineNumber;
+        this.highlighterName = _highlighter.name;
+        {
+            __classPrivateFieldGet(this, _File_instances, "m", _File_doCheck).call(this);
         }
-        return new DiffHunk(header, lines, linesConsumed, linesConsumed + lines.length - 1, getHunkHeaderExpansionType(hunkIndex, header, previousHunk));
+        this.hasDoSyntax = true;
     }
-    /**
-     * Parse a well-formed unified diff into hunks and lines.
-     *
-     * @param text A unified diff produced by git diff, git log --patch
-     *             or any other git plumbing command that produces unified
-     *             diffs.
-     */
-    parse(text) {
-        this.text = text;
-        try {
-            const headerInfo = this.parseDiffHeader();
-            const headerEnd = this.le;
-            const header = this.text.substring(0, headerEnd);
-            // empty diff
-            if (!headerInfo) {
-                return {
-                    header,
-                    contents: "",
-                    hunks: [],
-                    isBinary: false,
-                    maxLineNumber: 0,
-                    hasHiddenBidiChars: false,
-                };
-            }
-            if (headerInfo.isBinary) {
-                return {
-                    header,
-                    contents: "",
-                    hunks: [],
-                    isBinary: true,
-                    maxLineNumber: 0,
-                    hasHiddenBidiChars: false,
-                };
-            }
-            const hunks = new Array();
-            let linesConsumed = 0;
-            let previousHunk = null;
-            do {
-                const hunk = this.parseHunk(linesConsumed, hunks.length, previousHunk);
-                hunks.push(hunk);
-                previousHunk = hunk;
-                linesConsumed += hunk.lines.length;
-            } while (this.peek());
-            const contents = this.text
-                .substring(headerEnd + 1, this.le)
-                // Note that this simply returns a reference to the
-                // substring if no match is found, it does not create
-                // a new string instance.
-                .replace(/\n\/g, "");
-            return {
-                header,
-                contents,
-                hunks,
-                isBinary: headerInfo.isBinary,
-                maxLineNumber: getLargestLineNumber(hunks),
-                hasHiddenBidiChars: HiddenBidiCharsRegex.test(text),
-            };
-        }
-        finally {
-            this.reset();
+    doRaw() {
+        if (!this.raw || this.hasDoRaw)
+            return;
+        const rawString = this.raw;
+        const rawArray = rawString.split("\n");
+        this.rawLength = rawArray.length;
+        this.maxLineNumber = rawArray.length;
+        this.rawFile = {};
+        for (let i = 0; i < rawArray.length; i++) {
+            this.rawFile[i + 1] = i < rawArray.length - 1 ? rawArray[i] + "\n" : rawArray[i];
         }
+        // reduce 对于大数组性能很差
+        // this.rawFile = rawArray.reduce(
+        //   (p, item, index) => ({
+        //     ...p,
+        //     [index + 1]: index < rawArray.length - 1 ? item + "\n" : item,
+        //   }),
+        //   {}
+        // );
+        this.hasDoRaw = true;
     }
 }
-const parseInstance = new DiffParser();
+_File_instances = new WeakSet(), _File_doCheck = function _File_doCheck() {
+    if (this.rawLength && this.syntaxLength) {
+        if (this.rawLength !== this.syntaxLength) {
+            console.warn("the rawLength not match for the syntaxLength");
+        }
+        Object.values(this.syntaxFile).forEach(({ value, lineNumber }) => {
+            if (value !== this.rawFile[lineNumber]) {
+                console.log("some line not match:" + value + " __ " + this.rawFile[lineNumber] + " __ at: " + lineNumber + " lineNumber");
+            }
+        });
+    }
+};
+const getFile = (raw, lang, fileName) => {
+    const key = raw + "--" + "0.0.12" + "--" + lang;
+    if (map.has(key))
+        return map.get(key);
+    const file = new File(raw, lang, fileName);
+    map.set(key, file);
+    return file;
+};
+const _cacheMap = map;
 
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-/* eslint-disable max-lines */
-var _DiffFile_instances, _DiffFile_oldFileResult, _DiffFile_newFileResult, _DiffFile_diffListResults, _DiffFile_diffLines, _DiffFile_oldFileDiffLines, _DiffFile_newFileDiffLines, _DiffFile_oldFileLines, _DiffFile_newFileLines, _DiffFile_oldFileSyntaxLines, _DiffFile_newFileSyntaxLines, _DiffFile_oldFilePlaceholderLines, _DiffFile_newFilePlaceholderLines, _DiffFile_splitLeftLines, _DiffFile_splitRightLines, _DiffFile_splitHunksLines, _DiffFile_unifiedLines, _DiffFile_unifiedHunksLines, _DiffFile_listeners, _DiffFile_hasInitRaw, _DiffFile_hasInitSyntax, _DiffFile_hasBuildSplit, _DiffFile_hasBuildUnified, _DiffFile_updateCount, _DiffFile_composeByDiff, _DiffFile_highlighterName, _DiffFile_id, _DiffFile_clonedInstance, _DiffFile_doDiff, _DiffFile_doFile, _DiffFile_composeRaw, _DiffFile_composeFile, _DiffFile_composeDiff, _DiffFile_composeSyntax, _DiffFile_getOldDiffLine, _DiffFile_getNewDiffLine, _DiffFile_getOldRawLine, _DiffFile_getNewRawLine;
+var _DiffFile_instances, _DiffFile_oldFileResult, _DiffFile_newFileResult, _DiffFile_diffListResults, _DiffFile_diffLines, _DiffFile_oldFileDiffLines, _DiffFile_newFileDiffLines, _DiffFile_oldFileLines, _DiffFile_newFileLines, _DiffFile_oldFileSyntaxLines, _DiffFile_newFileSyntaxLines, _DiffFile_oldFilePlaceholderLines, _DiffFile_newFilePlaceholderLines, _DiffFile_splitLeftLines, _DiffFile_splitRightLines, _DiffFile_splitHunksLines, _DiffFile_unifiedLines, _DiffFile_unifiedHunksLines, _DiffFile_listeners, _DiffFile_hasInitRaw, _DiffFile_hasInitSyntax, _DiffFile_hasBuildSplit, _DiffFile_hasBuildUnified, _DiffFile_updateCount, _DiffFile_composeByDiff, _DiffFile_composeByMerge, _DiffFile_composeByFullMerge, _DiffFile_highlighterName, _DiffFile_id, _DiffFile_clonedInstance, _DiffFile_doDiff, _DiffFile_doFile, _DiffFile_composeRaw, _DiffFile_composeFile, _DiffFile_composeDiff, _DiffFile_composeSyntax, _DiffFile_getOldDiffLine, _DiffFile_getNewDiffLine, _DiffFile_getOldRawLine, _DiffFile_getNewRawLine;
 const composeLen = 40;
 const idSet = new Set();
 class DiffFile {
@@ -1058,7 +1064,12 @@ class DiffFile {
         var _a, _b, _c, _d, _e, _f;
         const instance = new DiffFile(((_a = data === null || data === void 0 ? void 0 : data.oldFile) === null || _a === void 0 ? void 0 : _a.fileName) || "", ((_b = data === null || data === void 0 ? void 0 : data.oldFile) === null || _b === void 0 ? void 0 : _b.content) || "", ((_c = data === null || data === void 0 ? void 0 : data.newFile) === null || _c === void 0 ? void 0 : _c.fileName) || "", ((_d = data === null || data === void 0 ? void 0 : data.newFile) === null || _d === void 0 ? void 0 : _d.content) || "", (data === null || data === void 0 ? void 0 : data.hunks) || [], ((_e = data === null || data === void 0 ? void 0 : data.oldFile) === null || _e === void 0 ? void 0 : _e.fileLang) || "", ((_f = data === null || data === void 0 ? void 0 : data.newFile) === null || _f === void 0 ? void 0 : _f.fileLang) || "");
         if (bundle) {
-            instance.mergeBundle(bundle);
+            if (bundle.isFullMerge) {
+                instance._mergeFullBundle(bundle);
+            }
+            else {
+                instance.mergeBundle(bundle);
+            }
         }
         return instance;
     }
@@ -1091,8 +1102,10 @@ class DiffFile {
         _DiffFile_hasBuildUnified.set(this, false);
         _DiffFile_updateCount.set(this, 0);
         _DiffFile_composeByDiff.set(this, false);
+        _DiffFile_composeByMerge.set(this, false);
+        _DiffFile_composeByFullMerge.set(this, false);
         _DiffFile_highlighterName.set(this, void 0);
-        this._version_ = "0.0.11";
+        this._version_ = "0.0.12";
         this._oldFileContent = "";
         this._oldFileLang = "";
         this._newFileContent = "";
@@ -1100,9 +1113,9 @@ class DiffFile {
         this.diffLineLength = 0;
         this.splitLineLength = 0;
         this.unifiedLineLength = 0;
-        this.expandSplitAll = false;
-        this.expandUnifiedAll = false;
-        this.hasCollapsed = false;
+        this.hasExpandSplitAll = false;
+        this.hasExpandUnifiedAll = false;
+        this.hasSomeLineCollapsed = false;
         _DiffFile_id.set(this, "");
         _DiffFile_clonedInstance.set(this, new Map());
         this.getSplitLeftLine = (index) => {
@@ -1241,13 +1254,13 @@ class DiffFile {
                 Object.keys(__classPrivateFieldGet(this, _DiffFile_splitHunksLines, "f") || {}).forEach((key) => {
                     this.onSplitHunkExpand("all", +key, false);
                 });
-                this.expandSplitAll = true;
+                this.hasExpandSplitAll = true;
             }
             else {
                 Object.keys(__classPrivateFieldGet(this, _DiffFile_unifiedHunksLines, "f") || {}).forEach((key) => {
                     this.onUnifiedHunkExpand("all", +key, false);
                 });
-                this.expandUnifiedAll = true;
+                this.hasExpandUnifiedAll = true;
             }
             this.notifyAll();
         };
@@ -1279,7 +1292,7 @@ class DiffFile {
                         __classPrivateFieldGet(this, _DiffFile_splitHunksLines, "f")[item.splitInfo.endHiddenIndex] = item;
                     }
                 });
-                this.expandSplitAll = false;
+                this.hasExpandSplitAll = false;
             }
             else {
                 Object.values(__classPrivateFieldGet(this, _DiffFile_unifiedLines, "f") || {}).forEach((item) => {
@@ -1301,7 +1314,7 @@ class DiffFile {
                         __classPrivateFieldGet(this, _DiffFile_unifiedHunksLines, "f")[item.unifiedInfo.endHiddenIndex] = item;
                     }
                 });
-                this.expandUnifiedAll = false;
+                this.hasExpandUnifiedAll = false;
             }
             this.notifyAll();
         };
@@ -1353,7 +1366,7 @@ class DiffFile {
             const unifiedLineLength = this.unifiedLineLength;
             const composeByDiff = __classPrivateFieldGet(this, _DiffFile_composeByDiff, "f");
             const highlighterName = __classPrivateFieldGet(this, _DiffFile_highlighterName, "f");
-            const hasCollapsed = this.hasCollapsed;
+            const hasSomeLineCollapsed = this.hasSomeLineCollapsed;
             // split
             const splitLeftLines = __classPrivateFieldGet(this, _DiffFile_splitLeftLines, "f");
             const splitRightLines = __classPrivateFieldGet(this, _DiffFile_splitRightLines, "f");
@@ -1384,8 +1397,9 @@ class DiffFile {
                 unifiedHunkLines,
                 highlighterName,
                 composeByDiff,
-                hasCollapsed,
+                hasSomeLineCollapsed,
                 version,
+                isFullMerge: false,
             };
         };
         this.mergeBundle = (data) => {
@@ -1405,12 +1419,14 @@ class DiffFile {
             __classPrivateFieldSet(this, _DiffFile_newFilePlaceholderLines, data.newFilePlaceholderLines, "f");
             this.splitLineLength = data.splitLineLength;
             this.unifiedLineLength = data.unifiedLineLength;
-            this.hasCollapsed = data.hasCollapsed;
+            this.hasSomeLineCollapsed = data.hasSomeLineCollapsed;
             __classPrivateFieldSet(this, _DiffFile_splitLeftLines, data.splitLeftLines, "f");
             __classPrivateFieldSet(this, _DiffFile_splitRightLines, data.splitRightLines, "f");
             __classPrivateFieldSet(this, _DiffFile_splitHunksLines, data.splitHunkLines, "f");
             __classPrivateFieldSet(this, _DiffFile_unifiedLines, data.unifiedLines, "f");
             __classPrivateFieldSet(this, _DiffFile_unifiedHunksLines, data.unifiedHunkLines, "f");
+            // mark this instance as a merged instance
+            __classPrivateFieldSet(this, _DiffFile_composeByMerge, true, "f");
             if (this._version_ !== data.version) {
                 console.error("the version of the `diffInstance` is not match, some error may happen!");
             }
@@ -1447,14 +1463,21 @@ class DiffFile {
             return Object.assign(Object.assign({}, bundle), { oldFileResult,
                 newFileResult,
                 diffLines,
-                diffListResults });
+                diffListResults, 
+                // get current instance is a fullMerge instance or not
+                isFullMerge: __classPrivateFieldGet(this, _DiffFile_composeByMerge, "f") ? __classPrivateFieldGet(this, _DiffFile_composeByFullMerge, "f") : true });
         };
         this._mergeFullBundle = (data) => {
             this.mergeBundle(data);
-            __classPrivateFieldSet(this, _DiffFile_oldFileResult, data.oldFileResult, "f");
-            __classPrivateFieldSet(this, _DiffFile_newFileResult, data.newFileResult, "f");
-            __classPrivateFieldSet(this, _DiffFile_diffLines, data.diffLines, "f");
-            __classPrivateFieldSet(this, _DiffFile_diffListResults, data.diffListResults, "f");
+            try {
+                __classPrivateFieldSet(this, _DiffFile_oldFileResult, File.createInstance(data.oldFileResult), "f");
+                __classPrivateFieldSet(this, _DiffFile_newFileResult, File.createInstance(data.newFileResult), "f");
+                __classPrivateFieldSet(this, _DiffFile_diffLines, data.diffLines, "f");
+                __classPrivateFieldSet(this, _DiffFile_diffListResults, data.diffListResults, "f");
+                __classPrivateFieldSet(this, _DiffFile_composeByFullMerge, data.isFullMerge, "f");
+            }
+            catch (_a) {
+            }
         };
         this._destroy = () => {
             this.clearId();
@@ -1529,6 +1552,10 @@ class DiffFile {
         var _a, _b;
         if (__classPrivateFieldGet(this, _DiffFile_hasInitSyntax, "f"))
             return;
+        if (__classPrivateFieldGet(this, _DiffFile_composeByMerge, "f") && !__classPrivateFieldGet(this, _DiffFile_composeByFullMerge, "f")) {
+            console.error(`this instance can not do syntax because of the data missing, try to use '_getFullBundle' & '_mergeFullBundle' instead of 'getBundle' & 'mergeBundle'`);
+            return;
+        }
         __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_composeSyntax).call(this, { registerHighlighter });
         __classPrivateFieldSet(this, _DiffFile_highlighterName, ((_a = __classPrivateFieldGet(this, _DiffFile_oldFileResult, "f")) === null || _a === void 0 ? void 0 : _a.highlighterName) || ((_b = __classPrivateFieldGet(this, _DiffFile_newFileResult, "f")) === null || _b === void 0 ? void 0 : _b.highlighterName) || __classPrivateFieldGet(this, _DiffFile_highlighterName, "f"), "f");
         __classPrivateFieldSet(this, _DiffFile_hasInitSyntax, true, "f");
@@ -1631,7 +1658,7 @@ class DiffFile {
                 hideStart = len;
             }
             if (isHidden) {
-                this.hasCollapsed = true;
+                this.hasSomeLineCollapsed = true;
             }
             prevIsHidden = isHidden;
             if (oldDiffLine && newDiffLine && !oldLineHasChange && !newLineHasChange) {
@@ -1762,7 +1789,7 @@ class DiffFile {
                 hideStart = len;
             }
             if (isHidden) {
-                this.hasCollapsed = true;
+                this.hasSomeLineCollapsed = true;
             }
             prevIsHidden = isHidden;
             if (oldDiffLine && newDiffLine && !oldLineHasChange && !newLineHasChange) {
@@ -1808,7 +1835,7 @@ class DiffFile {
         this.notifyAll();
     }
 }
-_DiffFile_oldFileResult = new WeakMap(), _DiffFile_newFileResult = new WeakMap(), _DiffFile_diffListResults = new WeakMap(), _DiffFile_diffLines = new WeakMap(), _DiffFile_oldFileDiffLines = new WeakMap(), _DiffFile_newFileDiffLines = new WeakMap(), _DiffFile_oldFileLines = new WeakMap(), _DiffFile_newFileLines = new WeakMap(), _DiffFile_oldFileSyntaxLines = new WeakMap(), _DiffFile_newFileSyntaxLines = new WeakMap(), _DiffFile_oldFilePlaceholderLines = new WeakMap(), _DiffFile_newFilePlaceholderLines = new WeakMap(), _DiffFile_splitLeftLines = new WeakMap(), _DiffFile_splitRightLines = new WeakMap(), _DiffFile_splitHunksLines = new WeakMap(), _DiffFile_unifiedLines = new WeakMap(), _DiffFile_unifiedHunksLines = new WeakMap(), _DiffFile_listeners = new WeakMap(), _DiffFile_hasInitRaw = new WeakMap(), _DiffFile_hasInitSyntax = new WeakMap(), _DiffFile_hasBuildSplit = new WeakMap(), _DiffFile_hasBuildUnified = new WeakMap(), _DiffFile_updateCount = new WeakMap(), _DiffFile_composeByDiff = new WeakMap(), _DiffFile_highlighterName = new WeakMap(), _DiffFile_id = new WeakMap(), _DiffFile_clonedInstance = new WeakMap(), _DiffFile_instances = new WeakSet(), _DiffFile_doDiff = function _DiffFile_doDiff() {
+_DiffFile_oldFileResult = new WeakMap(), _DiffFile_newFileResult = new WeakMap(), _DiffFile_diffListResults = new WeakMap(), _DiffFile_diffLines = new WeakMap(), _DiffFile_oldFileDiffLines = new WeakMap(), _DiffFile_newFileDiffLines = new WeakMap(), _DiffFile_oldFileLines = new WeakMap(), _DiffFile_newFileLines = new WeakMap(), _DiffFile_oldFileSyntaxLines = new WeakMap(), _DiffFile_newFileSyntaxLines = new WeakMap(), _DiffFile_oldFilePlaceholderLines = new WeakMap(), _DiffFile_newFilePlaceholderLines = new WeakMap(), _DiffFile_splitLeftLines = new WeakMap(), _DiffFile_splitRightLines = new WeakMap(), _DiffFile_splitHunksLines = new WeakMap(), _DiffFile_unifiedLines = new WeakMap(), _DiffFile_unifiedHunksLines = new WeakMap(), _DiffFile_listeners = new WeakMap(), _DiffFile_hasInitRaw = new WeakMap(), _DiffFile_hasInitSyntax = new WeakMap(), _DiffFile_hasBuildSplit = new WeakMap(), _DiffFile_hasBuildUnified = new WeakMap(), _DiffFile_updateCount = new WeakMap(), _DiffFile_composeByDiff = new WeakMap(), _DiffFile_composeByMerge = new WeakMap(), _DiffFile_composeByFullMerge = new WeakMap(), _DiffFile_highlighterName = new WeakMap(), _DiffFile_id = new WeakMap(), _DiffFile_clonedInstance = new WeakMap(), _DiffFile_instances = new WeakSet(), _DiffFile_doDiff = function _DiffFile_doDiff() {
     if (!this._diffList)
         return;
     __classPrivateFieldSet(this, _DiffFile_diffListResults, this._diffList.map((s) => parseInstance.parse(s)), "f");
@@ -2122,7 +2149,7 @@ const getUnifiedContentLine = (diffFile) => {
     return lines.filter((line) => line.type === exports.DiffFileLineType.content);
 };
 
-const versions = "0.0.11";
+const versions = "0.0.12";
 
 const useUnmount = (cb, deps) => {
     const ref = React.useRef(cb);
@@ -3565,7 +3592,7 @@ const _InternalDiffView = (props) => {
     ]);
     const value = React.useMemo(() => ({ useDiffContext }), [useDiffContext]);
     return (React__namespace.createElement(DiffViewContext.Provider, { value: value },
-        React__namespace.createElement("div", { className: "diff-tailwindcss-wrapper", "data-component": "git-diff-view", "data-version": `${"0.0.11"}`, "data-highlighter": diffFile._getHighlighterName() },
+        React__namespace.createElement("div", { className: "diff-tailwindcss-wrapper", "data-component": "git-diff-view", "data-version": `${"0.0.12"}`, "data-highlighter": diffFile._getHighlighterName() },
             React__namespace.createElement("div", { className: "diff-style-root", style: {
                     // @ts-ignore
                     [diffFontSizeName]: diffViewFontSize + "px",
@@ -3618,14 +3645,18 @@ const DiffViewWithRef = (props, ref) => {
 };
 const DiffView = React.forwardRef(DiffViewWithRef);
 DiffView.displayName = "DiffView";
-const version = "0.0.11";
+const version = "0.0.12";
 
 exports.DefaultDiffExpansionStep = DefaultDiffExpansionStep;
 exports.DiffFile = DiffFile;
+exports.DiffHunk = DiffHunk;
+exports.DiffHunkHeader = DiffHunkHeader;
 exports.DiffLine = DiffLine;
+exports.DiffParser = DiffParser;
 exports.DiffView = DiffView;
 exports.DiffViewContext = DiffViewContext;
 exports.File = File;
+exports.HiddenBidiCharsRegex = HiddenBidiCharsRegex;
 exports._cacheMap = _cacheMap;
 exports.assertNever = assertNever;
 exports.checkDiffLineIncludeChange = checkDiffLineIncludeChange;
@@ -3643,6 +3674,7 @@ exports.getUnifiedLines = getUnifiedLines;
 exports.hasRelativeChange = hasRelativeChange;
 exports.highlighter = highlighter;
 exports.numIterator = numIterator;
+exports.parseInstance = parseInstance;
 exports.processAST = processAST;
 exports.relativeChanges = relativeChanges;
 exports.useDiffViewContext = useDiffViewContext;