@git-diff-view/react 0.0.3 → 0.0.6

package/dist/cjs/index.development.js

@@ -25,6 +25,1447 @@ function _interopNamespaceDefault(e) {
 
 var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 
+/**
+ * @module LRUCache
+ */
+const perf = typeof performance === 'object' &&
+    performance &&
+    typeof performance.now === 'function'
+    ? performance
+    : Date;
+const warned = new Set();
+/* c8 ignore start */
+const PROCESS = (typeof process === 'object' && !!process ? process : {});
+/* c8 ignore start */
+const emitWarning = (msg, type, code, fn) => {
+    typeof PROCESS.emitWarning === 'function'
+        ? PROCESS.emitWarning(msg, type, code, fn)
+        : console.error(`[${code}] ${type}: ${msg}`);
+};
+let AC = globalThis.AbortController;
+let AS = globalThis.AbortSignal;
+/* c8 ignore start */
+if (typeof AC === 'undefined') {
+    //@ts-ignore
+    AS = class AbortSignal {
+        onabort;
+        _onabort = [];
+        reason;
+        aborted = false;
+        addEventListener(_, fn) {
+            this._onabort.push(fn);
+        }
+    };
+    //@ts-ignore
+    AC = class AbortController {
+        constructor() {
+            warnACPolyfill();
+        }
+        signal = new AS();
+        abort(reason) {
+            if (this.signal.aborted)
+                return;
+            //@ts-ignore
+            this.signal.reason = reason;
+            //@ts-ignore
+            this.signal.aborted = true;
+            //@ts-ignore
+            for (const fn of this.signal._onabort) {
+                fn(reason);
+            }
+            this.signal.onabort?.(reason);
+        }
+    };
+    let printACPolyfillWarning = PROCESS.env?.LRU_CACHE_IGNORE_AC_WARNING !== '1';
+    const warnACPolyfill = () => {
+        if (!printACPolyfillWarning)
+            return;
+        printACPolyfillWarning = false;
+        emitWarning('AbortController is not defined. If using lru-cache in ' +
+            'node 14, load an AbortController polyfill from the ' +
+            '`node-abort-controller` package. A minimal polyfill is ' +
+            'provided for use by LRUCache.fetch(), but it should not be ' +
+            'relied upon in other contexts (eg, passing it to other APIs that ' +
+            'use AbortController/AbortSignal might have undesirable effects). ' +
+            'You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.', 'NO_ABORT_CONTROLLER', 'ENOTSUP', warnACPolyfill);
+    };
+}
+/* c8 ignore stop */
+const shouldWarn = (code) => !warned.has(code);
+const isPosInt = (n) => n && n === Math.floor(n) && n > 0 && isFinite(n);
+/* c8 ignore start */
+// This is a little bit ridiculous, tbh.
+// The maximum array length is 2^32-1 or thereabouts on most JS impls.
+// And well before that point, you're caching the entire world, I mean,
+// that's ~32GB of just integers for the next/prev links, plus whatever
+// else to hold that many keys and values.  Just filling the memory with
+// zeroes at init time is brutal when you get that big.
+// But why not be complete?
+// Maybe in the future, these limits will have expanded.
+const getUintArray = (max) => !isPosInt(max)
+    ? null
+    : max <= Math.pow(2, 8)
+        ? Uint8Array
+        : max <= Math.pow(2, 16)
+            ? Uint16Array
+            : max <= Math.pow(2, 32)
+                ? Uint32Array
+                : max <= Number.MAX_SAFE_INTEGER
+                    ? ZeroArray
+                    : null;
+/* c8 ignore stop */
+class ZeroArray extends Array {
+    constructor(size) {
+        super(size);
+        this.fill(0);
+    }
+}
+class Stack {
+    heap;
+    length;
+    // private constructor
+    static #constructing = false;
+    static create(max) {
+        const HeapCls = getUintArray(max);
+        if (!HeapCls)
+            return [];
+        Stack.#constructing = true;
+        const s = new Stack(max, HeapCls);
+        Stack.#constructing = false;
+        return s;
+    }
+    constructor(max, HeapCls) {
+        /* c8 ignore start */
+        if (!Stack.#constructing) {
+            throw new TypeError('instantiate Stack using Stack.create(n)');
+        }
+        /* c8 ignore stop */
+        this.heap = new HeapCls(max);
+        this.length = 0;
+    }
+    push(n) {
+        this.heap[this.length++] = n;
+    }
+    pop() {
+        return this.heap[--this.length];
+    }
+}
+/**
+ * Default export, the thing you're using this module to get.
+ *
+ * All properties from the options object (with the exception of
+ * {@link OptionsBase.max} and {@link OptionsBase.maxSize}) are added as
+ * normal public members. (`max` and `maxBase` are read-only getters.)
+ * Changing any of these will alter the defaults for subsequent method calls,
+ * but is otherwise safe.
+ */
+class LRUCache {
+    // properties coming in from the options of these, only max and maxSize
+    // really *need* to be protected. The rest can be modified, as they just
+    // set defaults for various methods.
+    #max;
+    #maxSize;
+    #dispose;
+    #disposeAfter;
+    #fetchMethod;
+    /**
+     * {@link LRUCache.OptionsBase.ttl}
+     */
+    ttl;
+    /**
+     * {@link LRUCache.OptionsBase.ttlResolution}
+     */
+    ttlResolution;
+    /**
+     * {@link LRUCache.OptionsBase.ttlAutopurge}
+     */
+    ttlAutopurge;
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnGet}
+     */
+    updateAgeOnGet;
+    /**
+     * {@link LRUCache.OptionsBase.updateAgeOnHas}
+     */
+    updateAgeOnHas;
+    /**
+     * {@link LRUCache.OptionsBase.allowStale}
+     */
+    allowStale;
+    /**
+     * {@link LRUCache.OptionsBase.noDisposeOnSet}
+     */
+    noDisposeOnSet;
+    /**
+     * {@link LRUCache.OptionsBase.noUpdateTTL}
+     */
+    noUpdateTTL;
+    /**
+     * {@link LRUCache.OptionsBase.maxEntrySize}
+     */
+    maxEntrySize;
+    /**
+     * {@link LRUCache.OptionsBase.sizeCalculation}
+     */
+    sizeCalculation;
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnFetchRejection}
+     */
+    noDeleteOnFetchRejection;
+    /**
+     * {@link LRUCache.OptionsBase.noDeleteOnStaleGet}
+     */
+    noDeleteOnStaleGet;
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchAbort}
+     */
+    allowStaleOnFetchAbort;
+    /**
+     * {@link LRUCache.OptionsBase.allowStaleOnFetchRejection}
+     */
+    allowStaleOnFetchRejection;
+    /**
+     * {@link LRUCache.OptionsBase.ignoreFetchAbort}
+     */
+    ignoreFetchAbort;
+    // computed properties
+    #size;
+    #calculatedSize;
+    #keyMap;
+    #keyList;
+    #valList;
+    #next;
+    #prev;
+    #head;
+    #tail;
+    #free;
+    #disposed;
+    #sizes;
+    #starts;
+    #ttls;
+    #hasDispose;
+    #hasFetchMethod;
+    #hasDisposeAfter;
+    /**
+     * Do not call this method unless you need to inspect the
+     * inner workings of the cache.  If anything returned by this
+     * object is modified in any way, strange breakage may occur.
+     *
+     * These fields are private for a reason!
+     *
+     * @internal
+     */
+    static unsafeExposeInternals(c) {
+        return {
+            // properties
+            starts: c.#starts,
+            ttls: c.#ttls,
+            sizes: c.#sizes,
+            keyMap: c.#keyMap,
+            keyList: c.#keyList,
+            valList: c.#valList,
+            next: c.#next,
+            prev: c.#prev,
+            get head() {
+                return c.#head;
+            },
+            get tail() {
+                return c.#tail;
+            },
+            free: c.#free,
+            // methods
+            isBackgroundFetch: (p) => c.#isBackgroundFetch(p),
+            backgroundFetch: (k, index, options, context) => c.#backgroundFetch(k, index, options, context),
+            moveToTail: (index) => c.#moveToTail(index),
+            indexes: (options) => c.#indexes(options),
+            rindexes: (options) => c.#rindexes(options),
+            isStale: (index) => c.#isStale(index),
+        };
+    }
+    // Protected read-only members
+    /**
+     * {@link LRUCache.OptionsBase.max} (read-only)
+     */
+    get max() {
+        return this.#max;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.maxSize} (read-only)
+     */
+    get maxSize() {
+        return this.#maxSize;
+    }
+    /**
+     * The total computed size of items in the cache (read-only)
+     */
+    get calculatedSize() {
+        return this.#calculatedSize;
+    }
+    /**
+     * The number of items stored in the cache (read-only)
+     */
+    get size() {
+        return this.#size;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.fetchMethod} (read-only)
+     */
+    get fetchMethod() {
+        return this.#fetchMethod;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.dispose} (read-only)
+     */
+    get dispose() {
+        return this.#dispose;
+    }
+    /**
+     * {@link LRUCache.OptionsBase.disposeAfter} (read-only)
+     */
+    get disposeAfter() {
+        return this.#disposeAfter;
+    }
+    constructor(options) {
+        const { max = 0, ttl, ttlResolution = 1, ttlAutopurge, updateAgeOnGet, updateAgeOnHas, allowStale, dispose, disposeAfter, noDisposeOnSet, noUpdateTTL, maxSize = 0, maxEntrySize = 0, sizeCalculation, fetchMethod, noDeleteOnFetchRejection, noDeleteOnStaleGet, allowStaleOnFetchRejection, allowStaleOnFetchAbort, ignoreFetchAbort, } = options;
+        if (max !== 0 && !isPosInt(max)) {
+            throw new TypeError('max option must be a nonnegative integer');
+        }
+        const UintArray = max ? getUintArray(max) : Array;
+        if (!UintArray) {
+            throw new Error('invalid max value: ' + max);
+        }
+        this.#max = max;
+        this.#maxSize = maxSize;
+        this.maxEntrySize = maxEntrySize || this.#maxSize;
+        this.sizeCalculation = sizeCalculation;
+        if (this.sizeCalculation) {
+            if (!this.#maxSize && !this.maxEntrySize) {
+                throw new TypeError('cannot set sizeCalculation without setting maxSize or maxEntrySize');
+            }
+            if (typeof this.sizeCalculation !== 'function') {
+                throw new TypeError('sizeCalculation set to non-function');
+            }
+        }
+        if (fetchMethod !== undefined &&
+            typeof fetchMethod !== 'function') {
+            throw new TypeError('fetchMethod must be a function if specified');
+        }
+        this.#fetchMethod = fetchMethod;
+        this.#hasFetchMethod = !!fetchMethod;
+        this.#keyMap = new Map();
+        this.#keyList = new Array(max).fill(undefined);
+        this.#valList = new Array(max).fill(undefined);
+        this.#next = new UintArray(max);
+        this.#prev = new UintArray(max);
+        this.#head = 0;
+        this.#tail = 0;
+        this.#free = Stack.create(max);
+        this.#size = 0;
+        this.#calculatedSize = 0;
+        if (typeof dispose === 'function') {
+            this.#dispose = dispose;
+        }
+        if (typeof disposeAfter === 'function') {
+            this.#disposeAfter = disposeAfter;
+            this.#disposed = [];
+        }
+        else {
+            this.#disposeAfter = undefined;
+            this.#disposed = undefined;
+        }
+        this.#hasDispose = !!this.#dispose;
+        this.#hasDisposeAfter = !!this.#disposeAfter;
+        this.noDisposeOnSet = !!noDisposeOnSet;
+        this.noUpdateTTL = !!noUpdateTTL;
+        this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
+        this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
+        this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
+        this.ignoreFetchAbort = !!ignoreFetchAbort;
+        // NB: maxEntrySize is set to maxSize if it's set
+        if (this.maxEntrySize !== 0) {
+            if (this.#maxSize !== 0) {
+                if (!isPosInt(this.#maxSize)) {
+                    throw new TypeError('maxSize must be a positive integer if specified');
+                }
+            }
+            if (!isPosInt(this.maxEntrySize)) {
+                throw new TypeError('maxEntrySize must be a positive integer if specified');
+            }
+            this.#initializeSizeTracking();
+        }
+        this.allowStale = !!allowStale;
+        this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
+        this.updateAgeOnGet = !!updateAgeOnGet;
+        this.updateAgeOnHas = !!updateAgeOnHas;
+        this.ttlResolution =
+            isPosInt(ttlResolution) || ttlResolution === 0
+                ? ttlResolution
+                : 1;
+        this.ttlAutopurge = !!ttlAutopurge;
+        this.ttl = ttl || 0;
+        if (this.ttl) {
+            if (!isPosInt(this.ttl)) {
+                throw new TypeError('ttl must be a positive integer if specified');
+            }
+            this.#initializeTTLTracking();
+        }
+        // do not allow completely unbounded caches
+        if (this.#max === 0 && this.ttl === 0 && this.#maxSize === 0) {
+            throw new TypeError('At least one of max, maxSize, or ttl is required');
+        }
+        if (!this.ttlAutopurge && !this.#max && !this.#maxSize) {
+            const code = 'LRU_CACHE_UNBOUNDED';
+            if (shouldWarn(code)) {
+                warned.add(code);
+                const msg = 'TTL caching without ttlAutopurge, max, or maxSize can ' +
+                    'result in unbounded memory consumption.';
+                emitWarning(msg, 'UnboundedCacheWarning', code, LRUCache);
+            }
+        }
+    }
+    /**
+     * Return the remaining TTL time for a given entry key
+     */
+    getRemainingTTL(key) {
+        return this.#keyMap.has(key) ? Infinity : 0;
+    }
+    #initializeTTLTracking() {
+        const ttls = new ZeroArray(this.#max);
+        const starts = new ZeroArray(this.#max);
+        this.#ttls = ttls;
+        this.#starts = starts;
+        this.#setItemTTL = (index, ttl, start = perf.now()) => {
+            starts[index] = ttl !== 0 ? start : 0;
+            ttls[index] = ttl;
+            if (ttl !== 0 && this.ttlAutopurge) {
+                const t = setTimeout(() => {
+                    if (this.#isStale(index)) {
+                        this.delete(this.#keyList[index]);
+                    }
+                }, ttl + 1);
+                // unref() not supported on all platforms
+                /* c8 ignore start */
+                if (t.unref) {
+                    t.unref();
+                }
+                /* c8 ignore stop */
+            }
+        };
+        this.#updateItemAge = index => {
+            starts[index] = ttls[index] !== 0 ? perf.now() : 0;
+        };
+        this.#statusTTL = (status, index) => {
+            if (ttls[index]) {
+                const ttl = ttls[index];
+                const start = starts[index];
+                /* c8 ignore next */
+                if (!ttl || !start)
+                    return;
+                status.ttl = ttl;
+                status.start = start;
+                status.now = cachedNow || getNow();
+                const age = status.now - start;
+                status.remainingTTL = ttl - age;
+            }
+        };
+        // debounce calls to perf.now() to 1s so we're not hitting
+        // that costly call repeatedly.
+        let cachedNow = 0;
+        const getNow = () => {
+            const n = perf.now();
+            if (this.ttlResolution > 0) {
+                cachedNow = n;
+                const t = setTimeout(() => (cachedNow = 0), this.ttlResolution);
+                // not available on all platforms
+                /* c8 ignore start */
+                if (t.unref) {
+                    t.unref();
+                }
+                /* c8 ignore stop */
+            }
+            return n;
+        };
+        this.getRemainingTTL = key => {
+            const index = this.#keyMap.get(key);
+            if (index === undefined) {
+                return 0;
+            }
+            const ttl = ttls[index];
+            const start = starts[index];
+            if (!ttl || !start) {
+                return Infinity;
+            }
+            const age = (cachedNow || getNow()) - start;
+            return ttl - age;
+        };
+        this.#isStale = index => {
+            const s = starts[index];
+            const t = ttls[index];
+            return !!t && !!s && (cachedNow || getNow()) - s > t;
+        };
+    }
+    // conditionally set private methods related to TTL
+    #updateItemAge = () => { };
+    #statusTTL = () => { };
+    #setItemTTL = () => { };
+    /* c8 ignore stop */
+    #isStale = () => false;
+    #initializeSizeTracking() {
+        const sizes = new ZeroArray(this.#max);
+        this.#calculatedSize = 0;
+        this.#sizes = sizes;
+        this.#removeItemSize = index => {
+            this.#calculatedSize -= sizes[index];
+            sizes[index] = 0;
+        };
+        this.#requireSize = (k, v, size, sizeCalculation) => {
+            // provisionally accept background fetches.
+            // actual value size will be checked when they return.
+            if (this.#isBackgroundFetch(v)) {
+                return 0;
+            }
+            if (!isPosInt(size)) {
+                if (sizeCalculation) {
+                    if (typeof sizeCalculation !== 'function') {
+                        throw new TypeError('sizeCalculation must be a function');
+                    }
+                    size = sizeCalculation(v, k);
+                    if (!isPosInt(size)) {
+                        throw new TypeError('sizeCalculation return invalid (expect positive integer)');
+                    }
+                }
+                else {
+                    throw new TypeError('invalid size value (must be positive integer). ' +
+                        'When maxSize or maxEntrySize is used, sizeCalculation ' +
+                        'or size must be set.');
+                }
+            }
+            return size;
+        };
+        this.#addItemSize = (index, size, status) => {
+            sizes[index] = size;
+            if (this.#maxSize) {
+                const maxSize = this.#maxSize - sizes[index];
+                while (this.#calculatedSize > maxSize) {
+                    this.#evict(true);
+                }
+            }
+            this.#calculatedSize += sizes[index];
+            if (status) {
+                status.entrySize = size;
+                status.totalCalculatedSize = this.#calculatedSize;
+            }
+        };
+    }
+    #removeItemSize = _i => { };
+    #addItemSize = (_i, _s, _st) => { };
+    #requireSize = (_k, _v, size, sizeCalculation) => {
+        if (size || sizeCalculation) {
+            throw new TypeError('cannot set size without setting maxSize or maxEntrySize on cache');
+        }
+        return 0;
+    };
+    *#indexes({ allowStale = this.allowStale } = {}) {
+        if (this.#size) {
+            for (let i = this.#tail; true;) {
+                if (!this.#isValidIndex(i)) {
+                    break;
+                }
+                if (allowStale || !this.#isStale(i)) {
+                    yield i;
+                }
+                if (i === this.#head) {
+                    break;
+                }
+                else {
+                    i = this.#prev[i];
+                }
+            }
+        }
+    }
+    *#rindexes({ allowStale = this.allowStale } = {}) {
+        if (this.#size) {
+            for (let i = this.#head; true;) {
+                if (!this.#isValidIndex(i)) {
+                    break;
+                }
+                if (allowStale || !this.#isStale(i)) {
+                    yield i;
+                }
+                if (i === this.#tail) {
+                    break;
+                }
+                else {
+                    i = this.#next[i];
+                }
+            }
+        }
+    }
+    #isValidIndex(index) {
+        return (index !== undefined &&
+            this.#keyMap.get(this.#keyList[index]) === index);
+    }
+    /**
+     * Return a generator yielding `[key, value]` pairs,
+     * in order from most recently used to least recently used.
+     */
+    *entries() {
+        for (const i of this.#indexes()) {
+            if (this.#valList[i] !== undefined &&
+                this.#keyList[i] !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield [this.#keyList[i], this.#valList[i]];
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.entries}
+     *
+     * Return a generator yielding `[key, value]` pairs,
+     * in order from least recently used to most recently used.
+     */
+    *rentries() {
+        for (const i of this.#rindexes()) {
+            if (this.#valList[i] !== undefined &&
+                this.#keyList[i] !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield [this.#keyList[i], this.#valList[i]];
+            }
+        }
+    }
+    /**
+     * Return a generator yielding the keys in the cache,
+     * in order from most recently used to least recently used.
+     */
+    *keys() {
+        for (const i of this.#indexes()) {
+            const k = this.#keyList[i];
+            if (k !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield k;
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.keys}
+     *
+     * Return a generator yielding the keys in the cache,
+     * in order from least recently used to most recently used.
+     */
+    *rkeys() {
+        for (const i of this.#rindexes()) {
+            const k = this.#keyList[i];
+            if (k !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield k;
+            }
+        }
+    }
+    /**
+     * Return a generator yielding the values in the cache,
+     * in order from most recently used to least recently used.
+     */
+    *values() {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            if (v !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield this.#valList[i];
+            }
+        }
+    }
+    /**
+     * Inverse order version of {@link LRUCache.values}
+     *
+     * Return a generator yielding the values in the cache,
+     * in order from least recently used to most recently used.
+     */
+    *rvalues() {
+        for (const i of this.#rindexes()) {
+            const v = this.#valList[i];
+            if (v !== undefined &&
+                !this.#isBackgroundFetch(this.#valList[i])) {
+                yield this.#valList[i];
+            }
+        }
+    }
+    /**
+     * Iterating over the cache itself yields the same results as
+     * {@link LRUCache.entries}
+     */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    /**
+     * A String value that is used in the creation of the default string description of an object.
+     * Called by the built-in method Object.prototype.toString.
+     */
+    [Symbol.toStringTag] = 'LRUCache';
+    /**
+     * Find a value for which the supplied fn method returns a truthy value,
+     * similar to Array.find().  fn is called as fn(value, key, cache).
+     */
+    find(fn, getOptions = {}) {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v)
+                ? v.__staleWhileFetching
+                : v;
+            if (value === undefined)
+                continue;
+            if (fn(value, this.#keyList[i], this)) {
+                return this.get(this.#keyList[i], getOptions);
+            }
+        }
+    }
+    /**
+     * Call the supplied function on each item in the cache, in order from
+     * most recently used to least recently used.  fn is called as
+     * fn(value, key, cache).  Does not update age or recenty of use.
+     * Does not iterate over stale values.
+     */
+    forEach(fn, thisp = this) {
+        for (const i of this.#indexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v)
+                ? v.__staleWhileFetching
+                : v;
+            if (value === undefined)
+                continue;
+            fn.call(thisp, value, this.#keyList[i], this);
+        }
+    }
+    /**
+     * The same as {@link LRUCache.forEach} but items are iterated over in
+     * reverse order.  (ie, less recently used items are iterated over first.)
+     */
+    rforEach(fn, thisp = this) {
+        for (const i of this.#rindexes()) {
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v)
+                ? v.__staleWhileFetching
+                : v;
+            if (value === undefined)
+                continue;
+            fn.call(thisp, value, this.#keyList[i], this);
+        }
+    }
+    /**
+     * Delete any stale entries. Returns true if anything was removed,
+     * false otherwise.
+     */
+    purgeStale() {
+        let deleted = false;
+        for (const i of this.#rindexes({ allowStale: true })) {
+            if (this.#isStale(i)) {
+                this.delete(this.#keyList[i]);
+                deleted = true;
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Get the extended info about a given entry, to get its value, size, and
+     * TTL info simultaneously. Like {@link LRUCache#dump}, but just for a
+     * single key. Always returns stale values, if their info is found in the
+     * cache, so be sure to check for expired TTLs if relevant.
+     */
+    info(key) {
+        const i = this.#keyMap.get(key);
+        if (i === undefined)
+            return undefined;
+        const v = this.#valList[i];
+        const value = this.#isBackgroundFetch(v)
+            ? v.__staleWhileFetching
+            : v;
+        if (value === undefined)
+            return undefined;
+        const entry = { value };
+        if (this.#ttls && this.#starts) {
+            const ttl = this.#ttls[i];
+            const start = this.#starts[i];
+            if (ttl && start) {
+                const remain = ttl - (perf.now() - start);
+                entry.ttl = remain;
+                entry.start = Date.now();
+            }
+        }
+        if (this.#sizes) {
+            entry.size = this.#sizes[i];
+        }
+        return entry;
+    }
+    /**
+     * Return an array of [key, {@link LRUCache.Entry}] tuples which can be
+     * passed to cache.load()
+     */
+    dump() {
+        const arr = [];
+        for (const i of this.#indexes({ allowStale: true })) {
+            const key = this.#keyList[i];
+            const v = this.#valList[i];
+            const value = this.#isBackgroundFetch(v)
+                ? v.__staleWhileFetching
+                : v;
+            if (value === undefined || key === undefined)
+                continue;
+            const entry = { value };
+            if (this.#ttls && this.#starts) {
+                entry.ttl = this.#ttls[i];
+                // always dump the start relative to a portable timestamp
+                // it's ok for this to be a bit slow, it's a rare operation.
+                const age = perf.now() - this.#starts[i];
+                entry.start = Math.floor(Date.now() - age);
+            }
+            if (this.#sizes) {
+                entry.size = this.#sizes[i];
+            }
+            arr.unshift([key, entry]);
+        }
+        return arr;
+    }
+    /**
+     * Reset the cache and load in the items in entries in the order listed.
+     * Note that the shape of the resulting cache may be different if the
+     * same options are not used in both caches.
+     */
+    load(arr) {
+        this.clear();
+        for (const [key, entry] of arr) {
+            if (entry.start) {
+                // entry.start is a portable timestamp, but we may be using
+                // node's performance.now(), so calculate the offset, so that
+                // we get the intended remaining TTL, no matter how long it's
+                // been on ice.
+                //
+                // it's ok for this to be a bit slow, it's a rare operation.
+                const age = Date.now() - entry.start;
+                entry.start = perf.now() - age;
+            }
+            this.set(key, entry.value, entry);
+        }
+    }
+    /**
+     * Add a value to the cache.
+     *
+     * Note: if `undefined` is specified as a value, this is an alias for
+     * {@link LRUCache#delete}
+     */
+    set(k, v, setOptions = {}) {
+        if (v === undefined) {
+            this.delete(k);
+            return this;
+        }
+        const { ttl = this.ttl, start, noDisposeOnSet = this.noDisposeOnSet, sizeCalculation = this.sizeCalculation, status, } = setOptions;
+        let { noUpdateTTL = this.noUpdateTTL } = setOptions;
+        const size = this.#requireSize(k, v, setOptions.size || 0, sizeCalculation);
+        // if the item doesn't fit, don't do anything
+        // NB: maxEntrySize set to maxSize by default
+        if (this.maxEntrySize && size > this.maxEntrySize) {
+            if (status) {
+                status.set = 'miss';
+                status.maxEntrySizeExceeded = true;
+            }
+            // have to delete, in case something is there already.
+            this.delete(k);
+            return this;
+        }
+        let index = this.#size === 0 ? undefined : this.#keyMap.get(k);
+        if (index === undefined) {
+            // addition
+            index = (this.#size === 0
+                ? this.#tail
+                : this.#free.length !== 0
+                    ? this.#free.pop()
+                    : this.#size === this.#max
+                        ? this.#evict(false)
+                        : this.#size);
+            this.#keyList[index] = k;
+            this.#valList[index] = v;
+            this.#keyMap.set(k, index);
+            this.#next[this.#tail] = index;
+            this.#prev[index] = this.#tail;
+            this.#tail = index;
+            this.#size++;
+            this.#addItemSize(index, size, status);
+            if (status)
+                status.set = 'add';
+            noUpdateTTL = false;
+        }
+        else {
+            // update
+            this.#moveToTail(index);
+            const oldVal = this.#valList[index];
+            if (v !== oldVal) {
+                if (this.#hasFetchMethod && this.#isBackgroundFetch(oldVal)) {
+                    oldVal.__abortController.abort(new Error('replaced'));
+                    const { __staleWhileFetching: s } = oldVal;
+                    if (s !== undefined && !noDisposeOnSet) {
+                        if (this.#hasDispose) {
+                            this.#dispose?.(s, k, 'set');
+                        }
+                        if (this.#hasDisposeAfter) {
+                            this.#disposed?.push([s, k, 'set']);
+                        }
+                    }
+                }
+                else if (!noDisposeOnSet) {
+                    if (this.#hasDispose) {
+                        this.#dispose?.(oldVal, k, 'set');
+                    }
+                    if (this.#hasDisposeAfter) {
+                        this.#disposed?.push([oldVal, k, 'set']);
+                    }
+                }
+                this.#removeItemSize(index);
+                this.#addItemSize(index, size, status);
+                this.#valList[index] = v;
+                if (status) {
+                    status.set = 'replace';
+                    const oldValue = oldVal && this.#isBackgroundFetch(oldVal)
+                        ? oldVal.__staleWhileFetching
+                        : oldVal;
+                    if (oldValue !== undefined)
+                        status.oldValue = oldValue;
+                }
+            }
+            else if (status) {
+                status.set = 'update';
+            }
+        }
+        if (ttl !== 0 && !this.#ttls) {
+            this.#initializeTTLTracking();
+        }
+        if (this.#ttls) {
+            if (!noUpdateTTL) {
+                this.#setItemTTL(index, ttl, start);
+            }
+            if (status)
+                this.#statusTTL(status, index);
+        }
+        if (!noDisposeOnSet && this.#hasDisposeAfter && this.#disposed) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+        return this;
+    }
+    /**
+     * Evict the least recently used item, returning its value or
+     * `undefined` if cache is empty.
+     */
+    pop() {
+        try {
+            while (this.#size) {
+                const val = this.#valList[this.#head];
+                this.#evict(true);
+                if (this.#isBackgroundFetch(val)) {
+                    if (val.__staleWhileFetching) {
+                        return val.__staleWhileFetching;
+                    }
+                }
+                else if (val !== undefined) {
+                    return val;
+                }
+            }
+        }
+        finally {
+            if (this.#hasDisposeAfter && this.#disposed) {
+                const dt = this.#disposed;
+                let task;
+                while ((task = dt?.shift())) {
+                    this.#disposeAfter?.(...task);
+                }
+            }
+        }
+    }
+    #evict(free) {
+        const head = this.#head;
+        const k = this.#keyList[head];
+        const v = this.#valList[head];
+        if (this.#hasFetchMethod && this.#isBackgroundFetch(v)) {
+            v.__abortController.abort(new Error('evicted'));
+        }
+        else if (this.#hasDispose || this.#hasDisposeAfter) {
+            if (this.#hasDispose) {
+                this.#dispose?.(v, k, 'evict');
+            }
+            if (this.#hasDisposeAfter) {
+                this.#disposed?.push([v, k, 'evict']);
+            }
+        }
+        this.#removeItemSize(head);
+        // if we aren't about to use the index, then null these out
+        if (free) {
+            this.#keyList[head] = undefined;
+            this.#valList[head] = undefined;
+            this.#free.push(head);
+        }
+        if (this.#size === 1) {
+            this.#head = this.#tail = 0;
+            this.#free.length = 0;
+        }
+        else {
+            this.#head = this.#next[head];
+        }
+        this.#keyMap.delete(k);
+        this.#size--;
+        return head;
+    }
+    /**
+     * Check if a key is in the cache, without updating the recency of use.
+     * Will return false if the item is stale, even though it is technically
+     * in the cache.
+     *
+     * Will not update item age unless
+     * {@link LRUCache.OptionsBase.updateAgeOnHas} is set.
+     */
+    has(k, hasOptions = {}) {
+        const { updateAgeOnHas = this.updateAgeOnHas, status } = hasOptions;
+        const index = this.#keyMap.get(k);
+        if (index !== undefined) {
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v) &&
+                v.__staleWhileFetching === undefined) {
+                return false;
+            }
+            if (!this.#isStale(index)) {
+                if (updateAgeOnHas) {
+                    this.#updateItemAge(index);
+                }
+                if (status) {
+                    status.has = 'hit';
+                    this.#statusTTL(status, index);
+                }
+                return true;
+            }
+            else if (status) {
+                status.has = 'stale';
+                this.#statusTTL(status, index);
+            }
+        }
+        else if (status) {
+            status.has = 'miss';
+        }
+        return false;
+    }
+    /**
+     * Like {@link LRUCache#get} but doesn't update recency or delete stale
+     * items.
+     *
+     * Returns `undefined` if the item is stale, unless
+     * {@link LRUCache.OptionsBase.allowStale} is set.
+     */
+    peek(k, peekOptions = {}) {
+        const { allowStale = this.allowStale } = peekOptions;
+        const index = this.#keyMap.get(k);
+        if (index === undefined ||
+            (!allowStale && this.#isStale(index))) {
+            return;
+        }
+        const v = this.#valList[index];
+        // either stale and allowed, or forcing a refresh of non-stale value
+        return this.#isBackgroundFetch(v) ? v.__staleWhileFetching : v;
+    }
+    #backgroundFetch(k, index, options, context) {
+        const v = index === undefined ? undefined : this.#valList[index];
+        if (this.#isBackgroundFetch(v)) {
+            return v;
+        }
+        const ac = new AC();
+        const { signal } = options;
+        // when/if our AC signals, then stop listening to theirs.
+        signal?.addEventListener('abort', () => ac.abort(signal.reason), {
+            signal: ac.signal,
+        });
+        const fetchOpts = {
+            signal: ac.signal,
+            options,
+            context,
+        };
+        const cb = (v, updateCache = false) => {
+            const { aborted } = ac.signal;
+            const ignoreAbort = options.ignoreFetchAbort && v !== undefined;
+            if (options.status) {
+                if (aborted && !updateCache) {
+                    options.status.fetchAborted = true;
+                    options.status.fetchError = ac.signal.reason;
+                    if (ignoreAbort)
+                        options.status.fetchAbortIgnored = true;
+                }
+                else {
+                    options.status.fetchResolved = true;
+                }
+            }
+            if (aborted && !ignoreAbort && !updateCache) {
+                return fetchFail(ac.signal.reason);
+            }
+            // either we didn't abort, and are still here, or we did, and ignored
+            const bf = p;
+            if (this.#valList[index] === p) {
+                if (v === undefined) {
+                    if (bf.__staleWhileFetching) {
+                        this.#valList[index] = bf.__staleWhileFetching;
+                    }
+                    else {
+                        this.delete(k);
+                    }
+                }
+                else {
+                    if (options.status)
+                        options.status.fetchUpdated = true;
+                    this.set(k, v, fetchOpts.options);
+                }
+            }
+            return v;
+        };
+        const eb = (er) => {
+            if (options.status) {
+                options.status.fetchRejected = true;
+                options.status.fetchError = er;
+            }
+            return fetchFail(er);
+        };
+        const fetchFail = (er) => {
+            const { aborted } = ac.signal;
+            const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
+            const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
+            const noDelete = allowStale || options.noDeleteOnFetchRejection;
+            const bf = p;
+            if (this.#valList[index] === p) {
+                // if we allow stale on fetch rejections, then we need to ensure that
+                // the stale value is not removed from the cache when the fetch fails.
+                const del = !noDelete || bf.__staleWhileFetching === undefined;
+                if (del) {
+                    this.delete(k);
+                }
+                else if (!allowStaleAborted) {
+                    // still replace the *promise* with the stale value,
+                    // since we are done with the promise at this point.
+                    // leave it untouched if we're still waiting for an
+                    // aborted background fetch that hasn't yet returned.
+                    this.#valList[index] = bf.__staleWhileFetching;
+                }
+            }
+            if (allowStale) {
+                if (options.status && bf.__staleWhileFetching !== undefined) {
+                    options.status.returnedStale = true;
+                }
+                return bf.__staleWhileFetching;
+            }
+            else if (bf.__returned === bf) {
+                throw er;
+            }
+        };
+        const pcall = (res, rej) => {
+            const fmp = this.#fetchMethod?.(k, v, fetchOpts);
+            if (fmp && fmp instanceof Promise) {
+                fmp.then(v => res(v === undefined ? undefined : v), rej);
+            }
+            // ignored, we go until we finish, regardless.
+            // defer check until we are actually aborting,
+            // so fetchMethod can override.
+            ac.signal.addEventListener('abort', () => {
+                if (!options.ignoreFetchAbort ||
+                    options.allowStaleOnFetchAbort) {
+                    res(undefined);
+                    // when it eventually resolves, update the cache.
+                    if (options.allowStaleOnFetchAbort) {
+                        res = v => cb(v, true);
+                    }
+                }
+            });
+        };
+        if (options.status)
+            options.status.fetchDispatched = true;
+        const p = new Promise(pcall).then(cb, eb);
+        const bf = Object.assign(p, {
+            __abortController: ac,
+            __staleWhileFetching: v,
+            __returned: undefined,
+        });
+        if (index === undefined) {
+            // internal, don't expose status.
+            this.set(k, bf, { ...fetchOpts.options, status: undefined });
+            index = this.#keyMap.get(k);
+        }
+        else {
+            this.#valList[index] = bf;
+        }
+        return bf;
+    }
+    #isBackgroundFetch(p) {
+        if (!this.#hasFetchMethod)
+            return false;
+        const b = p;
+        return (!!b &&
+            b instanceof Promise &&
+            b.hasOwnProperty('__staleWhileFetching') &&
+            b.__abortController instanceof AC);
+    }
+    async fetch(k, fetchOptions = {}) {
+        const { 
+        // get options
+        allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, 
+        // set options
+        ttl = this.ttl, noDisposeOnSet = this.noDisposeOnSet, size = 0, sizeCalculation = this.sizeCalculation, noUpdateTTL = this.noUpdateTTL, 
+        // fetch exclusive options
+        noDeleteOnFetchRejection = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection = this.allowStaleOnFetchRejection, ignoreFetchAbort = this.ignoreFetchAbort, allowStaleOnFetchAbort = this.allowStaleOnFetchAbort, context, forceRefresh = false, status, signal, } = fetchOptions;
+        if (!this.#hasFetchMethod) {
+            if (status)
+                status.fetch = 'get';
+            return this.get(k, {
+                allowStale,
+                updateAgeOnGet,
+                noDeleteOnStaleGet,
+                status,
+            });
+        }
+        const options = {
+            allowStale,
+            updateAgeOnGet,
+            noDeleteOnStaleGet,
+            ttl,
+            noDisposeOnSet,
+            size,
+            sizeCalculation,
+            noUpdateTTL,
+            noDeleteOnFetchRejection,
+            allowStaleOnFetchRejection,
+            allowStaleOnFetchAbort,
+            ignoreFetchAbort,
+            status,
+            signal,
+        };
+        let index = this.#keyMap.get(k);
+        if (index === undefined) {
+            if (status)
+                status.fetch = 'miss';
+            const p = this.#backgroundFetch(k, index, options, context);
+            return (p.__returned = p);
+        }
+        else {
+            // in cache, maybe already fetching
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+                const stale = allowStale && v.__staleWhileFetching !== undefined;
+                if (status) {
+                    status.fetch = 'inflight';
+                    if (stale)
+                        status.returnedStale = true;
+                }
+                return stale ? v.__staleWhileFetching : (v.__returned = v);
+            }
+            // if we force a refresh, that means do NOT serve the cached value,
+            // unless we are already in the process of refreshing the cache.
+            const isStale = this.#isStale(index);
+            if (!forceRefresh && !isStale) {
+                if (status)
+                    status.fetch = 'hit';
+                this.#moveToTail(index);
+                if (updateAgeOnGet) {
+                    this.#updateItemAge(index);
+                }
+                if (status)
+                    this.#statusTTL(status, index);
+                return v;
+            }
+            // ok, it is stale or a forced refresh, and not already fetching.
+            // refresh the cache.
+            const p = this.#backgroundFetch(k, index, options, context);
+            const hasStale = p.__staleWhileFetching !== undefined;
+            const staleVal = hasStale && allowStale;
+            if (status) {
+                status.fetch = isStale ? 'stale' : 'refresh';
+                if (staleVal && isStale)
+                    status.returnedStale = true;
+            }
+            return staleVal ? p.__staleWhileFetching : (p.__returned = p);
+        }
+    }
+    /**
+     * Return a value from the cache. Will update the recency of the cache
+     * entry found.
+     *
+     * If the key is not found, get() will return `undefined`.
+     */
+    get(k, getOptions = {}) {
+        const { allowStale = this.allowStale, updateAgeOnGet = this.updateAgeOnGet, noDeleteOnStaleGet = this.noDeleteOnStaleGet, status, } = getOptions;
+        const index = this.#keyMap.get(k);
+        if (index !== undefined) {
+            const value = this.#valList[index];
+            const fetching = this.#isBackgroundFetch(value);
+            if (status)
+                this.#statusTTL(status, index);
+            if (this.#isStale(index)) {
+                if (status)
+                    status.get = 'stale';
+                // delete only if not an in-flight background fetch
+                if (!fetching) {
+                    if (!noDeleteOnStaleGet) {
+                        this.delete(k);
+                    }
+                    if (status && allowStale)
+                        status.returnedStale = true;
+                    return allowStale ? value : undefined;
+                }
+                else {
+                    if (status &&
+                        allowStale &&
+                        value.__staleWhileFetching !== undefined) {
+                        status.returnedStale = true;
+                    }
+                    return allowStale ? value.__staleWhileFetching : undefined;
+                }
+            }
+            else {
+                if (status)
+                    status.get = 'hit';
+                // if we're currently fetching it, we don't actually have it yet
+                // it's not stale, which means this isn't a staleWhileRefetching.
+                // If it's not stale, and fetching, AND has a __staleWhileFetching
+                // value, then that means the user fetched with {forceRefresh:true},
+                // so it's safe to return that value.
+                if (fetching) {
+                    return value.__staleWhileFetching;
+                }
+                this.#moveToTail(index);
+                if (updateAgeOnGet) {
+                    this.#updateItemAge(index);
+                }
+                return value;
+            }
+        }
+        else if (status) {
+            status.get = 'miss';
+        }
+    }
+    #connect(p, n) {
+        this.#prev[n] = p;
+        this.#next[p] = n;
+    }
+    #moveToTail(index) {
+        // if tail already, nothing to do
+        // if head, move head to next[index]
+        // else
+        //   move next[prev[index]] to next[index] (head has no prev)
+        //   move prev[next[index]] to prev[index]
+        // prev[index] = tail
+        // next[tail] = index
+        // tail = index
+        if (index !== this.#tail) {
+            if (index === this.#head) {
+                this.#head = this.#next[index];
+            }
+            else {
+                this.#connect(this.#prev[index], this.#next[index]);
+            }
+            this.#connect(this.#tail, index);
+            this.#tail = index;
+        }
+    }
+    /**
+     * Deletes a key out of the cache.
+     * Returns true if the key was deleted, false otherwise.
+     */
+    delete(k) {
+        let deleted = false;
+        if (this.#size !== 0) {
+            const index = this.#keyMap.get(k);
+            if (index !== undefined) {
+                deleted = true;
+                if (this.#size === 1) {
+                    this.clear();
+                }
+                else {
+                    this.#removeItemSize(index);
+                    const v = this.#valList[index];
+                    if (this.#isBackgroundFetch(v)) {
+                        v.__abortController.abort(new Error('deleted'));
+                    }
+                    else if (this.#hasDispose || this.#hasDisposeAfter) {
+                        if (this.#hasDispose) {
+                            this.#dispose?.(v, k, 'delete');
+                        }
+                        if (this.#hasDisposeAfter) {
+                            this.#disposed?.push([v, k, 'delete']);
+                        }
+                    }
+                    this.#keyMap.delete(k);
+                    this.#keyList[index] = undefined;
+                    this.#valList[index] = undefined;
+                    if (index === this.#tail) {
+                        this.#tail = this.#prev[index];
+                    }
+                    else if (index === this.#head) {
+                        this.#head = this.#next[index];
+                    }
+                    else {
+                        const pi = this.#prev[index];
+                        this.#next[pi] = this.#next[index];
+                        const ni = this.#next[index];
+                        this.#prev[ni] = this.#prev[index];
+                    }
+                    this.#size--;
+                    this.#free.push(index);
+                }
+            }
+        }
+        if (this.#hasDisposeAfter && this.#disposed?.length) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Clear the cache entirely, throwing away all values.
+     */
+    clear() {
+        for (const index of this.#rindexes({ allowStale: true })) {
+            const v = this.#valList[index];
+            if (this.#isBackgroundFetch(v)) {
+                v.__abortController.abort(new Error('deleted'));
+            }
+            else {
+                const k = this.#keyList[index];
+                if (this.#hasDispose) {
+                    this.#dispose?.(v, k, 'delete');
+                }
+                if (this.#hasDisposeAfter) {
+                    this.#disposed?.push([v, k, 'delete']);
+                }
+            }
+        }
+        this.#keyMap.clear();
+        this.#valList.fill(undefined);
+        this.#keyList.fill(undefined);
+        if (this.#ttls && this.#starts) {
+            this.#ttls.fill(0);
+            this.#starts.fill(0);
+        }
+        if (this.#sizes) {
+            this.#sizes.fill(0);
+        }
+        this.#head = 0;
+        this.#tail = 0;
+        this.#free.length = 0;
+        this.#calculatedSize = 0;
+        this.#size = 0;
+        if (this.#hasDisposeAfter && this.#disposed) {
+            const dt = this.#disposed;
+            let task;
+            while ((task = dt?.shift())) {
+                this.#disposeAfter?.(...task);
+            }
+        }
+    }
+}
+
 const lowlight = lowlight$1.createLowlight(lowlight$1.all);
 lowlight.register("vue", function hljsDefineVue(hljs) {
     return {
@@ -74,6 +1515,7 @@ lowlight.register("vue", function hljsDefineVue(hljs) {
 const highlighter = lowlight;
 let _autoDetectLang = true;
 let _maxLineToIgnoreSyntax = 2000;
+const _ignoreSyntaxHighlightList = [];
 Object.defineProperty(highlighter, "maxLineToIgnoreSyntax", {
     get: () => _maxLineToIgnoreSyntax,
 });
@@ -90,12 +1532,21 @@ Object.defineProperty(highlighter, "setAutoDetectLang", {
         _autoDetectLang = v;
     },
 });
+Object.defineProperty(highlighter, "ignoreSyntaxHighlightList", {
+    get: () => _ignoreSyntaxHighlightList,
+});
+Object.defineProperty(highlighter, "setIgnoreSyntaxHighlightList", {
+    value: (v) => {
+        _ignoreSyntaxHighlightList.length = 0;
+        _ignoreSyntaxHighlightList.push(...v);
+    },
+});
 
-// TODO LRU Cache
-const map = {};
+const map = new LRUCache({ max: 30 });
 class File {
     raw;
     lang;
+    fileName;
     ast;
     rawFile = {};
     hasDoRaw = false;
@@ -104,12 +1555,13 @@ class File {
     hasDoSyntax = false;
     syntaxLength;
     maxLineNumber = 0;
-    constructor(raw, lang) {
+    constructor(raw, lang, fileName) {
         this.raw = raw;
         this.lang = lang;
+        this.fileName = fileName;
         Object.defineProperty(this, "__v_skip", { value: true });
     }
-    doSyntax({ autoDetectLang, registerHighlighter }) {
+    doSyntax({ autoDetectLang, registerHighlighter, }) {
         if (!this.raw || this.hasDoSyntax)
             return;
         let hasRegisteredLang = true;
@@ -129,6 +1581,11 @@ class File {
             console.warn(`ignore syntax for current file, because the rawLength is too long: ${this.rawLength}`);
             return;
         }
+        if (this.fileName &&
+            _highlighter.ignoreSyntaxHighlightList.some((item) => item instanceof RegExp ? item.test(this.fileName) : this.fileName === item)) {
+            console.warn(`ignore syntax for current file, because the fileName is in the ignoreSyntaxHighlightList: ${this.fileName}`);
+            return;
+        }
         if (hasRegisteredLang) {
             this.ast = _highlighter.highlight(this.lang, this.raw);
         }
@@ -148,10 +1605,18 @@ class File {
         const rawArray = rawString.split("\n");
         this.rawLength = rawArray.length;
         this.maxLineNumber = rawArray.length;
-        this.rawFile = rawArray.reduce((p, item, index) => ({
-            ...p,
-            [index + 1]: index < rawArray.length - 1 ? item + "\n" : item,
-        }), {});
+        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;
     }
     #doAST() {
@@ -242,15 +1707,90 @@ class File {
         }
     }
 }
-const getFile = (raw, lang) => {
-    const key = raw + "--" + "0.0.3" + "--" + lang;
-    if (map[key])
-        return map[key];
-    const file = new File(raw, lang);
-    map[key] = file;
+const getFile = (raw, lang, fileName) => {
+    const key = raw + "--" + "0.0.6" + "--" + lang;
+    if (map.has(key))
+        return map.get(key);
+    const file = new File(raw, lang, fileName);
+    map.set(key, file);
     return file;
 };
 
+const maxLength = 1000;
+/** Get the maximum position in the range. */
+function rangeMax(range) {
+    return range.location + range.length;
+}
+/** Get the length of the common substring between the two strings. */
+function commonLength(stringA, rangeA, stringB, rangeB, reverse) {
+    const max = Math.min(rangeA.length, rangeB.length);
+    const startA = reverse ? rangeMax(rangeA) - 1 : rangeA.location;
+    const startB = reverse ? rangeMax(rangeB) - 1 : rangeB.location;
+    const stride = reverse ? -1 : 1;
+    let length = 0;
+    while (Math.abs(length) < max) {
+        if (stringA[startA + length] !== stringB[startB + length]) {
+            break;
+        }
+        length += stride;
+    }
+    return Math.abs(length);
+}
+function isInValidString(s) {
+    return s.trim().length === 0 || s.length >= maxLength;
+}
+/** Get the changed ranges in the strings, relative to each other. */
+function relativeChanges(stringA, stringB) {
+    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")) {
+        return {
+            stringARange: {
+                location: _stringA.length,
+                length: stringA.length - _stringA.length,
+                isNewLineSymbolChanged: true,
+            },
+            stringBRange: {
+                location: _stringB.length,
+                length: stringB.length - _stringB.length,
+                isNewLineSymbolChanged: true,
+            },
+        };
+    }
+    if (isInValidString(stringA) || isInValidString(stringB)) {
+        aRange.length = 0;
+        bRange.length = 0;
+        return { stringARange: aRange, stringBRange: bRange };
+    }
+    const prefixLength = commonLength(stringB, bRange, stringA, aRange, false);
+    bRange = {
+        location: bRange.location + prefixLength,
+        length: bRange.length - prefixLength,
+    };
+    aRange = {
+        location: aRange.location + prefixLength,
+        length: aRange.length - prefixLength,
+    };
+    const suffixLength = commonLength(stringB, bRange, stringA, aRange, true);
+    bRange.length -= suffixLength;
+    aRange.length -= suffixLength;
+    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);
+    return (stringARange.location > 0 ||
+        stringBRange.location > 0 ||
+        stringARange.length < _stringA.length ||
+        stringBRange.length < _stringB.length);
+}
+
 /** indicate what a line in the diff represents */
 var DiffLineType;
 (function (DiffLineType) {
@@ -446,72 +1986,39 @@ function getHunkHeaderExpansionType(hunkIndex, hunkHeader, previousHunk) {
     else if (distanceToPrevious <= DefaultDiffExpansionStep) {
         return DiffHunkExpansionType.Short;
     }
-    else {
-        return DiffHunkExpansionType.Both;
-    }
-}
-const numIterator = (num, cb) => {
-    const re = [];
-    for (let i = 0; i < num; i++) {
-        re.push(cb(i));
-    }
-    return re;
-};
-
-const maxLength = 1000;
-/** Get the maximum position in the range. */
-function rangeMax(range) {
-    return range.location + range.length;
-}
-/** Get the length of the common substring between the two strings. */
-function commonLength(stringA, rangeA, stringB, rangeB, reverse) {
-    const max = Math.min(rangeA.length, rangeB.length);
-    const startA = reverse ? rangeMax(rangeA) - 1 : rangeA.location;
-    const startB = reverse ? rangeMax(rangeB) - 1 : rangeB.location;
-    const stride = reverse ? -1 : 1;
-    let length = 0;
-    while (Math.abs(length) < max) {
-        if (stringA[startA + length] !== stringB[startB + length]) {
-            break;
-        }
-        length += stride;
-    }
-    return Math.abs(length);
-}
-function isInValidString(s) {
-    return s.trim().length === 0 || s.length >= maxLength;
-}
-/** Get the changed ranges in the strings, relative to each other. */
-function relativeChanges(stringA, stringB) {
-    let bRange = { location: 0, length: stringB.length };
-    let aRange = { location: 0, length: stringA.length };
-    const _stringA = stringA.trimEnd();
-    const _stringB = stringB.trimEnd();
-    if (_stringA === _stringB) {
-        return {
-            stringARange: { location: _stringA.length, length: stringA.length - _stringA.length },
-            stringBRange: { location: _stringB.length, length: stringB.length - _stringB.length },
-        };
-    }
-    if (isInValidString(stringA) || isInValidString(stringB)) {
-        aRange.length = 0;
-        bRange.length = 0;
-        return { stringARange: aRange, stringBRange: bRange };
-    }
-    const prefixLength = commonLength(stringB, bRange, stringA, aRange, false);
-    bRange = {
-        location: bRange.location + prefixLength,
-        length: bRange.length - prefixLength,
-    };
-    aRange = {
-        location: aRange.location + prefixLength,
-        length: aRange.length - prefixLength,
-    };
-    const suffixLength = commonLength(stringB, bRange, stringA, aRange, true);
-    bRange.length -= suffixLength;
-    aRange.length -= suffixLength;
-    return { stringARange: aRange, stringBRange: bRange };
+    else {
+        return DiffHunkExpansionType.Both;
+    }
 }
+const numIterator = (num, cb) => {
+    const re = [];
+    for (let i = 0; i < num; i++) {
+        re.push(cb(i));
+    }
+    return re;
+};
+const getLang = (fileName) => {
+    const dotIndex = fileName.lastIndexOf(".");
+    const extension = fileName.slice(dotIndex + 1);
+    return extension;
+};
+const getDiffRange = (additions, deletions) => {
+    if (additions.length === deletions.length) {
+        const len = additions.length;
+        for (let i = 0; i < len; i++) {
+            const addition = additions[i];
+            const deletion = deletions[i];
+            const hasDiffRange = hasRelativeChange(addition.text, deletion.text);
+            if (hasDiffRange) {
+                const { stringARange, stringBRange } = relativeChanges(addition.text, deletion.text);
+                addition.needRematch = true;
+                addition.range = stringARange;
+                deletion.needRematch = true;
+                deletion.range = stringBRange;
+            }
+        }
+    }
+};
 
 /* eslint-disable max-lines */
 // NODE: ALL of the Diff parse logic from desktop, SEE https://github.com/desktop/desktop
@@ -866,11 +2373,6 @@ const parseInstance = new DiffParser();
 /* eslint-disable max-lines */
 const composeLen = 40;
 const idSet = new Set();
-const getLang = (fileName) => {
-    const dotIndex = fileName.lastIndexOf(".");
-    const extension = fileName.slice(dotIndex + 1);
-    return extension;
-};
 class DiffFile {
     _oldFileName;
     _newFileName;
@@ -888,10 +2390,8 @@ class DiffFile {
     #splitLeftLines = [];
     #splitRightLines = [];
     #splitHunksLines;
-    #splitLastStartIndex;
     #unifiedLines = [];
     #unifiedHunksLines;
-    #unifiedLastStartIndex;
     #listeners = [];
     #hasInitRaw = false;
     #hasInitSyntax = false;
@@ -899,6 +2399,7 @@ class DiffFile {
     #hasBuildUnified = false;
     #updateCount = 0;
     #composeByDiff = false;
+    _version_ = "0.0.6";
     _oldFileContent = "";
     _oldFileLang = "";
     _newFileContent = "";
@@ -949,10 +2450,10 @@ class DiffFile {
         if (!this._oldFileContent && !this._newFileContent)
             return;
         if (this._oldFileContent) {
-            this.#oldFileResult = getFile(this._oldFileContent, this._oldFileLang);
+            this.#oldFileResult = getFile(this._oldFileContent, this._oldFileLang, this._oldFileName);
         }
         if (this._newFileContent) {
-            this.#newFileResult = getFile(this._newFileContent, this._newFileLang);
+            this.#newFileResult = getFile(this._newFileContent, this._newFileLang, this._newFileName);
         }
     }
     #composeRaw() {
@@ -994,8 +2495,8 @@ class DiffFile {
                 return;
             this._oldFileContent = oldFileContent;
             this._newFileContent = newFileContent;
-            this.#oldFileResult = getFile(this._oldFileContent, this._oldFileLang);
-            this.#newFileResult = getFile(this._newFileContent, this._newFileLang);
+            this.#oldFileResult = getFile(this._oldFileContent, this._oldFileLang, this._oldFileName);
+            this.#newFileResult = getFile(this._newFileContent, this._newFileLang, this._newFileName);
             // all of the file just compose by diff, so we can not do the expand action
             this.#composeByDiff = true;
         }
@@ -1016,7 +2517,7 @@ class DiffFile {
             if (newFileContent === this._oldFileContent)
                 return;
             this._newFileContent = newFileContent;
-            this.#newFileResult = getFile(this._newFileContent, this._newFileLang);
+            this.#newFileResult = getFile(this._newFileContent, this._newFileLang, this._newFileName);
         }
         else if (this.#newFileResult) {
             let oldLineNumber = 1;
@@ -1035,7 +2536,7 @@ class DiffFile {
             if (oldFileContent === this._newFileContent)
                 return;
             this._oldFileContent = oldFileContent;
-            this.#oldFileResult = getFile(this._oldFileContent, this._oldFileLang);
+            this.#oldFileResult = getFile(this._oldFileContent, this._oldFileLang, this._oldFileName);
         }
         this.#composeRaw();
     }
@@ -1055,27 +2556,22 @@ class DiffFile {
                         deletions.push(line);
                     }
                     else {
-                        if (additions.length === deletions.length) {
-                            const len = additions.length;
-                            for (let i = 0; i < len; i++) {
-                                const addition = additions[i];
-                                const deletion = deletions[i];
-                                const { stringARange, stringBRange } = relativeChanges(addition.text, deletion.text);
-                                addition.needRematch = true;
-                                addition.range = stringARange;
-                                deletion.needRematch = true;
-                                deletion.range = stringBRange;
-                            }
-                        }
+                        getDiffRange(additions, deletions);
                         additions = [];
                         deletions = [];
                     }
                 });
+                getDiffRange(additions, deletions);
+            });
+        });
+        this.#diffLines = [];
+        const tmp = [];
+        this.#diffListResults.forEach((item) => {
+            item.hunks.forEach((_item) => {
+                tmp.push(..._item.lines);
             });
         });
-        this.#diffLines = this.#diffListResults
-            .reduce((p, c) => p.concat(...c.hunks.reduce((_p, _c) => _p.concat(..._c.lines), [])), [])
-            .map((i, index) => {
+        this.#diffLines = tmp.map((i, index) => {
             const typedI = i;
             typedI.index = index;
             if (typedI.type === DiffLineType.Hunk) {
@@ -1090,28 +2586,49 @@ class DiffFile {
                     oldLength: Number(oldNumLength),
                     newStartIndex: +Number(newNumStartIndex),
                     newLength: Number(newNumLength),
+                    _oldStartIndex: -Number(oldNumStartIndex),
+                    _oldLength: Number(oldNumLength),
+                    _newStartIndex: +Number(newNumStartIndex),
+                    _newLength: Number(newNumLength),
                 };
             }
             return typedI;
         });
-        this.#oldFileDiffLines = this.#diffLines.reduce((p, c) => {
-            if (c.oldLineNumber) {
-                this.diffLineLength = Math.max(this.diffLineLength, c.oldLineNumber);
-                return { ...p, [c.oldLineNumber]: c };
+        // this.#diffLines = this.#diffListResults
+        //   .reduce<DiffLine[]>((p, c) => p.concat(...c.hunks.reduce<DiffLine[]>((_p, _c) => _p.concat(..._c.lines), [])), [])
+        //   .map<DiffLineItem>((i, index) => {
+        //     const typedI = i as DiffLineItem;
+        //     typedI.index = index;
+        //     if (typedI.type === DiffLineType.Hunk) {
+        //       const numInfo = typedI.text.split("@@")?.[1].split(" ").filter(Boolean);
+        //       const oldNumInfo = numInfo?.[0] || "";
+        //       const newNumInfo = numInfo?.[1] || "";
+        //       const [oldNumStartIndex, oldNumLength] = oldNumInfo.split(",");
+        //       const [newNumStartIndex, newNumLength] = newNumInfo.split(",");
+        //       const typedTypeI = typedI as DiffHunkItem;
+        //       typedTypeI.hunkInfo = {
+        //         oldStartIndex: -Number(oldNumStartIndex),
+        //         oldLength: Number(oldNumLength),
+        //         newStartIndex: +Number(newNumStartIndex),
+        //         newLength: Number(newNumLength),
+        //       };
+        //     }
+        //     return typedI;
+        //   });
+        this.#oldFileDiffLines = {};
+        this.#diffLines.forEach((item) => {
+            if (item.oldLineNumber) {
+                this.diffLineLength = Math.max(this.diffLineLength, item.oldLineNumber);
+                this.#oldFileDiffLines[item.oldLineNumber] = item;
             }
-            else {
-                return p;
-            }
-        }, {});
-        this.#newFileDiffLines = this.#diffLines.reduce((p, c) => {
-            if (c.newLineNumber) {
-                this.diffLineLength = Math.max(this.diffLineLength, c.newLineNumber);
-                return { ...p, [c.newLineNumber]: c };
-            }
-            else {
-                return p;
+        });
+        this.#newFileDiffLines = {};
+        this.#diffLines.forEach((item) => {
+            if (item.newLineNumber) {
+                this.diffLineLength = Math.max(this.diffLineLength, item.newLineNumber);
+                this.#newFileDiffLines[item.newLineNumber] = item;
             }
-        }, {});
+        });
     }
     #composeSyntax({ autoDetectLang, registerHighlighter, }) {
         this.#oldFileResult?.doSyntax({ autoDetectLang, registerHighlighter });
@@ -1179,14 +2696,27 @@ class DiffFile {
         const maxOldFileLineNumber = this.#oldFileResult?.maxLineNumber || 0;
         const maxNewFileLineNumber = this.#newFileResult?.maxLineNumber || 0;
         while (oldFileLineNumber <= maxOldFileLineNumber || newFileLineNumber <= maxNewFileLineNumber) {
-            const oldRawLine = this.#getOldRawLine(oldFileLineNumber);
             const oldDiffLine = this.#getOldDiffLine(oldFileLineNumber);
-            const newRawLine = this.#getNewRawLine(newFileLineNumber);
             const newDiffLine = this.#getNewDiffLine(newFileLineNumber);
+            const oldRawLine = this.#getOldRawLine(oldFileLineNumber);
+            const newRawLine = this.#getNewRawLine(newFileLineNumber);
             const oldLineHasChange = oldDiffLine?.isIncludeableLine();
             const newLineHasChange = newDiffLine?.isIncludeableLine();
             const len = this.#splitRightLines.length;
             const isHidden = !oldDiffLine && !newDiffLine;
+            if ((oldDiffLine && !newDiffLine && oldDiffLine.newLineNumber && oldDiffLine.newLineNumber > newFileLineNumber) ||
+                (!oldDiffLine && newDiffLine && newDiffLine.oldLineNumber && newDiffLine.oldLineNumber > oldFileLineNumber)) {
+                if (this.#composeByDiff) {
+                    oldDiffLine && newFileLineNumber++;
+                    newDiffLine && oldFileLineNumber++;
+                    continue;
+                }
+                else {
+                    {
+                        console.error("some error happen for generate diff line!");
+                    }
+                }
+            }
             if (!oldDiffLine && !newRawLine && !oldDiffLine && !newDiffLine)
                 break;
             if ((oldLineHasChange && newLineHasChange) || (!oldLineHasChange && !newLineHasChange)) {
@@ -1195,12 +2725,14 @@ class DiffFile {
                     value: oldRawLine,
                     diff: oldDiffLine,
                     isHidden,
+                    _isHidden: isHidden,
                 });
                 this.#splitRightLines.push({
                     lineNumber: newFileLineNumber++,
                     value: newRawLine,
                     diff: newDiffLine,
                     isHidden,
+                    _isHidden: isHidden,
                 });
             }
             else if (oldLineHasChange) {
@@ -1208,6 +2740,8 @@ class DiffFile {
                     lineNumber: oldFileLineNumber++,
                     value: oldRawLine,
                     diff: oldDiffLine,
+                    isHidden,
+                    _isHidden: isHidden,
                 });
                 this.#splitRightLines.push({});
             }
@@ -1217,6 +2751,8 @@ class DiffFile {
                     lineNumber: newFileLineNumber++,
                     value: newRawLine,
                     diff: newDiffLine,
+                    isHidden,
+                    _isHidden: isHidden,
                 });
             }
             if (!prevIsHidden && isHidden) {
@@ -1234,18 +2770,48 @@ class DiffFile {
                             startHiddenIndex: hideStart,
                             endHiddenIndex: len,
                             plainText: typedPrevious.text,
+                            _startHiddenIndex: hideStart,
+                            _endHiddenIndex: len,
+                            _plainText: typedPrevious.text,
                         };
                         hideStart = Infinity;
                     }
                     this.#splitHunksLines = {
                         ...this.#splitHunksLines,
-                        [len]: previous,
+                        [len]: typedPrevious,
                     };
                 }
             }
         }
+        // have last hunk
+        if (Number.isFinite(hideStart)) {
+            const lastDiff = new DiffLine("", DiffLineType.Hunk, null, null, null);
+            const lastHunk = lastDiff;
+            lastHunk.isLast = true;
+            lastHunk.splitInfo = {
+                startHiddenIndex: hideStart,
+                endHiddenIndex: this.#splitRightLines.length,
+                _startHiddenIndex: hideStart,
+                _endHiddenIndex: this.#splitRightLines.length,
+                // just for placeholder
+                plainText: "",
+                oldStartIndex: 0,
+                newStartIndex: 0,
+                oldLength: 0,
+                newLength: 0,
+                _plainText: "",
+                _oldStartIndex: 0,
+                _newStartIndex: 0,
+                _oldLength: 0,
+                _newLength: 0,
+            };
+            this.#splitHunksLines = {
+                ...this.#splitHunksLines,
+                [this.#splitRightLines.length]: lastHunk,
+            };
+            hideStart = Infinity;
+        }
         this.splitLineLength = this.#splitRightLines.length;
-        this.#splitLastStartIndex = hideStart;
         this.#hasBuildSplit = true;
         this.notifyAll();
     }
@@ -1267,6 +2833,19 @@ class DiffFile {
             const newLineHasChange = newDiffLine?.isIncludeableLine();
             const len = this.#unifiedLines.length;
             const isHidden = !oldDiffLine && !newDiffLine;
+            if ((oldDiffLine && !newDiffLine && oldDiffLine.newLineNumber && oldDiffLine.newLineNumber > newFileLineNumber) ||
+                (!oldDiffLine && newDiffLine && newDiffLine.oldLineNumber && newDiffLine.oldLineNumber > oldFileLineNumber)) {
+                if (this.#composeByDiff) {
+                    oldDiffLine && newFileLineNumber++;
+                    newDiffLine && oldFileLineNumber++;
+                    continue;
+                }
+                else {
+                    {
+                        console.error("some error happen for generate diff line!");
+                    }
+                }
+            }
             if (!oldRawLine && !newRawLine && !newDiffLine && !oldDiffLine)
                 break;
             if (!oldLineHasChange && !newLineHasChange) {
@@ -1276,6 +2855,7 @@ class DiffFile {
                     value: newRawLine,
                     diff: newDiffLine,
                     isHidden,
+                    _isHidden: isHidden,
                 });
             }
             else if (oldLineHasChange) {
@@ -1283,6 +2863,8 @@ class DiffFile {
                     oldLineNumber: oldFileLineNumber++,
                     value: oldRawLine,
                     diff: oldDiffLine,
+                    isHidden,
+                    _isHidden: isHidden,
                 });
             }
             else if (newLineHasChange) {
@@ -1290,6 +2872,8 @@ class DiffFile {
                     newLineNumber: newFileLineNumber++,
                     value: newRawLine,
                     diff: newDiffLine,
+                    isHidden,
+                    _isHidden: isHidden,
                 });
             }
             if (!prevIsHidden && isHidden) {
@@ -1307,18 +2891,48 @@ class DiffFile {
                             startHiddenIndex: hideStart,
                             endHiddenIndex: len,
                             plainText: typedPrevious.text,
+                            _startHiddenIndex: hideStart,
+                            _endHiddenIndex: len,
+                            _plainText: typedPrevious.text,
                         };
                         hideStart = Infinity;
                     }
                     this.#unifiedHunksLines = {
                         ...this.#unifiedHunksLines,
-                        [len]: previous,
+                        [len]: typedPrevious,
                     };
                 }
             }
         }
+        // have last hunk
+        if (Number.isFinite(hideStart)) {
+            const lastDiff = new DiffLine("", DiffLineType.Hunk, null, null, null);
+            const lastHunk = lastDiff;
+            lastHunk.isLast = true;
+            lastHunk.unifiedInfo = {
+                startHiddenIndex: hideStart,
+                endHiddenIndex: this.#unifiedLines.length,
+                _startHiddenIndex: hideStart,
+                _endHiddenIndex: this.#unifiedLines.length,
+                // just for placeholder
+                plainText: "",
+                oldStartIndex: 0,
+                newStartIndex: 0,
+                oldLength: 0,
+                newLength: 0,
+                _plainText: "",
+                _oldStartIndex: 0,
+                _newStartIndex: 0,
+                _oldLength: 0,
+                _newLength: 0,
+            };
+            this.#unifiedHunksLines = {
+                ...this.#unifiedHunksLines,
+                [this.#unifiedLines.length]: lastHunk,
+            };
+            hideStart = Infinity;
+        }
         this.unifiedLineLength = this.#unifiedLines.length;
-        this.#unifiedLastStartIndex = hideStart;
         this.#hasBuildUnified = true;
         this.notifyAll();
     }
@@ -1331,9 +2945,9 @@ class DiffFile {
     getSplitHunkLine = (index) => {
         return this.#splitHunksLines?.[index];
     };
-    onSplitHunkExpand = (dir, index) => {
+    onSplitHunkExpand = (dir, index, needTrigger = true) => {
         const current = this.#splitHunksLines?.[index];
-        if (!current)
+        if (!current || !current.splitInfo)
             return;
         if (dir === "all") {
             for (let i = current.splitInfo.startHiddenIndex; i < current.splitInfo.endHiddenIndex; i++) {
@@ -1344,7 +2958,6 @@ class DiffFile {
                 if (rightLine?.isHidden)
                     rightLine.isHidden = false;
             }
-            current.splitInfo.plainText = current.text;
             current.splitInfo = {
                 ...current.splitInfo,
                 ...current.hunkInfo,
@@ -1361,13 +2974,25 @@ class DiffFile {
                 if (rightLine?.isHidden)
                     rightLine.isHidden = false;
             }
-            current.splitInfo = {
-                ...current.splitInfo,
-                startHiddenIndex: current.splitInfo.startHiddenIndex + composeLen,
-                plainText: `@@ -${current.splitInfo.oldStartIndex},${current.splitInfo.oldLength} +${current.splitInfo.newStartIndex},${current.splitInfo.newLength}`,
-            };
+            if (current.isLast) {
+                current.splitInfo = {
+                    ...current.splitInfo,
+                    startHiddenIndex: current.splitInfo.startHiddenIndex + composeLen,
+                };
+            }
+            else {
+                current.splitInfo = {
+                    ...current.splitInfo,
+                    startHiddenIndex: current.splitInfo.startHiddenIndex + composeLen,
+                    plainText: `@@ -${current.splitInfo.oldStartIndex},${current.splitInfo.oldLength} +${current.splitInfo.newStartIndex},${current.splitInfo.newLength}`,
+                };
+            }
         }
         else {
+            if (current.isLast) {
+                console.error("the last hunk can not expand up!");
+                return;
+            }
             for (let i = current.splitInfo.endHiddenIndex - composeLen; i < current.splitInfo.endHiddenIndex; i++) {
                 const leftLine = this.#splitLeftLines[i];
                 const rightLine = this.#splitRightLines[i];
@@ -1392,25 +3017,7 @@ class DiffFile {
             delete this.#splitHunksLines?.[index];
             this.#splitHunksLines[current.splitInfo.endHiddenIndex] = current;
         }
-        this.notifyAll();
-    };
-    onSplitLastExpand = (expandAll) => {
-        if (!this.#splitLastStartIndex || !Number.isFinite(this.#splitLastStartIndex))
-            return;
-        const start = this.#splitLastStartIndex;
-        const end = expandAll ? this.splitLineLength : this.#splitLastStartIndex + composeLen;
-        for (let i = start; i < end; i++) {
-            const leftLine = this.#splitLeftLines[i];
-            const rightLine = this.#splitRightLines[i];
-            if (leftLine?.isHidden)
-                leftLine.isHidden = false;
-            if (rightLine?.isHidden)
-                rightLine.isHidden = false;
-        }
-        this.#splitLastStartIndex = end;
-        this.#splitLastStartIndex =
-            this.#splitLastStartIndex >= this.splitLineLength ? Infinity : this.#splitLastStartIndex;
-        this.notifyAll();
+        needTrigger && this.notifyAll();
     };
     getUnifiedLine = (index) => {
         return this.#unifiedLines[index];
@@ -1418,9 +3025,9 @@ class DiffFile {
     getUnifiedHunkLine = (index) => {
         return this.#unifiedHunksLines?.[index];
     };
-    onUnifiedHunkExpand = (dir, index) => {
+    onUnifiedHunkExpand = (dir, index, needTrigger = true) => {
         const current = this.#unifiedHunksLines?.[index];
-        if (!current)
+        if (!current || !current.unifiedInfo)
             return;
         if (dir === "all") {
             for (let i = current.unifiedInfo.startHiddenIndex; i < current.unifiedInfo.endHiddenIndex; i++) {
@@ -1429,7 +3036,6 @@ class DiffFile {
                     unifiedLine.isHidden = false;
                 }
             }
-            current.unifiedInfo.plainText = current.text;
             current.unifiedInfo = {
                 ...current.unifiedInfo,
                 ...current.hunkInfo,
@@ -1443,13 +3049,25 @@ class DiffFile {
                 if (unifiedLine?.isHidden)
                     unifiedLine.isHidden = false;
             }
-            current.unifiedInfo = {
-                ...current.unifiedInfo,
-                startHiddenIndex: current.unifiedInfo.startHiddenIndex + composeLen,
-                plainText: `@@ -${current.unifiedInfo.oldStartIndex},${current.unifiedInfo.oldLength} +${current.unifiedInfo.newStartIndex},${current.unifiedInfo.newLength}`,
-            };
+            if (current.isLast) {
+                current.unifiedInfo = {
+                    ...current.unifiedInfo,
+                    startHiddenIndex: current.unifiedInfo.startHiddenIndex + composeLen,
+                };
+            }
+            else {
+                current.unifiedInfo = {
+                    ...current.unifiedInfo,
+                    startHiddenIndex: current.unifiedInfo.startHiddenIndex + composeLen,
+                    plainText: `@@ -${current.unifiedInfo.oldStartIndex},${current.unifiedInfo.oldLength} +${current.unifiedInfo.newStartIndex},${current.unifiedInfo.newLength}`,
+                };
+            }
         }
         else {
+            if (current.isLast) {
+                console.error("the last hunk can not expand up!");
+                return;
+            }
             for (let i = current.unifiedInfo.endHiddenIndex - composeLen; i < current.unifiedInfo.endHiddenIndex; i++) {
                 const unifiedLine = this.#unifiedLines[i];
                 if (unifiedLine?.isHidden)
@@ -1471,21 +3089,87 @@ class DiffFile {
             delete this.#unifiedHunksLines?.[index];
             this.#unifiedHunksLines[current.unifiedInfo.endHiddenIndex] = current;
         }
+        needTrigger && this.notifyAll();
+    };
+    onAllExpand = (mode) => {
+        if (mode === "split") {
+            Object.keys(this.#splitHunksLines || {}).forEach((key) => {
+                this.onSplitHunkExpand("all", +key, false);
+            });
+        }
+        else {
+            Object.keys(this.#unifiedHunksLines || {}).forEach((key) => {
+                this.onUnifiedHunkExpand("all", +key, false);
+            });
+        }
         this.notifyAll();
     };
-    onUnifiedLastExpand = (expandAll) => {
-        if (!this.#unifiedLastStartIndex || !Number.isFinite(this.#unifiedLastStartIndex))
-            return;
-        const start = this.#unifiedLastStartIndex;
-        const end = expandAll ? this.unifiedLineLength : this.#unifiedLastStartIndex + composeLen;
-        for (let i = start; i < end; i++) {
-            const unifiedLine = this.#unifiedLines[i];
-            if (unifiedLine?.isHidden)
-                unifiedLine.isHidden = false;
-        }
-        this.#unifiedLastStartIndex = end;
-        this.#unifiedLastStartIndex =
-            this.#unifiedLastStartIndex >= this.unifiedLineLength ? Infinity : this.#unifiedLastStartIndex;
+    onAllCollapse = (mode) => {
+        if (mode === "split") {
+            Object.values(this.#splitLeftLines || {}).forEach((item) => {
+                if (!item.isHidden && item._isHidden) {
+                    item.isHidden = item._isHidden;
+                }
+            });
+            Object.values(this.#splitRightLines || {}).forEach((item) => {
+                if (!item.isHidden && item._isHidden) {
+                    item.isHidden = item._isHidden;
+                }
+            });
+            Object.values(this.#splitHunksLines || {}).forEach((item) => {
+                if (!item.splitInfo)
+                    return;
+                item.splitInfo = {
+                    ...item.splitInfo,
+                    oldStartIndex: item.splitInfo._oldStartIndex,
+                    oldLength: item.splitInfo._oldLength,
+                    newStartIndex: item.splitInfo._newStartIndex,
+                    newLength: item.splitInfo._newLength,
+                    startHiddenIndex: item.splitInfo._startHiddenIndex,
+                    endHiddenIndex: item.splitInfo._endHiddenIndex,
+                    plainText: item.splitInfo._plainText,
+                };
+            });
+            Object.keys(this.#splitHunksLines || {}).forEach((key) => {
+                const item = this.#splitHunksLines[key];
+                if (!item.splitInfo)
+                    return;
+                if (item.splitInfo.endHiddenIndex !== +key) {
+                    delete this.#splitHunksLines[key];
+                    this.#splitHunksLines[item.splitInfo.endHiddenIndex] = item;
+                }
+            });
+        }
+        else {
+            Object.values(this.#unifiedLines || {}).forEach((item) => {
+                if (!item.isHidden && item._isHidden) {
+                    item.isHidden = item._isHidden;
+                }
+            });
+            Object.values(this.#unifiedHunksLines || {}).forEach((item) => {
+                if (!item.unifiedInfo)
+                    return;
+                item.unifiedInfo = {
+                    ...item.unifiedInfo,
+                    oldStartIndex: item.unifiedInfo._oldStartIndex,
+                    oldLength: item.unifiedInfo._oldLength,
+                    newStartIndex: item.unifiedInfo._newStartIndex,
+                    newLength: item.unifiedInfo._newLength,
+                    startHiddenIndex: item.unifiedInfo._startHiddenIndex,
+                    endHiddenIndex: item.unifiedInfo._endHiddenIndex,
+                    plainText: item.unifiedInfo._plainText,
+                };
+            });
+            Object.keys(this.#unifiedHunksLines || {}).forEach((key) => {
+                const item = this.#unifiedHunksLines[key];
+                if (!item.unifiedInfo)
+                    return;
+                if (item.unifiedInfo.endHiddenIndex !== +key) {
+                    delete this.#unifiedHunksLines[key];
+                    this.#unifiedHunksLines[item.unifiedInfo.endHiddenIndex] = item;
+                }
+            });
+        }
         this.notifyAll();
     };
     getOldSyntaxLine = (lineNumber) => {
@@ -1510,19 +3194,6 @@ class DiffFile {
         });
     };
     getUpdateCount = () => this.#updateCount;
-    getNeedShowExpandAll = (mode) => {
-        if (mode === "split") {
-            return (this.#splitLastStartIndex &&
-                Number.isFinite(this.#splitLastStartIndex) &&
-                (this.getSplitLeftLine(this.splitLineLength - 1)?.isHidden ||
-                    this.getSplitRightLine(this.splitLineLength - 1)?.isHidden));
-        }
-        else {
-            return (this.#unifiedLastStartIndex &&
-                Number.isFinite(this.#unifiedLastStartIndex) &&
-                this.getUnifiedLine(this.unifiedLineLength - 1)?.isHidden);
-        }
-    };
     getExpandEnabled = () => !this.#composeByDiff;
     getBundle = () => {
         // common
@@ -1543,11 +3214,10 @@ class DiffFile {
         const splitLeftLines = this.#splitLeftLines;
         const splitRightLines = this.#splitRightLines;
         const splitHunkLines = this.#splitHunksLines;
-        const splitLastStartIndex = this.#splitLastStartIndex;
         // unified
         const unifiedLines = this.#unifiedLines;
         const unifiedHunkLines = this.#unifiedHunksLines;
-        const unifiedLastStartIndex = this.#unifiedLastStartIndex;
+        const version = this._version_;
         return {
             hasInitRaw,
             hasInitSyntax,
@@ -1564,11 +3234,10 @@ class DiffFile {
             splitLeftLines,
             splitRightLines,
             splitHunkLines,
-            splitLastStartIndex,
             unifiedLines,
             unifiedHunkLines,
-            unifiedLastStartIndex,
             composeByDiff,
+            version
         };
     };
     mergeBundle = (data) => {
@@ -1588,10 +3257,11 @@ class DiffFile {
         this.#splitLeftLines = data.splitLeftLines;
         this.#splitRightLines = data.splitRightLines;
         this.#splitHunksLines = data.splitHunkLines;
-        this.#splitLastStartIndex = data.splitLastStartIndex;
         this.#unifiedLines = data.unifiedLines;
         this.#unifiedHunksLines = data.unifiedHunkLines;
-        this.#unifiedLastStartIndex = data.unifiedLastStartIndex;
+        if (this._version_ !== data.version) {
+            console.error('the version of the `diffInstance` is not match, some error may happen!');
+        }
         this.notifyAll();
     };
     _addClonedInstance = (instance) => {
@@ -1641,6 +3311,24 @@ class DiffFile {
         this.#clonedInstance.forEach((v) => v());
         this.#clonedInstance.clear();
     };
+    clear = () => {
+        this._destroy();
+        this.#oldFileResult = null;
+        this.#newFileResult = null;
+        this.#diffLines = null;
+        this.#diffListResults = null;
+        this.#newFileDiffLines = null;
+        this.#oldFileDiffLines = null;
+        this.#newFileLines = null;
+        this.#oldFileLines = null;
+        this.#newFileSyntaxLines = null;
+        this.#oldFileSyntaxLines = null;
+        this.#splitHunksLines = null;
+        this.#splitLeftLines = null;
+        this.#splitRightLines = null;
+        this.#unifiedHunksLines = null;
+        this.#unifiedLines = null;
+    };
 }
 
 var DiffFileLineType;
@@ -1649,7 +3337,6 @@ var DiffFileLineType;
     DiffFileLineType[DiffFileLineType["content"] = 2] = "content";
     DiffFileLineType[DiffFileLineType["widget"] = 3] = "widget";
     DiffFileLineType[DiffFileLineType["extend"] = 4] = "extend";
-    DiffFileLineType[DiffFileLineType["lastHunk"] = 5] = "lastHunk";
 })(DiffFileLineType || (DiffFileLineType = {}));
 const getSplitLines = (diffFile, options) => {
     const splitLineLength = diffFile.splitLineLength;
@@ -1677,15 +3364,6 @@ const getSplitLines = (diffFile, options) => {
         extendLine &&
             splitLines.push({ type: DiffFileLineType.extend, index, lineNumber: index + 1, extendLine: extendLine });
     });
-    const lastHunkLine = diffFile.getNeedShowExpandAll("split");
-    const expandEnabled = diffFile.getExpandEnabled();
-    if (lastHunkLine && expandEnabled) {
-        splitLines.push({
-            type: DiffFileLineType.lastHunk,
-            index: splitLineLength,
-            lineNumber: splitLineLength + 1,
-        });
-    }
     return splitLines;
 };
 const getSplitContentLines = (diffFile) => {
@@ -1711,15 +3389,6 @@ const getUnifiedLines = (diffFile, options) => {
         extendLine &&
             unifiedLines.push({ type: DiffFileLineType.extend, index, lineNumber: index + 1, extendLine: extendLine });
     });
-    const lastHunkLine = diffFile.getNeedShowExpandAll("unified");
-    const expandEnabled = diffFile.getExpandEnabled();
-    if (lastHunkLine && expandEnabled) {
-        unifiedLines.push({
-            type: DiffFileLineType.lastHunk,
-            index: unifiedLineLength,
-            lineNumber: unifiedLineLength + 1,
-        });
-    }
     return unifiedLines;
 };
 const getUnifiedContentLine = (diffFile) => {
@@ -1733,6 +3402,47 @@ const useUnmount = (cb, deps) => {
     React.useEffect(() => ref.current, deps);
 };
 
+const isClient = typeof window !== "undefined";
+const useSafeLayout = isClient ? React.useLayoutEffect : React.useEffect;
+
+let canvasCtx = null;
+class TextMeasure {
+    #key = "";
+    #map = {};
+    #getInstance() {
+        canvasCtx = canvasCtx || document.createElement("canvas").getContext("2d");
+        return canvasCtx;
+    }
+    measure(text, font) {
+        const currentKey = `${font?.fontFamily}-${font?.fontStyle}-${font?.fontSize}-${text}`;
+        if (this.#map[currentKey]) {
+            return this.#map[currentKey];
+        }
+        const instance = this.#getInstance();
+        if (font) {
+            const currentFontKey = `${font.fontFamily}-${font.fontStyle}-${font.fontSize}`;
+            if (this.#key !== currentFontKey) {
+                this.#key = currentFontKey;
+                instance.font = `${font.fontStyle || ""} ${font.fontSize || ""} ${font.fontFamily || ""}`;
+            }
+        }
+        else {
+            instance.font = "";
+        }
+        const textWidth = instance.measureText(text).width;
+        return textWidth;
+    }
+}
+const measureInstance = new TextMeasure();
+const useTextWidth = ({ text, font, }) => {
+    const [width, setWidth] = React.useState(0);
+    useSafeLayout(() => {
+        const width = measureInstance.measure(text, font);
+        setWidth(width);
+    }, [text, font]);
+    return width;
+};
+
 const useDomWidth = ({ selector, enable }) => {
     const [width, setWidth] = React.useState(0);
     const { useDiffContext } = useDiffViewContext();
@@ -1783,9 +3493,6 @@ const DiffViewContext = React.createContext(null);
 DiffViewContext.displayName = "DiffViewContext";
 const useDiffViewContext = () => React.useContext(DiffViewContext);
 
-const isClient = typeof window !== "undefined";
-const useSafeLayout = isClient ? React.useLayoutEffect : React.useEffect;
-
 const useSyncHeight = ({ selector, side, enable, }) => {
     const { useDiffContext } = useDiffViewContext();
     const id = useDiffContext(React.useCallback((s) => s.id, []));
@@ -1934,22 +3641,26 @@ const _DiffSplitHunkLine = ({ index, diffFile, side, lineNumber, }) => {
         currentHunk.splitInfo &&
         currentHunk.splitInfo.endHiddenIndex - currentHunk.splitInfo.startHiddenIndex < composeLen;
     const isFirstLine = currentHunk && currentHunk.index === 0;
+    const isLastLine = currentHunk && currentHunk.isLast;
     return (React__namespace.createElement("tr", { "data-line": `${lineNumber}-hunk`, "data-state": "hunk", "data-side": exports.SplitSide[side], className: "diff-line diff-line-hunk" }, enableHunkAction ? (React__namespace.createElement(React__namespace.Fragment, null,
         React__namespace.createElement("td", { className: "diff-line-hunk-action sticky left-0 p-[1px] w-[1%] min-w-[40px] select-none", style: {
                 backgroundColor: `var(${hunkLineNumberBGName})`,
                 color: `var(${plainLineNumberColorName})`,
             } }, expandEnabled ? (isFirstLine ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand Up", "data-title": "Expand Up", onClick: () => diffFile.onSplitHunkExpand("up", index) },
-            React__namespace.createElement(ExpandUp, { className: "fill-current" }))) : isExpandAll ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand All", "data-title": "Expand All", onClick: () => diffFile.onSplitHunkExpand("all", index) },
+            React__namespace.createElement(ExpandUp, { className: "fill-current" }))) : isLastLine ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px] relative", title: "Expand Down", "data-title": "Expand Down", onClick: () => {
+                diffFile.onSplitHunkExpand("down", index);
+            } },
+            React__namespace.createElement(ExpandDown, { className: "fill-current" }))) : isExpandAll ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand All", "data-title": "Expand All", onClick: () => diffFile.onSplitHunkExpand("all", index) },
             React__namespace.createElement(ExpandAll, { className: "fill-current" }))) : (React__namespace.createElement(React__namespace.Fragment, null,
             React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[2px] cursor-pointer rounded-[2px]", title: "Expand Down", "data-title": "Expand Down", onClick: () => diffFile.onSplitHunkExpand("down", index) },
                 React__namespace.createElement(ExpandDown, { className: "fill-current" })),
             React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[2px] cursor-pointer rounded-[2px]", title: "Expand Up", "data-title": "Expand Up", onClick: () => diffFile.onSplitHunkExpand("up", index) },
-                React__namespace.createElement(ExpandUp, { className: "fill-current" }))))) : (React__namespace.createElement("span", null, "\u2002"))),
+                React__namespace.createElement(ExpandUp, { className: "fill-current" }))))) : (React__namespace.createElement("div", { className: "min-h-[28px]" }, "\u2002"))),
         React__namespace.createElement("td", { className: "diff-line-hunk-content pr-[10px] align-middle", style: { backgroundColor: `var(${hunkContentBGName})` } },
             React__namespace.createElement("div", { className: "pl-[1.5em]", style: {
                     color: `var(${hunkContentColorName})`,
                 } }, currentHunk.splitInfo.plainText)))) : (React__namespace.createElement("td", { className: "diff-line-hunk-placeholder select-none", colSpan: 2, style: { backgroundColor: `var(${hunkContentBGName})` } },
-        React__namespace.createElement("span", null, "\u2002")))));
+        React__namespace.createElement("div", { className: "min-h-[28px]" }, "\u2002")))));
 };
 const DiffSplitHunkLine$1 = ({ index, diffFile, side, lineNumber, }) => {
     const currentHunk = diffFile.getSplitHunkLine(index);
@@ -1960,33 +3671,6 @@ const DiffSplitHunkLine$1 = ({ index, diffFile, side, lineNumber, }) => {
         return null;
     return React__namespace.createElement(_DiffSplitHunkLine, { index: index, diffFile: diffFile, side: side, lineNumber: lineNumber });
 };
-const _DiffSplitLastHunkLine = ({ diffFile, side }) => {
-    const enableHunkAction = side === exports.SplitSide.old;
-    useSyncHeight({
-        selector: `tr[data-line="last-hunk"]`,
-        side: exports.SplitSide[exports.SplitSide.old],
-        enable: side === exports.SplitSide.new,
-    });
-    return (React__namespace.createElement("tr", { "data-line": "last-hunk", "data-state": "hunk", "data-side": exports.SplitSide[side], className: "diff-line diff-line-hunk" }, enableHunkAction ? (React__namespace.createElement(React__namespace.Fragment, null,
-        React__namespace.createElement("td", { className: "diff-line-hunk-action sticky left-0 p-[1px] w-[1%] min-w-[40px] select-none", style: {
-                backgroundColor: `var(${hunkLineNumberBGName})`,
-                color: `var(${plainLineNumberColorName})`,
-            } },
-            React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px] relative", title: "Expand Down", "data-title": "Expand Down", onClick: () => {
-                    diffFile.onSplitLastExpand();
-                } },
-                React__namespace.createElement(ExpandDown, { className: "fill-current" }))),
-        React__namespace.createElement("td", { className: "diff-line-hunk-content pr-[10px] align-middle select-none", style: { backgroundColor: `var(${hunkContentBGName})` } },
-            React__namespace.createElement("span", null, "\u2002")))) : (React__namespace.createElement("td", { className: "diff-line-hunk-placeholder select-none", colSpan: 2, style: { backgroundColor: `var(${hunkContentBGName})` } },
-        React__namespace.createElement("span", null, "\u2002")))));
-};
-const DiffSplitLastHunkLine$1 = ({ diffFile, side }) => {
-    const currentIsShow = diffFile.getNeedShowExpandAll("split");
-    const expandEnabled = diffFile.getExpandEnabled();
-    if (!currentIsShow || !expandEnabled)
-        return null;
-    return React__namespace.createElement(_DiffSplitLastHunkLine, { diffFile: diffFile, side: side });
-};
 
 const DiffSplitAddWidget = ({ side, className, lineNumber, onWidgetClick, onOpenAddWidget, }) => {
     return (React__namespace.createElement("div", { className: "diff-add-widget-wrapper" + (className ? " " + className : ""), style: {
@@ -2021,16 +3705,25 @@ const DiffUnifiedAddWidget = ({ lineNumber, side, onWidgetClick, onOpenAddWidget
 
 const DiffString = ({ rawLine, diffLine, operator, }) => {
     const range = diffLine?.range;
-    if (range && range.length > 0 && range.length < rawLine.length) {
+    if (range) {
         const str1 = rawLine.slice(0, range.location);
         const str2 = rawLine.slice(range.location, range.location + range.length);
         const str3 = rawLine.slice(range.location + range.length);
+        const isNewLineSymbolChanged = range.isNewLineSymbolChanged;
         return (React__namespace.createElement("span", { className: "diff-line-content-raw" },
             React__namespace.createElement("span", { "data-range-start": range.location, "data-range-end": range.location + range.length },
                 str1,
                 React__namespace.createElement("span", { "data-diff-highlight": true, className: "rounded-[0.2em]", style: {
                         backgroundColor: operator === "add" ? `var(${addContentHighlightBGName})` : `var(${delContentHighlightBGName})`,
-                    } }, str2 === "\r" ? "␍" : str2 === "\n" ? "␊" : str2 === "\r\n" ? "␍␊" : str2),
+                    } }, isNewLineSymbolChanged
+                    ? str2 === "\r"
+                        ? "␍"
+                        : str2 === "\n"
+                            ? "␊"
+                            : str2 === "\r\n"
+                                ? "␍␊"
+                                : str2
+                    : str2),
                 str3)));
     }
     return React__namespace.createElement("span", { className: "diff-line-content-raw" }, rawLine);
@@ -2040,7 +3733,7 @@ const DiffSyntax = ({ rawLine, diffLine, operator, syntaxLine, }) => {
         return React__namespace.createElement(DiffString, { rawLine: rawLine, diffLine: diffLine, operator: operator });
     }
     const range = diffLine?.range;
-    if (range && range.length > 0 && range.length < syntaxLine.valueLength) {
+    if (range) {
         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 }, syntaxLine.nodeList?.map(({ node, wrapper }, index) => {
                 if (node.endIndex < range.location || range.location + range.length < node.startIndex) {
@@ -2054,6 +3747,7 @@ const DiffSyntax = ({ rawLine, diffLine, operator, syntaxLine, }) => {
                     const str3 = node.value.slice(index1 + range.length);
                     const isStart = str1.length || range.location === node.startIndex;
                     const isEnd = str3.length || node.endIndex === range.location + range.length - 1;
+                    const isNewLineSymbolChanged = range.isNewLineSymbolChanged;
                     return (React__namespace.createElement("span", { key: index, "data-start": node.startIndex, "data-end": node.endIndex, className: wrapper?.properties?.className?.join(" ") },
                         str1,
                         React__namespace.createElement("span", { "data-diff-highlight": true, style: {
@@ -2062,7 +3756,15 @@ const DiffSyntax = ({ rawLine, diffLine, operator, syntaxLine, }) => {
                                 borderBottomLeftRadius: isStart ? "0.2em" : undefined,
                                 borderTopRightRadius: isEnd ? "0.2em" : undefined,
                                 borderBottomRightRadius: isEnd ? "0.2em" : undefined,
-                            } }, str2 === "\r" ? "␍" : str2 === "\n" ? "␊" : str2 === "\r\n" ? "␍␊" : str2),
+                            } }, isNewLineSymbolChanged
+                            ? str2 === "\r"
+                                ? "␍"
+                                : str2 === "\n"
+                                    ? "␊"
+                                    : str2 === "\r\n"
+                                        ? "␍␊"
+                                        : str2
+                            : str2),
                         str3));
                 }
             }))));
@@ -2072,12 +3774,13 @@ const DiffSyntax = ({ rawLine, diffLine, operator, syntaxLine, }) => {
 const DiffContent = ({ diffLine, rawLine, syntaxLine, enableWrap, enableHighlight, }) => {
     const isAdded = diffLine?.type === DiffLineType.Add;
     const isDelete = diffLine?.type === DiffLineType.Delete;
+    const isMaxLineLengthToIgnoreSyntax = syntaxLine?.nodeList?.length > 150;
     return (React__namespace.createElement("div", { className: "diff-line-content-item pl-[2.0em]", "data-val": rawLine, style: {
             whiteSpace: enableWrap ? "pre-wrap" : "pre",
             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 ? (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 })) : (React__namespace.createElement(DiffString, { operator: isAdded ? "add" : isDelete ? "del" : undefined, rawLine: rawLine, diffLine: diffLine }))));
 };
 
 const DiffWidgetContext = React.createContext(null);
@@ -2203,12 +3906,12 @@ const onMouseDown$1 = (e) => {
         return;
     }
 };
-const DiffSplitViewTable = ({ side, diffFile }) => {
+const DiffSplitViewTable = ({ side, diffFile, width }) => {
     const className = side === exports.SplitSide.new ? "new-diff-table" : "old-diff-table";
     const lines = getSplitContentLines(diffFile);
     return (React__namespace.createElement("table", { className: className + " border-collapse w-full", "data-mode": exports.SplitSide[side] },
         React__namespace.createElement("colgroup", null,
-            React__namespace.createElement("col", { className: `diff-table-${exports.SplitSide[side]}-num-col` }),
+            React__namespace.createElement("col", { className: `diff-table-${exports.SplitSide[side]}-num-col`, style: { minWidth: Math.round(width) + 25 } }),
             React__namespace.createElement("col", { className: `diff-table-${exports.SplitSide[side]}-content-col` })),
         React__namespace.createElement("thead", { className: "hidden" },
             React__namespace.createElement("tr", null,
@@ -2224,11 +3927,14 @@ const DiffSplitViewTable = ({ side, diffFile }) => {
                 React__namespace.createElement(DiffSplitLine$1, { index: line.index, side: side, lineNumber: line.lineNumber, diffFile: diffFile }),
                 React__namespace.createElement(DiffSplitWidgetLine$1, { index: line.index, side: side, lineNumber: line.lineNumber, diffFile: diffFile }),
                 React__namespace.createElement(DiffSplitExtendLine$1, { index: line.index, side: side, lineNumber: line.lineNumber, diffFile: diffFile })))),
-            React__namespace.createElement(DiffSplitLastHunkLine$1, { side: side, diffFile: diffFile }))));
+            React__namespace.createElement(DiffSplitHunkLine$1, { side: side, index: diffFile.splitLineLength, lineNumber: diffFile.splitLineLength, diffFile: diffFile }))));
 };
 const DiffSplitViewNormal = React.memo(({ diffFile }) => {
     const ref1 = React.useRef(null);
     const ref2 = React.useRef(null);
+    const splitLineLength = diffFile.splitLineLength;
+    const { useDiffContext } = useDiffViewContext();
+    const fontSize = useDiffContext(React.useCallback((s) => s.fontSize, []));
     shim.useSyncExternalStore(diffFile.subscribe, diffFile.getUpdateCount);
     React.useEffect(() => {
         const left = ref1.current;
@@ -2237,61 +3943,27 @@ const DiffSplitViewNormal = React.memo(({ diffFile }) => {
             return;
         return syncScroll(left, right);
     }, []);
+    const width = useTextWidth({
+        text: splitLineLength.toString(),
+        font: { fontSize: fontSize + "px", fontFamily: "Menlo, Consolas, monospace" },
+    });
     return (React__namespace.createElement("div", { className: "split-diff-view split-diff-view-wrap w-full flex basis-[50%]" },
         React__namespace.createElement("div", { className: "old-diff-table-wrapper overflow-auto w-full scrollbar-hide scrollbar-disable", ref: ref1, style: {
                 overscrollBehaviorX: "none",
                 fontFamily: "Menlo, Consolas, monospace",
                 fontSize: "var(--diff-font-size--)",
             } },
-            React__namespace.createElement(DiffSplitViewTable, { side: exports.SplitSide.old, diffFile: diffFile })),
+            React__namespace.createElement(DiffSplitViewTable, { side: exports.SplitSide.old, diffFile: diffFile, width: width })),
         React__namespace.createElement("div", { className: "diff-split-line w-[1.5px] bg-[#ccc]" }),
         React__namespace.createElement("div", { className: "new-diff-table-wrapper overflow-auto w-full scrollbar-hide scrollbar-disable", ref: ref2, style: {
                 overscrollBehaviorX: "none",
                 fontFamily: "Menlo, Consolas, monospace",
                 fontSize: "var(--diff-font-size--)",
             } },
-            React__namespace.createElement(DiffSplitViewTable, { side: exports.SplitSide.new, diffFile: diffFile }))));
+            React__namespace.createElement(DiffSplitViewTable, { side: exports.SplitSide.new, diffFile: diffFile, width: width }))));
 });
 DiffSplitViewNormal.displayName = "DiffSplitViewNormal";
 
-let canvasCtx = null;
-class TextMeasure {
-    #key = "";
-    #map = {};
-    #getInstance() {
-        canvasCtx = canvasCtx || document.createElement("canvas").getContext("2d");
-        return canvasCtx;
-    }
-    measure(text, font) {
-        const currentKey = `${font?.fontFamily}-${font?.fontStyle}-${font?.fontSize}-${text}`;
-        if (this.#map[currentKey]) {
-            return this.#map[currentKey];
-        }
-        const instance = this.#getInstance();
-        if (font) {
-            const currentFontKey = `${font.fontFamily}-${font.fontStyle}-${font.fontSize}`;
-            if (this.#key !== currentFontKey) {
-                this.#key = currentFontKey;
-                instance.font = `${font.fontStyle || ""} ${font.fontSize || ""} ${font.fontFamily || ""}`;
-            }
-        }
-        else {
-            instance.font = "";
-        }
-        const textWidth = instance.measureText(text).width;
-        return textWidth;
-    }
-}
-const measureInstance = new TextMeasure();
-const useTextWidth = ({ text, font, }) => {
-    const [width, setWidth] = React.useState(0);
-    useSafeLayout(() => {
-        const width = measureInstance.measure(text, font);
-        setWidth(width);
-    }, [text, font]);
-    return width;
-};
-
 const _DiffSplitExtendLine = ({ index, diffFile, lineNumber, }) => {
     const { useDiffContext } = useDiffViewContext();
     // 需要显示的时候才进行方法订阅，可以大幅度提高性能
@@ -2345,42 +4017,26 @@ const DiffSplitHunkLine = ({ index, diffFile, lineNumber, }) => {
         currentHunk.splitInfo &&
         currentHunk.splitInfo.startHiddenIndex < currentHunk.splitInfo.endHiddenIndex;
     const isFirstLine = currentHunk && currentHunk.index === 0;
+    const isLastLine = currentHunk && currentHunk.isLast;
     if (!currentIsShow)
         return null;
     return (React__namespace.createElement("tr", { "data-line": `${lineNumber}-hunk`, "data-state": "hunk", className: "diff-line diff-line-hunk" },
         React__namespace.createElement("td", { className: "diff-line-hunk-action p-[1px] w-[1%] min-w-[40px] select-none", style: {
                 backgroundColor: `var(${hunkLineNumberBGName})`,
                 color: `var(${plainLineNumberColorName})`,
-            } }, expandEnabled &&
-            (isFirstLine ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand Up", "data-title": "Expand Up", onClick: () => diffFile.onSplitHunkExpand("up", index) },
-                React__namespace.createElement(ExpandUp, { className: "fill-current" }))) : isExpandAll ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand All", "data-title": "Expand All", onClick: () => diffFile.onSplitHunkExpand("all", index) },
-                React__namespace.createElement(ExpandAll, { className: "fill-current" }))) : (React__namespace.createElement(React__namespace.Fragment, null,
-                React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[2px] cursor-pointer rounded-[2px]", title: "Expand Down", "data-title": "Expand Down", onClick: () => diffFile.onSplitHunkExpand("down", index) },
-                    React__namespace.createElement(ExpandDown, { className: "fill-current" })),
-                React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[2px] cursor-pointer rounded-[2px]", title: "Expand Up", "data-title": "Expand Up", onClick: () => diffFile.onSplitHunkExpand("up", index) },
-                    React__namespace.createElement(ExpandUp, { className: "fill-current" })))))),
+            } }, expandEnabled ? (isFirstLine ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand Up", "data-title": "Expand Up", onClick: () => diffFile.onSplitHunkExpand("up", index) },
+            React__namespace.createElement(ExpandUp, { className: "fill-current" }))) : isLastLine ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand Down", "data-title": "Expand Down", onClick: () => diffFile.onSplitHunkExpand("down", index) },
+            React__namespace.createElement(ExpandDown, { className: "fill-current" }))) : isExpandAll ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand All", "data-title": "Expand All", onClick: () => diffFile.onSplitHunkExpand("all", index) },
+            React__namespace.createElement(ExpandAll, { className: "fill-current" }))) : (React__namespace.createElement(React__namespace.Fragment, null,
+            React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[2px] cursor-pointer rounded-[2px]", title: "Expand Down", "data-title": "Expand Down", onClick: () => diffFile.onSplitHunkExpand("down", index) },
+                React__namespace.createElement(ExpandDown, { className: "fill-current" })),
+            React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[2px] cursor-pointer rounded-[2px]", title: "Expand Up", "data-title": "Expand Up", onClick: () => diffFile.onSplitHunkExpand("up", index) },
+                React__namespace.createElement(ExpandUp, { className: "fill-current" }))))) : (React__namespace.createElement("div", { className: "min-h-[28px]" }, "\u2002"))),
         React__namespace.createElement("td", { className: "diff-line-hunk-content pr-[10px] align-middle", style: { backgroundColor: `var(${hunkContentBGName})` }, colSpan: 3 },
             React__namespace.createElement("div", { className: "pl-[1.5em]", style: {
                     color: `var(${hunkContentColorName})`,
                 } }, currentHunk.splitInfo.plainText))));
 };
-const DiffSplitLastHunkLine = ({ diffFile }) => {
-    const currentIsShow = diffFile.getNeedShowExpandAll("split");
-    const expandEnabled = diffFile.getExpandEnabled();
-    if (!currentIsShow || !expandEnabled)
-        return null;
-    return (React__namespace.createElement("tr", { "data-line": "last-hunk", "data-state": "hunk", className: "diff-line diff-line-hunk" },
-        React__namespace.createElement("td", { className: "diff-line-hunk-action p-[1px] w-[1%] min-w-[40px] select-none", style: {
-                backgroundColor: `var(${hunkLineNumberBGName})`,
-                color: `var(${plainLineNumberColorName})`,
-            } },
-            React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand Down", "data-title": "Expand Down", onClick: () => {
-                    diffFile.onSplitLastExpand();
-                } },
-                React__namespace.createElement(ExpandDown, { className: "fill-current" }))),
-        React__namespace.createElement("td", { className: "diff-line-hunk-content pr-[10px] align-middle select-none", colSpan: 3, style: { backgroundColor: `var(${hunkContentBGName})` } },
-            React__namespace.createElement("span", null, "\u2002"))));
-};
 
 const _DiffSplitLine = ({ index, diffFile, lineNumber }) => {
     const oldLine = diffFile.getSplitLeftLine(index);
@@ -2473,7 +4129,6 @@ const DiffSplitWidgetLine = ({ index, diffFile, lineNumber, }) => {
     return React__namespace.createElement(_DiffSplitWidgetLine, { index: index, diffFile: diffFile, lineNumber: lineNumber });
 };
 
-/* eslint-disable jsx-a11y/no-noninteractive-element-interactions */
 const Style = ({ useSelector, id, }) => {
     const splitRef = useSelector((s) => s.splitRef);
     return (React__namespace.createElement("style", null, splitRef === exports.SplitSide.old
@@ -2544,7 +4199,7 @@ const DiffSplitViewWrap = React.memo(({ diffFile }) => {
                         React__namespace.createElement(DiffSplitLine, { index: line.index, lineNumber: line.lineNumber, diffFile: diffFile }),
                         React__namespace.createElement(DiffSplitWidgetLine, { index: line.index, lineNumber: line.lineNumber, diffFile: diffFile }),
                         React__namespace.createElement(DiffSplitExtendLine, { index: line.index, lineNumber: line.lineNumber, diffFile: diffFile })))),
-                    React__namespace.createElement(DiffSplitLastHunkLine, { diffFile: diffFile }))))));
+                    React__namespace.createElement(DiffSplitHunkLine, { index: diffFile.splitLineLength, lineNumber: diffFile.splitLineLength, diffFile: diffFile }))))));
 });
 DiffSplitViewWrap.displayName = "DiffSplitViewWrap";
 
@@ -2556,11 +4211,14 @@ const DiffSplitView = React.memo(({ diffFile }) => {
         const widgetSide = reactivityStore.ref(undefined);
         const widgetLineNumber = reactivityStore.ref(undefined);
         const setWidget = ({ side, lineNumber }) => {
+            const { renderWidgetLine } = useDiffContext.getReadonlyState();
+            if (typeof renderWidgetLine !== "function")
+                return;
             widgetSide.value = side;
             widgetLineNumber.value = lineNumber;
         };
         return { widgetSide, widgetLineNumber, setWidget };
-    }), []);
+    }), [useDiffContext]);
     const contextValue = React.useMemo(() => ({ useWidget }), [useWidget]);
     shim.useSyncExternalStore(diffFile.subscribe, diffFile.getUpdateCount);
     React.useEffect(() => {
@@ -2623,17 +4281,19 @@ const _DiffUnifiedHunkLine = ({ index, diffFile, lineNumber, }) => {
         currentHunk.unifiedInfo &&
         currentHunk.unifiedInfo.endHiddenIndex - currentHunk.unifiedInfo.startHiddenIndex < composeLen;
     const isFirstLine = currentHunk && currentHunk.index === 0;
+    const isLastLine = currentHunk && currentHunk.isLast;
     return (React__namespace.createElement("tr", { "data-line": `${lineNumber}-hunk`, "data-state": "hunk", className: "diff-line diff-line-hunk" },
         React__namespace.createElement("td", { className: "diff-line-hunk-action sticky left-0 p-[1px] w-[1%] min-w-[100px] select-none", style: {
                 backgroundColor: `var(${hunkLineNumberBGName})`,
                 color: `var(${plainLineNumberColorName})`,
             } }, expandEnabled ? (isFirstLine ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand Up", "data-title": "Expand Up", onClick: () => diffFile.onUnifiedHunkExpand("up", index) },
-            React__namespace.createElement(ExpandUp, { className: "fill-current" }))) : isExpandAll ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand All", "data-title": "Expand All", onClick: () => diffFile.onUnifiedHunkExpand("all", index) },
+            React__namespace.createElement(ExpandUp, { className: "fill-current" }))) : isLastLine ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand Down", "data-title": "Expand Down", onClick: () => diffFile.onUnifiedHunkExpand("down", index) },
+            React__namespace.createElement(ExpandDown, { className: "fill-current" }))) : isExpandAll ? (React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand All", "data-title": "Expand All", onClick: () => diffFile.onUnifiedHunkExpand("all", index) },
             React__namespace.createElement(ExpandAll, { className: "fill-current" }))) : (React__namespace.createElement(React__namespace.Fragment, null,
             React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[2px] cursor-pointer rounded-[2px]", title: "Expand Down", "data-title": "Expand Down", onClick: () => diffFile.onUnifiedHunkExpand("down", index) },
                 React__namespace.createElement(ExpandDown, { className: "fill-current" })),
             React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[2px] cursor-pointer rounded-[2px]", title: "Expand Up", "data-title": "Expand Up", onClick: () => diffFile.onUnifiedHunkExpand("up", index) },
-                React__namespace.createElement(ExpandUp, { className: "fill-current" }))))) : null),
+                React__namespace.createElement(ExpandUp, { className: "fill-current" }))))) : (React__namespace.createElement("div", { className: "min-h-[28px]" }, "\u2002"))),
         React__namespace.createElement("td", { className: "diff-line-hunk-content pr-[10px] align-middle", style: { backgroundColor: `var(${hunkContentBGName})` } },
             React__namespace.createElement("div", { className: "pl-[1.5em]", style: {
                     whiteSpace: enableWrap ? "pre-wrap" : "pre",
@@ -2650,21 +4310,6 @@ const DiffUnifiedHunkLine = ({ index, diffFile, lineNumber, }) => {
         return null;
     return React__namespace.createElement(_DiffUnifiedHunkLine, { index: index, diffFile: diffFile, lineNumber: lineNumber });
 };
-const DiffUnifiedLastHunkLine = ({ diffFile }) => {
-    const currentIsShow = diffFile.getNeedShowExpandAll("unified");
-    const expandEnabled = diffFile.getExpandEnabled();
-    if (!currentIsShow || !expandEnabled)
-        return null;
-    return (React__namespace.createElement("tr", { "data-line": "last-hunk", "data-state": "hunk", className: "diff-line diff-line-hunk" },
-        React__namespace.createElement("td", { className: "diff-line-hunk-action sticky left-0 w-[1%] min-w-[100px] select-none", style: {
-                backgroundColor: `var(${hunkLineNumberBGName})`,
-                color: `var(${plainLineNumberColorName})`,
-            } },
-            React__namespace.createElement("button", { className: "w-full diff-widget-tooltip hover:bg-blue-300 flex justify-center items-center py-[6px] cursor-pointer rounded-[2px]", title: "Expand Down", "data-title": "Expand Down", onClick: () => diffFile.onUnifiedLastExpand() },
-                React__namespace.createElement(ExpandDown, { className: "fill-current" }))),
-        React__namespace.createElement("td", { className: "diff-line-hunk-content pr-[10px] align-middle", style: { backgroundColor: `var(${hunkContentBGName})` } },
-            React__namespace.createElement("span", null, "\u2002"))));
-};
 
 const DiffUnifiedOldLine = ({ index, diffLine, rawLine, syntaxLine, lineNumber, diffFile, setWidget, enableWrap, enableAddWidget, enableHighlight, onAddWidgetClick, }) => {
     return (React__namespace.createElement("tr", { "data-line": index, "data-state": "diff", className: "diff-line group" },
@@ -2792,16 +4437,20 @@ const onMouseDown = (e) => {
     }
 };
 const DiffUnifiedView = React.memo(({ diffFile }) => {
+    const { useDiffContext } = useDiffViewContext();
     // performance optimization
     const useWidget = React.useMemo(() => reactivityStore.createStore(() => {
         const widgetSide = reactivityStore.ref(undefined);
         const widgetLineNumber = reactivityStore.ref(undefined);
         const setWidget = ({ side, lineNumber }) => {
+            const { renderWidgetLine } = useDiffContext.getReadonlyState();
+            if (typeof renderWidgetLine !== "function")
+                return;
             widgetSide.value = side;
             widgetLineNumber.value = lineNumber;
         };
         return { widgetSide, widgetLineNumber, setWidget };
-    }), []);
+    }), [useDiffContext]);
     const contextValue = React.useMemo(() => ({ useWidget }), [useWidget]);
     shim.useSyncExternalStore(diffFile.subscribe, diffFile.getUpdateCount);
     React.useEffect(() => {
@@ -2826,7 +4475,7 @@ const DiffUnifiedView = React.memo(({ diffFile }) => {
                             React__namespace.createElement(DiffUnifiedLine, { index: item.index, lineNumber: item.lineNumber, diffFile: diffFile }),
                             React__namespace.createElement(DiffUnifiedWidgetLine, { index: item.index, lineNumber: item.lineNumber, diffFile: diffFile }),
                             React__namespace.createElement(DiffUnifiedExtendLine, { index: item.index, lineNumber: item.lineNumber, diffFile: diffFile })))),
-                        React__namespace.createElement(DiffUnifiedLastHunkLine, { diffFile: diffFile })))))));
+                        React__namespace.createElement(DiffUnifiedHunkLine, { index: diffFile.unifiedLineLength, lineNumber: diffFile.unifiedLineLength, diffFile: diffFile })))))));
 });
 DiffUnifiedView.displayName = "DiffUnifiedView";
 
@@ -2939,7 +4588,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" },
+        React__namespace.createElement("div", { className: "diff-tailwindcss-wrapper", "data-component": "git-diff-view", "data-version": `${"0.0.6"}` },
             React__namespace.createElement("div", { className: "diff-style-root", style: {
                     // @ts-ignore
                     [diffFontSizeName]: diffViewFontSize + "px",
@@ -2947,7 +4596,7 @@ const _InternalDiffView = (props) => {
                 React__namespace.createElement("div", { id: `diff-root${diffFileId}`, className: "diff-view-wrapper" + (className ? ` ${className}` : ""), style: style }, diffViewMode === exports.DiffModeEnum.Split ? (React__namespace.createElement(DiffSplitView, { diffFile: diffFile })) : (React__namespace.createElement(DiffUnifiedView, { diffFile: diffFile })))))));
 };
 const InternalDiffView = React.memo(_InternalDiffView);
-const DiffView = (props) => {
+const DiffViewWithRef = (props, ref) => {
     const { registerHighlighter, autoDetectLang, data, diffFile: _diffFile, ...restProps } = props;
     const diffFile = React.useMemo(() => {
         if (_diffFile) {
@@ -2984,11 +4633,14 @@ const DiffView = (props) => {
         }
     }, [diffFile, _diffFile]);
     useUnmount(() => diffFile._destroy(), [diffFile]);
+    React.useImperativeHandle(ref, () => ({ getDiffFileInstance: () => diffFile }), [diffFile]);
     if (!diffFile)
         return null;
     return (React__namespace.createElement(InternalDiffView, { key: diffFile.getId(), ...restProps, diffFile: diffFile, diffViewFontSize: restProps.diffViewFontSize || 14 }));
 };
-const version = "0.0.3";
+const DiffView = React.forwardRef(DiffViewWithRef);
+DiffView.displayName = "DiffView";
+const version = "0.0.6";
 
 exports.DiffView = DiffView;
 exports.DiffViewContext = DiffViewContext;