@git-diff-view/react 0.0.10 → 0.0.12

package/dist/cjs/index.development.js

@@ -72,340 +72,86 @@ 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;
-    }
-    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];
+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;
+    }
+    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.10" + "--" + 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) {
     NewLineSymbol[NewLineSymbol["CRLF"] = 1] = "CRLF";
     NewLineSymbol[NewLineSymbol["CR"] = 2] = "CR";
     NewLineSymbol[NewLineSymbol["LF"] = 3] = "LF";
+    NewLineSymbol[NewLineSymbol["NEWLINE"] = 4] = "NEWLINE";
 })(exports.NewLineSymbol || (exports.NewLineSymbol = {}));
 const maxLength = 1000;
 /** Get the maximum position in the range. */
@@ -430,25 +176,31 @@ function commonLength(stringA, rangeA, stringB, rangeB, reverse) {
 function isInValidString(s) {
     return s.trim().length === 0 || s.length >= maxLength;
 }
+// TODO maybe could use the original content line
 /** Get the changed ranges in the strings, relative to each other. */
-function relativeChanges(stringA, stringB) {
+function relativeChanges(addition, deletion) {
+    const stringA = addition.text;
+    const stringB = deletion.text;
     let bRange = { location: 0, length: stringB.length };
     let aRange = { location: 0, length: stringA.length };
     const _stringA = stringA.trimEnd();
     const _stringB = stringB.trimEnd();
     const aEndStr = stringA.slice(-2);
     const bEndStr = stringB.slice(-2);
-    if (_stringA === _stringB && aEndStr !== bEndStr && (aEndStr === "\r\n" || bEndStr === "\r\n")) {
+    const hasNewLineChanged = addition.noTrailingNewLine !== deletion.noTrailingNewLine;
+    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: 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: bEndStr === "\r\n" ? exports.NewLineSymbol.CRLF : bEndStr.endsWith("\r") ? exports.NewLineSymbol.CR : exports.NewLineSymbol.LF,
+                newLineSymbol: hasNewLineChanged ? exports.NewLineSymbol.NEWLINE : bSymbol,
             },
         };
     }
@@ -472,10 +224,12 @@ function relativeChanges(stringA, stringB) {
     return { stringARange: aRange, stringBRange: bRange };
 }
 /** Check two string have a diff range */
-function hasRelativeChange(stringA, stringB) {
-    const _stringA = stringA.trim();
-    const _stringB = stringB.trim();
-    const { stringARange, stringBRange } = relativeChanges(_stringA, _stringB);
+function hasRelativeChange(addition, deletion) {
+    const _stringA = addition.text.trim();
+    const _stringB = deletion.text.trim();
+    const _addition = addition.clone(_stringA);
+    const _deletion = deletion.clone(_stringB);
+    const { stringARange, stringBRange } = relativeChanges(_addition, _deletion);
     return (stringARange.location > 0 ||
         stringBRange.location > 0 ||
         stringARange.length < _stringA.length ||
@@ -523,6 +277,9 @@ class DiffLine {
             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)
@@ -530,82 +287,8 @@ const checkDiffLineIncludeChange = (diffLine) => {
     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.
-     */
-    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";
-})(DiffHunkExpansionType || (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;
-    }
-    equals(other) {
-        if (this === other) {
-            return 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])));
-    }
-}
-/** 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);
-    }
-}
-
 /** How many new lines will be added to a diff hunk by default. */
-const DefaultDiffExpansionStep = 20;
+const DefaultDiffExpansionStep = 40;
 function assertNever(_, message) {
     throw new Error(message);
 }
@@ -652,17 +335,17 @@ function getHunkHeaderExpansionType(hunkIndex, hunkHeader, previousHunk) {
     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;
+            return exports.DiffHunkExpansionType.Up;
         }
         else {
-            return DiffHunkExpansionType.None;
+            return exports.DiffHunkExpansionType.None;
         }
     }
     else if (distanceToPrevious <= DefaultDiffExpansionStep) {
-        return DiffHunkExpansionType.Short;
+        return exports.DiffHunkExpansionType.Short;
     }
     else {
-        return DiffHunkExpansionType.Both;
+        return exports.DiffHunkExpansionType.Both;
     }
 }
 const numIterator = (num, cb) => {
@@ -683,9 +366,9 @@ const getDiffRange = (additions, deletions) => {
         for (let i = 0; i < len; i++) {
             const addition = additions[i];
             const deletion = deletions[i];
-            const hasDiffRange = hasRelativeChange(addition.text, deletion.text);
+            const hasDiffRange = hasRelativeChange(addition, deletion);
             if (hasDiffRange) {
-                const { stringARange, stringBRange } = relativeChanges(addition.text, deletion.text);
+                const { stringARange, stringBRange } = relativeChanges(addition, deletion);
                 addition.needRematch = true;
                 addition.range = stringARange;
                 deletion.needRematch = true;
@@ -736,299 +419,644 @@ class DiffParser {
         this.reset();
     }
     /**
-     * Resets the internal parser state so that it can be reused.
+     * 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;
+    }
+    /**
+     * 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;
+    }
+    /**
+     * Parses a hunk header or throws an error if the given line isn't
+     * a well-formed hunk header.
      *
-     * This is done automatically at the end of each parse run.
+     * 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
      */
-    reset() {
-        this.ls = 0;
-        this.le = -1;
-        this.text = "";
+    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);
     }
     /**
-     * Aligns the internal character pointers at the boundaries of
-     * the next line.
+     * Convenience function which lets us leverage the type system to
+     * prove exhaustive checks in parseHunk.
      *
-     * Returns true if successful or false if the end of the diff
-     * has been reached.
+     * 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).
      */
-    nextLine() {
-        this.ls = this.le + 1;
-        // We've reached the end of the diff
-        if (this.ls >= this.text.length) {
-            return false;
+    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;
+    }
+    /**
+     * 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");
+        }
+        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));
+    }
+    /**
+     * 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();
+        }
+    }
+}
+const parseInstance = new DiffParser();
+
+/******************************************************************************
+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;
         }
-        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;
+        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;
         }
-        // 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;
+        if (hasRegisteredLang) {
+            return lowlight.highlight(lang, raw);
         }
         else {
-            return this.nextLine() ? this.text.substring(this.ls + 1, this.le + 1) : null;
+            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;
+
+var _Cache_keyArray, _Cache_maxLength;
+class Cache extends Map {
+    constructor() {
+        super(...arguments);
+        _Cache_keyArray.set(this, []);
+        _Cache_maxLength.set(this, 30);
     }
-    /** 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;
+    setMaxLength(length) {
+        __classPrivateFieldSet(this, _Cache_maxLength, length, "f");
+        this._checkLength();
     }
-    /**
-     * 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;
+    set(key, value) {
+        if (this.has(key))
+            return this;
+        __classPrivateFieldGet(this, _Cache_keyArray, "f").push(key);
+        this._checkLength();
+        return super.set(key, value);
     }
-    /**
-     * 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}`);
+    _checkLength() {
+        while (__classPrivateFieldGet(this, _Cache_keyArray, "f").length > __classPrivateFieldGet(this, _Cache_maxLength, "f")) {
+            const key = __classPrivateFieldGet(this, _Cache_keyArray, "f").shift();
+            this.delete(key);
         }
-        return num;
     }
-    /**
-     * 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`);
+}
+_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!");
         }
-        // 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);
+        globalThis[devKey].push(map);
     }
-    /**
-     * 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];
-        }
-        return null;
+    else {
+        globalThis[devKey] = [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");
+}
+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 {
@@ -1036,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;
     }
@@ -1069,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.10";
+        this._version_ = "0.0.12";
         this._oldFileContent = "";
         this._oldFileLang = "";
         this._newFileContent = "";
@@ -1078,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) => {
@@ -1219,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();
         };
@@ -1257,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) => {
@@ -1279,7 +1314,7 @@ class DiffFile {
                         __classPrivateFieldGet(this, _DiffFile_unifiedHunksLines, "f")[item.unifiedInfo.endHiddenIndex] = item;
                     }
                 });
-                this.expandUnifiedAll = false;
+                this.hasExpandUnifiedAll = false;
             }
             this.notifyAll();
         };
@@ -1331,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");
@@ -1362,8 +1397,9 @@ class DiffFile {
                 unifiedHunkLines,
                 highlighterName,
                 composeByDiff,
-                hasCollapsed,
+                hasSomeLineCollapsed,
                 version,
+                isFullMerge: false,
             };
         };
         this.mergeBundle = (data) => {
@@ -1383,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!");
             }
@@ -1425,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();
@@ -1507,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");
@@ -1609,7 +1658,7 @@ class DiffFile {
                 hideStart = len;
             }
             if (isHidden) {
-                this.hasCollapsed = true;
+                this.hasSomeLineCollapsed = true;
             }
             prevIsHidden = isHidden;
             if (oldDiffLine && newDiffLine && !oldLineHasChange && !newLineHasChange) {
@@ -1740,7 +1789,7 @@ class DiffFile {
                 hideStart = len;
             }
             if (isHidden) {
-                this.hasCollapsed = true;
+                this.hasSomeLineCollapsed = true;
             }
             prevIsHidden = isHidden;
             if (oldDiffLine && newDiffLine && !oldLineHasChange && !newLineHasChange) {
@@ -1786,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");
@@ -1816,31 +1865,33 @@ _DiffFile_oldFileResult = new WeakMap(), _DiffFile_newFileResult = new WeakMap()
         let oldLineNumber = 1;
         let oldFileContent = "";
         let newFileContent = "";
-        while (oldLineNumber <= this.diffLineLength) {
-            const index = oldLineNumber++;
-            const diffLine = __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getOldDiffLine).call(this, index);
-            if (diffLine) {
-                oldFileContent += diffLine.text;
+        let hasSymbolChanged = false;
+        while (oldLineNumber <= this.diffLineLength || newLineNumber <= this.diffLineLength) {
+            const oldIndex = oldLineNumber++;
+            const newIndex = newLineNumber++;
+            const oldDiffLine = __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getOldDiffLine).call(this, oldIndex);
+            const newDiffLine = __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getNewDiffLine).call(this, newIndex);
+            if (oldDiffLine) {
+                oldFileContent += oldDiffLine.text;
             }
             else {
                 // empty line for placeholder
                 oldFileContent += "\n";
-                oldFilePlaceholderLines[index] = true;
+                oldFilePlaceholderLines[oldIndex] = true;
             }
-        }
-        while (newLineNumber <= this.diffLineLength) {
-            const index = newLineNumber++;
-            const diffLine = __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getNewDiffLine).call(this, index);
-            if (diffLine) {
-                newFileContent += diffLine.text;
+            if (newDiffLine) {
+                newFileContent += newDiffLine.text;
             }
             else {
                 // empty line for placeholder
                 newFileContent += "\n";
-                newFilePlaceholderLines[index] = true;
+                newFilePlaceholderLines[newIndex] = true;
+            }
+            if (!hasSymbolChanged && oldDiffLine && newDiffLine) {
+                hasSymbolChanged = hasSymbolChanged || oldDiffLine.noTrailingNewLine !== newDiffLine.noTrailingNewLine;
             }
         }
-        if (oldFileContent === newFileContent)
+        if (!hasSymbolChanged && oldFileContent === newFileContent)
             return;
         this._oldFileContent = oldFileContent;
         this._newFileContent = newFileContent;
@@ -1855,21 +1906,25 @@ _DiffFile_oldFileResult = new WeakMap(), _DiffFile_newFileResult = new WeakMap()
         let newLineNumber = 1;
         let oldLineNumber = 1;
         let newFileContent = "";
+        let hasSymbolChanged = false;
         while (oldLineNumber <= __classPrivateFieldGet(this, _DiffFile_oldFileResult, "f").maxLineNumber) {
             const newDiffLine = __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getNewDiffLine).call(this, newLineNumber++);
+            const oldDiffLine = __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getOldDiffLine).call(this, oldLineNumber);
             if (newDiffLine) {
                 newFileContent += newDiffLine.text;
                 oldLineNumber = newDiffLine.oldLineNumber ? newDiffLine.oldLineNumber + 1 : oldLineNumber;
             }
             else {
-                const oldDiffLine = __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getOldDiffLine).call(this, oldLineNumber);
                 if (!oldDiffLine) {
                     newFileContent += __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getOldRawLine).call(this, oldLineNumber);
                 }
                 oldLineNumber++;
             }
+            if (!hasSymbolChanged && newDiffLine && oldDiffLine) {
+                hasSymbolChanged = hasSymbolChanged || newDiffLine.noTrailingNewLine !== oldDiffLine.noTrailingNewLine;
+            }
         }
-        if (newFileContent === this._oldFileContent)
+        if (!hasSymbolChanged && newFileContent === this._oldFileContent)
             return;
         this._newFileContent = newFileContent;
         __classPrivateFieldSet(this, _DiffFile_newFileResult, getFile(this._newFileContent, this._newFileLang, this._newFileName), "f");
@@ -1878,21 +1933,25 @@ _DiffFile_oldFileResult = new WeakMap(), _DiffFile_newFileResult = new WeakMap()
         let oldLineNumber = 1;
         let newLineNumber = 1;
         let oldFileContent = "";
+        let hasSymbolChanged = false;
         while (newLineNumber <= __classPrivateFieldGet(this, _DiffFile_newFileResult, "f").maxLineNumber) {
             const oldDiffLine = __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getOldDiffLine).call(this, oldLineNumber++);
+            const newDiffLine = __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getNewDiffLine).call(this, newLineNumber);
             if (oldDiffLine) {
                 oldFileContent += oldDiffLine.text;
                 newLineNumber = oldDiffLine.newLineNumber ? oldDiffLine.newLineNumber + 1 : newLineNumber;
             }
             else {
-                const newDiffLine = __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getNewDiffLine).call(this, newLineNumber);
                 if (!newDiffLine) {
                     oldFileContent += __classPrivateFieldGet(this, _DiffFile_instances, "m", _DiffFile_getNewRawLine).call(this, newLineNumber);
                 }
                 newLineNumber++;
             }
+            if (!hasSymbolChanged && newDiffLine && oldDiffLine) {
+                hasSymbolChanged = hasSymbolChanged || newDiffLine.noTrailingNewLine !== oldDiffLine.noTrailingNewLine;
+            }
         }
-        if (oldFileContent === this._newFileContent)
+        if (!hasSymbolChanged && oldFileContent === this._newFileContent)
             return;
         this._oldFileContent = oldFileContent;
         __classPrivateFieldSet(this, _DiffFile_oldFileResult, getFile(this._oldFileContent, this._oldFileLang, this._oldFileName), "f");
@@ -2090,7 +2149,7 @@ const getUnifiedContentLine = (diffFile) => {
     return lines.filter((line) => line.type === exports.DiffFileLineType.content);
 };
 
-const versions = "0.0.10";
+const versions = "0.0.12";
 
 const useUnmount = (cb, deps) => {
     const ref = React.useRef(cb);
@@ -2427,6 +2486,11 @@ const _DiffSplitHunkLineGitLab = ({ index, diffFile, side, lineNumber, }) => {
     var _a;
     const currentHunk = diffFile.getSplitHunkLine(index);
     const expandEnabled = diffFile.getExpandEnabled();
+    useSyncHeight({
+        selector: `tr[data-line="${lineNumber}-hunk"]`,
+        side: exports.SplitSide[exports.SplitSide.old],
+        enable: side === exports.SplitSide.new,
+    });
     const couldExpand = expandEnabled && currentHunk && currentHunk.splitInfo;
     const isExpandAll = currentHunk &&
         currentHunk.splitInfo &&
@@ -2480,8 +2544,8 @@ const DiffSplitHunkLine$1 = ({ index, diffFile, side, lineNumber, }) => {
 
 const DiffSplitAddWidget = ({ side, className, lineNumber, onWidgetClick, onOpenAddWidget, }) => {
     return (React__namespace.createElement("div", { className: "diff-add-widget-wrapper" + (className ? " " + className : ""), style: {
-            width: "calc(var(--diff-font-size--) * 1.4)",
-            height: "calc(var(--diff-font-size--) * 1.4)",
+            width: `calc(var(${diffFontSizeName}) * 1.4)`,
+            height: `calc(var(${diffFontSizeName}) * 1.4)`,
         } },
         React__namespace.createElement("button", { className: "diff-add-widget w-full h-full invisible cursor-pointer rounded-md flex items-center justify-center transition-transform origin-center group-hover:visible hover:scale-110", style: {
                 color: `var(${addWidgetColorName})`,
@@ -2495,8 +2559,8 @@ const DiffSplitAddWidget = ({ side, className, lineNumber, onWidgetClick, onOpen
 };
 const DiffUnifiedAddWidget = ({ lineNumber, side, onWidgetClick, onOpenAddWidget, }) => {
     return (React__namespace.createElement("div", { className: "diff-add-widget-wrapper absolute left-[100%] top-[1px] translate-x-[-50%]", style: {
-            width: "calc(var(--diff-font-size--) * 1.4)",
-            height: "calc(var(--diff-font-size--) * 1.4)",
+            width: `calc(var(${diffFontSizeName}) * 1.4)`,
+            height: `calc(var(${diffFontSizeName}) * 1.4)`,
         } },
         React__namespace.createElement("button", { className: "diff-add-widget w-full h-full invisible cursor-pointer rounded-md flex items-center justify-center transition-transform origin-center group-hover:visible hover:scale-110", style: {
                 color: `var(${addWidgetColorName})`,
@@ -2509,6 +2573,12 @@ const DiffUnifiedAddWidget = ({ lineNumber, side, onWidgetClick, onOpenAddWidget
             } }, "+")));
 };
 
+const DiffNoNewLine = () => {
+    return (React__namespace.createElement("svg", { "aria-label": "No newline at end of file", role: "img", viewBox: "0 0 16 16", version: "1.1", fill: "currentColor" },
+        React__namespace.createElement("path", { d: "M4.25 7.25a.75.75 0 0 0 0 1.5h7.5a.75.75 0 0 0 0-1.5h-7.5Z" }),
+        React__namespace.createElement("path", { d: "M16 8A8 8 0 1 1 0 8a8 8 0 0 1 16 0Zm-1.5 0a6.5 6.5 0 1 0-13 0 6.5 6.5 0 0 0 13 0Z" })));
+};
+
 const temp = {};
 const formatStringToCamelCase = (str) => {
     const splitted = str.split("-");
@@ -2533,7 +2603,7 @@ const getStyleObjectFromString = memoFunc((str) => {
     });
     return style;
 });
-const DiffString = ({ rawLine, diffLine, operator, }) => {
+const DiffString = ({ rawLine, diffLine, operator, enableWrap, }) => {
     const range = diffLine === null || diffLine === void 0 ? void 0 : diffLine.range;
     if (range) {
         const str1 = rawLine.slice(0, range.location);
@@ -2552,19 +2622,27 @@ const DiffString = ({ rawLine, diffLine, operator, }) => {
                         ? "␊"
                         : isNewLineSymbolChanged === exports.NewLineSymbol.CR
                             ? "␍"
-                            : "␍␊"}`
+                            : isNewLineSymbolChanged === exports.NewLineSymbol.CRLF
+                                ? "␍␊"
+                                : ""}`
                     : str2),
-                str3)));
+                str3),
+            isNewLineSymbolChanged === exports.NewLineSymbol.NEWLINE && diffLine.noTrailingNewLine && (React__namespace.createElement("span", { "data-no-newline-at-end-of-file": true, className: enableWrap ? "block text-red-500" : "inline-block align-middle text-red-500", style: {
+                    width: `var(${diffFontSizeName})`,
+                    height: `var(${diffFontSizeName})`,
+                } },
+                React__namespace.createElement(DiffNoNewLine, null)))));
     }
     return React__namespace.createElement("span", { className: "diff-line-content-raw" }, rawLine);
 };
-const DiffSyntax = ({ rawLine, diffLine, operator, syntaxLine, }) => {
+const DiffSyntax = ({ rawLine, diffLine, operator, syntaxLine, enableWrap, }) => {
     var _a, _b;
     if (!syntaxLine) {
         return React__namespace.createElement(DiffString, { rawLine: rawLine, diffLine: diffLine, operator: operator });
     }
     const range = diffLine === null || diffLine === void 0 ? void 0 : diffLine.range;
     if (range) {
+        const isNewLineSymbolChanged = range.newLineSymbol;
         return (React__namespace.createElement("span", { className: "diff-line-syntax-raw" },
             React__namespace.createElement("span", { "data-range-start": range.location, "data-range-end": range.location + range.length }, (_a = syntaxLine.nodeList) === null || _a === void 0 ? void 0 : _a.map(({ node, wrapper }, index) => {
                 var _a, _b, _c, _d, _e, _f;
@@ -2581,7 +2659,6 @@ const DiffSyntax = ({ rawLine, diffLine, operator, syntaxLine, }) => {
                     const isEnd = str3.length || node.endIndex === range.location + range.length - 1;
                     const isLast = str2.includes("\n");
                     const _str2 = isLast ? str2.replace("\n", "") : str2;
-                    const isNewLineSymbolChanged = range.newLineSymbol;
                     return (React__namespace.createElement("span", { key: index, "data-start": node.startIndex, "data-end": node.endIndex, className: (_e = (_d = wrapper === null || wrapper === void 0 ? void 0 : wrapper.properties) === null || _d === void 0 ? void 0 : _d.className) === null || _e === void 0 ? void 0 : _e.join(" "), style: getStyleObjectFromString(((_f = wrapper === null || wrapper === void 0 ? void 0 : wrapper.properties) === null || _f === void 0 ? void 0 : _f.style) || "") },
                         str1,
                         React__namespace.createElement("span", { "data-diff-highlight": true, style: {
@@ -2595,11 +2672,18 @@ const DiffSyntax = ({ rawLine, diffLine, operator, syntaxLine, }) => {
                                 ? "␊"
                                 : isNewLineSymbolChanged === exports.NewLineSymbol.CR
                                     ? "␍"
-                                    : "␍␊"}`
+                                    : isNewLineSymbolChanged === exports.NewLineSymbol.CRLF
+                                        ? "␍␊"
+                                        : ""}`
                             : str2),
                         str3));
                 }
-            }))));
+            })),
+            isNewLineSymbolChanged === exports.NewLineSymbol.NEWLINE && diffLine.noTrailingNewLine && (React__namespace.createElement("span", { "data-no-newline-at-end-of-file": true, className: enableWrap ? "block text-red-500" : "inline-block align-middle text-red-500", style: {
+                    width: `var(${diffFontSizeName})`,
+                    height: `var(${diffFontSizeName})`,
+                } },
+                React__namespace.createElement(DiffNoNewLine, null)))));
     }
     return (React__namespace.createElement("span", { className: "diff-line-syntax-raw" }, (_b = syntaxLine === null || syntaxLine === void 0 ? void 0 : syntaxLine.nodeList) === null || _b === void 0 ? void 0 : _b.map(({ node, wrapper }, index) => {
         var _a, _b, _c;
@@ -2616,7 +2700,7 @@ const DiffContent = ({ diffLine, rawLine, syntaxLine, enableWrap, enableHighligh
             wordBreak: enableWrap ? "break-all" : "initial",
         } },
         React__namespace.createElement("span", { "data-operator": isAdded ? "+" : isDelete ? "-" : undefined, className: "diff-line-content-operator inline-block w-[1.5em] ml-[-1.5em] indent-[0.2em] select-none" }, isAdded ? "+" : isDelete ? "-" : " "),
-        enableHighlight && syntaxLine && !isMaxLineLengthToIgnoreSyntax ? (React__namespace.createElement(DiffSyntax, { operator: isAdded ? "add" : isDelete ? "del" : undefined, rawLine: rawLine, diffLine: diffLine, syntaxLine: syntaxLine })) : (React__namespace.createElement(DiffString, { operator: isAdded ? "add" : isDelete ? "del" : undefined, rawLine: rawLine, diffLine: diffLine }))));
+        enableHighlight && syntaxLine && !isMaxLineLengthToIgnoreSyntax ? (React__namespace.createElement(DiffSyntax, { operator: isAdded ? "add" : isDelete ? "del" : undefined, rawLine: rawLine, diffLine: diffLine, syntaxLine: syntaxLine, enableWrap: enableWrap })) : (React__namespace.createElement(DiffString, { operator: isAdded ? "add" : isDelete ? "del" : undefined, rawLine: rawLine, diffLine: diffLine, enableWrap: enableWrap }))));
 };
 
 const DiffWidgetContext = React.createContext(null);
@@ -2765,7 +2849,7 @@ const DiffSplitViewNormal = React.memo(({ diffFile }) => {
                 [asideWidth]: `${Math.round(width)}px`,
                 overscrollBehaviorX: "none",
                 fontFamily: "Menlo, Consolas, monospace",
-                fontSize: "var(--diff-font-size--)",
+                fontSize: `var(${diffFontSizeName})`,
             } },
             React__namespace.createElement(DiffSplitViewTable, { side: exports.SplitSide.old, diffFile: diffFile })),
         React__namespace.createElement("div", { className: "diff-split-line w-[1.5px] bg-[rgb(222,222,222)]" }),
@@ -2774,7 +2858,7 @@ const DiffSplitViewNormal = React.memo(({ diffFile }) => {
                 [asideWidth]: `${Math.round(width)}px`,
                 overscrollBehaviorX: "none",
                 fontFamily: "Menlo, Consolas, monospace",
-                fontSize: "var(--diff-font-size--)",
+                fontSize: `var(${diffFontSizeName})`,
             } },
             React__namespace.createElement(DiffSplitViewTable, { side: exports.SplitSide.new, diffFile: diffFile }))));
 });
@@ -3065,7 +3149,7 @@ const DiffSplitViewWrap = React.memo(({ diffFile }) => {
     return (React__namespace.createElement("div", { className: "split-diff-view split-diff-view-normal w-full" },
         React__namespace.createElement("div", { className: "diff-table-wrapper w-full", style: {
                 fontFamily: "Menlo, Consolas, monospace",
-                fontSize: "var(--diff-font-size--)",
+                fontSize: `var(${diffFontSizeName})`,
             } },
             React__namespace.createElement(Style, { useSelector: splitSideInfo, id: `diff-root${diffFile.getId()}` }),
             React__namespace.createElement("table", { className: "diff-table border-collapse table-fixed w-full" },
@@ -3378,7 +3462,7 @@ const DiffUnifiedView = React.memo(({ diffFile }) => {
                     // @ts-ignore
                     [asideWidth]: `${Math.round(width)}px`,
                     fontFamily: "Menlo, Consolas, monospace",
-                    fontSize: "var(--diff-font-size--)",
+                    fontSize: `var(${diffFontSizeName})`,
                 } },
                 React__namespace.createElement("table", { className: "unified-diff-table border-collapse w-full" },
                     React__namespace.createElement("colgroup", null,
@@ -3508,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.10"}`, "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",
@@ -3561,18 +3645,23 @@ const DiffViewWithRef = (props, ref) => {
 };
 const DiffView = React.forwardRef(DiffViewWithRef);
 DiffView.displayName = "DiffView";
-const version = "0.0.10";
+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;
 exports.composeLen = composeLen;
+exports.diffFontSizeName = diffFontSizeName;
 exports.getDiffRange = getDiffRange;
 exports.getFile = getFile;
 exports.getHunkHeaderExpansionType = getHunkHeaderExpansionType;
@@ -3585,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;