@yanglaofish/fishtools 0.5.2 → 0.6.0

package/node_modules/diff/libcjs/patch/apply.js

@@ -1,267 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyPatch = applyPatch;
-exports.applyPatches = applyPatches;
-var string_js_1 = require("../util/string.js");
-var line_endings_js_1 = require("./line-endings.js");
-var parse_js_1 = require("./parse.js");
-var distance_iterator_js_1 = require("../util/distance-iterator.js");
-/**
- * attempts to apply a unified diff patch.
- *
- * Hunks are applied first to last.
- * `applyPatch` first tries to apply the first hunk at the line number specified in the hunk header, and with all context lines matching exactly.
- * If that fails, it tries scanning backwards and forwards, one line at a time, to find a place to apply the hunk where the context lines match exactly.
- * If that still fails, and `fuzzFactor` is greater than zero, it increments the maximum number of mismatches (missing, extra, or changed context lines) that there can be between the hunk context and a region where we are trying to apply the patch such that the hunk will still be considered to match.
- * Regardless of `fuzzFactor`, lines to be deleted in the hunk *must* be present for a hunk to match, and the context lines *immediately* before and after an insertion must match exactly.
- *
- * Once a hunk is successfully fitted, the process begins again with the next hunk.
- * Regardless of `fuzzFactor`, later hunks must be applied later in the file than earlier hunks.
- *
- * If a hunk cannot be successfully fitted *anywhere* with fewer than `fuzzFactor` mismatches, `applyPatch` fails and returns `false`.
- *
- * If a hunk is successfully fitted but not at the line number specified by the hunk header, all subsequent hunks have their target line number adjusted accordingly.
- * (e.g. if the first hunk is applied 10 lines below where the hunk header said it should fit, `applyPatch` will *start* looking for somewhere to apply the second hunk 10 lines below where its hunk header says it goes.)
- *
- * If the patch was applied successfully, returns a string containing the patched text.
- * If the patch could not be applied (because some hunks in the patch couldn't be fitted to the text in `source`), `applyPatch` returns false.
- *
- * @param patch a string diff or the output from the `parsePatch` or `structuredPatch` methods.
- */
-function applyPatch(source, patch, options) {
-    if (options === void 0) { options = {}; }
-    var patches;
-    if (typeof patch === 'string') {
-        patches = (0, parse_js_1.parsePatch)(patch);
-    }
-    else if (Array.isArray(patch)) {
-        patches = patch;
-    }
-    else {
-        patches = [patch];
-    }
-    if (patches.length > 1) {
-        throw new Error('applyPatch only works with a single input.');
-    }
-    return applyStructuredPatch(source, patches[0], options);
-}
-function applyStructuredPatch(source, patch, options) {
-    if (options === void 0) { options = {}; }
-    if (options.autoConvertLineEndings || options.autoConvertLineEndings == null) {
-        if ((0, string_js_1.hasOnlyWinLineEndings)(source) && (0, line_endings_js_1.isUnix)(patch)) {
-            patch = (0, line_endings_js_1.unixToWin)(patch);
-        }
-        else if ((0, string_js_1.hasOnlyUnixLineEndings)(source) && (0, line_endings_js_1.isWin)(patch)) {
-            patch = (0, line_endings_js_1.winToUnix)(patch);
-        }
-    }
-    // Apply the diff to the input
-    var lines = source.split('\n'), hunks = patch.hunks, compareLine = options.compareLine || (function (lineNumber, line, operation, patchContent) { return line === patchContent; }), fuzzFactor = options.fuzzFactor || 0;
-    var minLine = 0;
-    if (fuzzFactor < 0 || !Number.isInteger(fuzzFactor)) {
-        throw new Error('fuzzFactor must be a non-negative integer');
-    }
-    // Special case for empty patch.
-    if (!hunks.length) {
-        return source;
-    }
-    // Before anything else, handle EOFNL insertion/removal. If the patch tells us to make a change
-    // to the EOFNL that is redundant/impossible - i.e. to remove a newline that's not there, or add a
-    // newline that already exists - then we either return false and fail to apply the patch (if
-    // fuzzFactor is 0) or simply ignore the problem and do nothing (if fuzzFactor is >0).
-    // If we do need to remove/add a newline at EOF, this will always be in the final hunk:
-    var prevLine = '', removeEOFNL = false, addEOFNL = false;
-    for (var i = 0; i < hunks[hunks.length - 1].lines.length; i++) {
-        var line = hunks[hunks.length - 1].lines[i];
-        if (line[0] == '\\') {
-            if (prevLine[0] == '+') {
-                removeEOFNL = true;
-            }
-            else if (prevLine[0] == '-') {
-                addEOFNL = true;
-            }
-        }
-        prevLine = line;
-    }
-    if (removeEOFNL) {
-        if (addEOFNL) {
-            // This means the final line gets changed but doesn't have a trailing newline in either the
-            // original or patched version. In that case, we do nothing if fuzzFactor > 0, and if
-            // fuzzFactor is 0, we simply validate that the source file has no trailing newline.
-            if (!fuzzFactor && lines[lines.length - 1] == '') {
-                return false;
-            }
-        }
-        else if (lines[lines.length - 1] == '') {
-            lines.pop();
-        }
-        else if (!fuzzFactor) {
-            return false;
-        }
-    }
-    else if (addEOFNL) {
-        if (lines[lines.length - 1] != '') {
-            lines.push('');
-        }
-        else if (!fuzzFactor) {
-            return false;
-        }
-    }
-    /**
-     * Checks if the hunk can be made to fit at the provided location with at most `maxErrors`
-     * insertions, substitutions, or deletions, while ensuring also that:
-     * - lines deleted in the hunk match exactly, and
-     * - wherever an insertion operation or block of insertion operations appears in the hunk, the
-     *   immediately preceding and following lines of context match exactly
-     *
-     * `toPos` should be set such that lines[toPos] is meant to match hunkLines[0].
-     *
-     * If the hunk can be applied, returns an object with properties `oldLineLastI` and
-     * `replacementLines`. Otherwise, returns null.
-     */
-    function applyHunk(hunkLines, toPos, maxErrors, hunkLinesI, lastContextLineMatched, patchedLines, patchedLinesLength) {
-        if (hunkLinesI === void 0) { hunkLinesI = 0; }
-        if (lastContextLineMatched === void 0) { lastContextLineMatched = true; }
-        if (patchedLines === void 0) { patchedLines = []; }
-        if (patchedLinesLength === void 0) { patchedLinesLength = 0; }
-        var nConsecutiveOldContextLines = 0;
-        var nextContextLineMustMatch = false;
-        for (; hunkLinesI < hunkLines.length; hunkLinesI++) {
-            var hunkLine = hunkLines[hunkLinesI], operation = (hunkLine.length > 0 ? hunkLine[0] : ' '), content = (hunkLine.length > 0 ? hunkLine.substr(1) : hunkLine);
-            if (operation === '-') {
-                if (compareLine(toPos + 1, lines[toPos], operation, content)) {
-                    toPos++;
-                    nConsecutiveOldContextLines = 0;
-                }
-                else {
-                    if (!maxErrors || lines[toPos] == null) {
-                        return null;
-                    }
-                    patchedLines[patchedLinesLength] = lines[toPos];
-                    return applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1);
-                }
-            }
-            if (operation === '+') {
-                if (!lastContextLineMatched) {
-                    return null;
-                }
-                patchedLines[patchedLinesLength] = content;
-                patchedLinesLength++;
-                nConsecutiveOldContextLines = 0;
-                nextContextLineMustMatch = true;
-            }
-            if (operation === ' ') {
-                nConsecutiveOldContextLines++;
-                patchedLines[patchedLinesLength] = lines[toPos];
-                if (compareLine(toPos + 1, lines[toPos], operation, content)) {
-                    patchedLinesLength++;
-                    lastContextLineMatched = true;
-                    nextContextLineMustMatch = false;
-                    toPos++;
-                }
-                else {
-                    if (nextContextLineMustMatch || !maxErrors) {
-                        return null;
-                    }
-                    // Consider 3 possibilities in sequence:
-                    // 1. lines contains a *substitution* not included in the patch context, or
-                    // 2. lines contains an *insertion* not included in the patch context, or
-                    // 3. lines contains a *deletion* not included in the patch context
-                    // The first two options are of course only possible if the line from lines is non-null -
-                    // i.e. only option 3 is possible if we've overrun the end of the old file.
-                    return (lines[toPos] && (applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength + 1) || applyHunk(hunkLines, toPos + 1, maxErrors - 1, hunkLinesI, false, patchedLines, patchedLinesLength + 1)) || applyHunk(hunkLines, toPos, maxErrors - 1, hunkLinesI + 1, false, patchedLines, patchedLinesLength));
-                }
-            }
-        }
-        // Before returning, trim any unmodified context lines off the end of patchedLines and reduce
-        // toPos (and thus oldLineLastI) accordingly. This allows later hunks to be applied to a region
-        // that starts in this hunk's trailing context.
-        patchedLinesLength -= nConsecutiveOldContextLines;
-        toPos -= nConsecutiveOldContextLines;
-        patchedLines.length = patchedLinesLength;
-        return {
-            patchedLines: patchedLines,
-            oldLineLastI: toPos - 1
-        };
-    }
-    var resultLines = [];
-    // Search best fit offsets for each hunk based on the previous ones
-    var prevHunkOffset = 0;
-    for (var i = 0; i < hunks.length; i++) {
-        var hunk = hunks[i];
-        var hunkResult = void 0;
-        var maxLine = lines.length - hunk.oldLines + fuzzFactor;
-        var toPos = void 0;
-        for (var maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {
-            toPos = hunk.oldStart + prevHunkOffset - 1;
-            var iterator = (0, distance_iterator_js_1.default)(toPos, minLine, maxLine);
-            for (; toPos !== undefined; toPos = iterator()) {
-                hunkResult = applyHunk(hunk.lines, toPos, maxErrors);
-                if (hunkResult) {
-                    break;
-                }
-            }
-            if (hunkResult) {
-                break;
-            }
-        }
-        if (!hunkResult) {
-            return false;
-        }
-        // Copy everything from the end of where we applied the last hunk to the start of this hunk
-        for (var i_1 = minLine; i_1 < toPos; i_1++) {
-            resultLines.push(lines[i_1]);
-        }
-        // Add the lines produced by applying the hunk:
-        for (var i_2 = 0; i_2 < hunkResult.patchedLines.length; i_2++) {
-            var line = hunkResult.patchedLines[i_2];
-            resultLines.push(line);
-        }
-        // Set lower text limit to end of the current hunk, so next ones don't try
-        // to fit over already patched text
-        minLine = hunkResult.oldLineLastI + 1;
-        // Note the offset between where the patch said the hunk should've applied and where we
-        // applied it, so we can adjust future hunks accordingly:
-        prevHunkOffset = toPos + 1 - hunk.oldStart;
-    }
-    // Copy over the rest of the lines from the old text
-    for (var i = minLine; i < lines.length; i++) {
-        resultLines.push(lines[i]);
-    }
-    return resultLines.join('\n');
-}
-/**
- * applies one or more patches.
- *
- * `patch` may be either an array of structured patch objects, or a string representing a patch in unified diff format (which may patch one or more files).
- *
- * This method will iterate over the contents of the patch and apply to data provided through callbacks. The general flow for each patch index is:
- *
- * - `options.loadFile(index, callback)` is called. The caller should then load the contents of the file and then pass that to the `callback(err, data)` callback. Passing an `err` will terminate further patch execution.
- * - `options.patched(index, content, callback)` is called once the patch has been applied. `content` will be the return value from `applyPatch`. When it's ready, the caller should call `callback(err)` callback. Passing an `err` will terminate further patch execution.
- *
- * Once all patches have been applied or an error occurs, the `options.complete(err)` callback is made.
- */
-function applyPatches(uniDiff, options) {
-    var spDiff = typeof uniDiff === 'string' ? (0, parse_js_1.parsePatch)(uniDiff) : uniDiff;
-    var currentIndex = 0;
-    function processIndex() {
-        var index = spDiff[currentIndex++];
-        if (!index) {
-            return options.complete();
-        }
-        options.loadFile(index, function (err, data) {
-            if (err) {
-                return options.complete(err);
-            }
-            var updatedContent = applyPatch(data, index, options);
-            options.patched(index, updatedContent, function (err) {
-                if (err) {
-                    return options.complete(err);
-                }
-                processIndex();
-            });
-        });
-    }
-    processIndex();
-}

package/node_modules/diff/libcjs/patch/create.d.ts

@@ -1,122 +0,0 @@
-import type { StructuredPatch, DiffLinesOptionsAbortable, DiffLinesOptionsNonabortable, AbortableDiffOptions } from '../types.js';
-type StructuredPatchCallbackAbortable = (patch: StructuredPatch | undefined) => void;
-type StructuredPatchCallbackNonabortable = (patch: StructuredPatch) => void;
-export interface HeaderOptions {
-    includeIndex: boolean;
-    includeUnderline: boolean;
-    includeFileHeaders: boolean;
-}
-export declare const INCLUDE_HEADERS: {
-    includeIndex: boolean;
-    includeUnderline: boolean;
-    includeFileHeaders: boolean;
-};
-export declare const FILE_HEADERS_ONLY: {
-    includeIndex: boolean;
-    includeUnderline: boolean;
-    includeFileHeaders: boolean;
-};
-export declare const OMIT_HEADERS: {
-    includeIndex: boolean;
-    includeUnderline: boolean;
-    includeFileHeaders: boolean;
-};
-interface _StructuredPatchOptionsAbortable extends Pick<DiffLinesOptionsAbortable, 'ignoreWhitespace' | 'stripTrailingCr'> {
-    /**
-     * describes how many lines of context should be included.
-     * You can set this to `Number.MAX_SAFE_INTEGER` or `Infinity` to include the entire file content in one hunk.
-     * @default 4
-     */
-    context?: number;
-    callback?: StructuredPatchCallbackAbortable;
-}
-export type StructuredPatchOptionsAbortable = _StructuredPatchOptionsAbortable & AbortableDiffOptions;
-export interface StructuredPatchOptionsNonabortable extends Pick<DiffLinesOptionsNonabortable, 'ignoreWhitespace' | 'stripTrailingCr'> {
-    context?: number;
-    callback?: StructuredPatchCallbackNonabortable;
-}
-interface StructuredPatchCallbackOptionAbortable {
-    /**
-     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
-     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
-     */
-    callback: StructuredPatchCallbackAbortable;
-}
-interface StructuredPatchCallbackOptionNonabortable {
-    /**
-     * If provided, the diff will be computed in async mode to avoid blocking the event loop while the diff is calculated.
-     * The value of the `callback` option should be a function and will be passed the computed diff or patch as its first argument.
-     */
-    callback: StructuredPatchCallbackNonabortable;
-}
-/**
- * returns an object with an array of hunk objects.
- *
- * This method is similar to createTwoFilesPatch, but returns a data structure suitable for further processing.
- * @param oldFileName String to be output in the filename section of the patch for the removals
- * @param newFileName String to be output in the filename section of the patch for the additions
- * @param oldStr Original string value
- * @param newStr New string value
- * @param oldHeader Optional additional information to include in the old file header.
- * @param newHeader Optional additional information to include in the new file header.
- */
-export declare function structuredPatch(oldFileName: string, newFileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: StructuredPatchCallbackNonabortable): undefined;
-export declare function structuredPatch(oldFileName: string, newFileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: StructuredPatchOptionsAbortable & StructuredPatchCallbackOptionAbortable): undefined;
-export declare function structuredPatch(oldFileName: string, newFileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: StructuredPatchOptionsNonabortable & StructuredPatchCallbackOptionNonabortable): undefined;
-export declare function structuredPatch(oldFileName: string, newFileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: StructuredPatchOptionsAbortable): StructuredPatch | undefined;
-export declare function structuredPatch(oldFileName: string, newFileName: string, oldStr: string, newStr: string, oldHeader?: string, newHeader?: string, options?: StructuredPatchOptionsNonabortable): StructuredPatch;
-/**
- * creates a unified diff patch.
- * @param patch either a single structured patch object (as returned by `structuredPatch`) or an array of them (as returned by `parsePatch`)
- */
-export declare function formatPatch(patch: StructuredPatch | StructuredPatch[], headerOptions?: HeaderOptions): string;
-type CreatePatchCallbackAbortable = (patch: string | undefined) => void;
-type CreatePatchCallbackNonabortable = (patch: string) => void;
-interface _CreatePatchOptionsAbortable extends Pick<DiffLinesOptionsAbortable, 'ignoreWhitespace' | 'stripTrailingCr'> {
-    context?: number;
-    callback?: CreatePatchCallbackAbortable;
-    headerOptions?: HeaderOptions;
-}
-export type CreatePatchOptionsAbortable = _CreatePatchOptionsAbortable & AbortableDiffOptions;
-export interface CreatePatchOptionsNonabortable extends Pick<DiffLinesOptionsNonabortable, 'ignoreWhitespace' | 'stripTrailingCr'> {
-    context?: number;
-    callback?: CreatePatchCallbackNonabortable;
-    headerOptions?: HeaderOptions;
-}
-interface CreatePatchCallbackOptionAbortable {
-    callback: CreatePatchCallbackAbortable;
-}
-interface CreatePatchCallbackOptionNonabortable {
-    callback: CreatePatchCallbackNonabortable;
-}
-/**
- * creates a unified diff patch by first computing a diff with `diffLines` and then serializing it to unified diff format.
- * @param oldFileName String to be output in the filename section of the patch for the removals
- * @param newFileName String to be output in the filename section of the patch for the additions
- * @param oldStr Original string value
- * @param newStr New string value
- * @param oldHeader Optional additional information to include in the old file header.
- * @param newHeader Optional additional information to include in the new file header.
- */
-export declare function createTwoFilesPatch(oldFileName: string, newFileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: CreatePatchCallbackNonabortable): undefined;
-export declare function createTwoFilesPatch(oldFileName: string, newFileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: CreatePatchOptionsAbortable & CreatePatchCallbackOptionAbortable): undefined;
-export declare function createTwoFilesPatch(oldFileName: string, newFileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: CreatePatchOptionsNonabortable & CreatePatchCallbackOptionNonabortable): undefined;
-export declare function createTwoFilesPatch(oldFileName: string, newFileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: CreatePatchOptionsAbortable): string | undefined;
-export declare function createTwoFilesPatch(oldFileName: string, newFileName: string, oldStr: string, newStr: string, oldHeader?: string, newHeader?: string, options?: CreatePatchOptionsNonabortable): string;
-/**
- * creates a unified diff patch.
- *
- * Just like createTwoFilesPatch, but with oldFileName being equal to newFileName.
- * @param fileName String to be output in the filename section of the patch
- * @param oldStr Original string value
- * @param newStr New string value
- * @param oldHeader Optional additional information to include in the old file header.
- * @param newHeader Optional additional information to include in the new file header.
- */
-export declare function createPatch(fileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: CreatePatchCallbackNonabortable): undefined;
-export declare function createPatch(fileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: CreatePatchOptionsAbortable & CreatePatchCallbackOptionAbortable): undefined;
-export declare function createPatch(fileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: CreatePatchOptionsNonabortable & CreatePatchCallbackOptionNonabortable): undefined;
-export declare function createPatch(fileName: string, oldStr: string, newStr: string, oldHeader: string | undefined, newHeader: string | undefined, options: CreatePatchOptionsAbortable): string | undefined;
-export declare function createPatch(fileName: string, oldStr: string, newStr: string, oldHeader?: string, newHeader?: string, options?: CreatePatchOptionsNonabortable): string;
-export {};
-//# sourceMappingURL=create.d.ts.map

package/node_modules/diff/libcjs/patch/create.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../src/patch/create.ts"],"names":[],"mappings":"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"}

package/node_modules/diff/libcjs/patch/create.js

@@ -1,251 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.OMIT_HEADERS = exports.FILE_HEADERS_ONLY = exports.INCLUDE_HEADERS = void 0;
-exports.structuredPatch = structuredPatch;
-exports.formatPatch = formatPatch;
-exports.createTwoFilesPatch = createTwoFilesPatch;
-exports.createPatch = createPatch;
-var line_js_1 = require("../diff/line.js");
-exports.INCLUDE_HEADERS = {
-    includeIndex: true,
-    includeUnderline: true,
-    includeFileHeaders: true
-};
-exports.FILE_HEADERS_ONLY = {
-    includeIndex: false,
-    includeUnderline: false,
-    includeFileHeaders: true
-};
-exports.OMIT_HEADERS = {
-    includeIndex: false,
-    includeUnderline: false,
-    includeFileHeaders: false
-};
-function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-    var optionsObj;
-    if (!options) {
-        optionsObj = {};
-    }
-    else if (typeof options === 'function') {
-        optionsObj = { callback: options };
-    }
-    else {
-        optionsObj = options;
-    }
-    if (typeof optionsObj.context === 'undefined') {
-        optionsObj.context = 4;
-    }
-    // We copy this into its own variable to placate TypeScript, which thinks
-    // optionsObj.context might be undefined in the callbacks below.
-    var context = optionsObj.context;
-    // @ts-expect-error (runtime check for something that is correctly a static type error)
-    if (optionsObj.newlineIsToken) {
-        throw new Error('newlineIsToken may not be used with patch-generation functions, only with diffing functions');
-    }
-    if (!optionsObj.callback) {
-        return diffLinesResultToPatch((0, line_js_1.diffLines)(oldStr, newStr, optionsObj));
-    }
-    else {
-        var callback_1 = optionsObj.callback;
-        (0, line_js_1.diffLines)(oldStr, newStr, __assign(__assign({}, optionsObj), { callback: function (diff) {
-                var patch = diffLinesResultToPatch(diff);
-                // TypeScript is unhappy without the cast because it does not understand that `patch` may
-                // be undefined here only if `callback` is StructuredPatchCallbackAbortable:
-                callback_1(patch);
-            } }));
-    }
-    function diffLinesResultToPatch(diff) {
-        // STEP 1: Build up the patch with no "" lines and with the arrays
-        //         of lines containing trailing newline characters. We'll tidy up later...
-        if (!diff) {
-            return;
-        }
-        diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier
-        function contextLines(lines) {
-            return lines.map(function (entry) { return ' ' + entry; });
-        }
-        var hunks = [];
-        var oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
-        for (var i = 0; i < diff.length; i++) {
-            var current = diff[i], lines = current.lines || splitLines(current.value);
-            current.lines = lines;
-            if (current.added || current.removed) {
-                // If we have previous context, start with that
-                if (!oldRangeStart) {
-                    var prev = diff[i - 1];
-                    oldRangeStart = oldLine;
-                    newRangeStart = newLine;
-                    if (prev) {
-                        curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
-                        oldRangeStart -= curRange.length;
-                        newRangeStart -= curRange.length;
-                    }
-                }
-                // Output our changes
-                for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) {
-                    var line = lines_1[_i];
-                    curRange.push((current.added ? '+' : '-') + line);
-                }
-                // Track the updated file position
-                if (current.added) {
-                    newLine += lines.length;
-                }
-                else {
-                    oldLine += lines.length;
-                }
-            }
-            else {
-                // Identical context lines. Track line changes
-                if (oldRangeStart) {
-                    // Close out any changes that have been output (or join overlapping)
-                    if (lines.length <= context * 2 && i < diff.length - 2) {
-                        // Overlapping
-                        for (var _a = 0, _b = contextLines(lines); _a < _b.length; _a++) {
-                            var line = _b[_a];
-                            curRange.push(line);
-                        }
-                    }
-                    else {
-                        // end the range and output
-                        var contextSize = Math.min(lines.length, context);
-                        for (var _c = 0, _d = contextLines(lines.slice(0, contextSize)); _c < _d.length; _c++) {
-                            var line = _d[_c];
-                            curRange.push(line);
-                        }
-                        var hunk = {
-                            oldStart: oldRangeStart,
-                            oldLines: (oldLine - oldRangeStart + contextSize),
-                            newStart: newRangeStart,
-                            newLines: (newLine - newRangeStart + contextSize),
-                            lines: curRange
-                        };
-                        hunks.push(hunk);
-                        oldRangeStart = 0;
-                        newRangeStart = 0;
-                        curRange = [];
-                    }
-                }
-                oldLine += lines.length;
-                newLine += lines.length;
-            }
-        }
-        // Step 2: eliminate the trailing `\n` from each line of each hunk, and, where needed, add
-        //         "".
-        for (var _e = 0, hunks_1 = hunks; _e < hunks_1.length; _e++) {
-            var hunk = hunks_1[_e];
-            for (var i = 0; i < hunk.lines.length; i++) {
-                if (hunk.lines[i].endsWith('\n')) {
-                    hunk.lines[i] = hunk.lines[i].slice(0, -1);
-                }
-                else {
-                    hunk.lines.splice(i + 1, 0, '\');
-                    i++; // Skip the line we just added, then continue iterating
-                }
-            }
-        }
-        return {
-            oldFileName: oldFileName, newFileName: newFileName,
-            oldHeader: oldHeader, newHeader: newHeader,
-            hunks: hunks
-        };
-    }
-}
-/**
- * creates a unified diff patch.
- * @param patch either a single structured patch object (as returned by `structuredPatch`) or an array of them (as returned by `parsePatch`)
- */
-function formatPatch(patch, headerOptions) {
-    if (!headerOptions) {
-        headerOptions = exports.INCLUDE_HEADERS;
-    }
-    if (Array.isArray(patch)) {
-        if (patch.length > 1 && !headerOptions.includeFileHeaders) {
-            throw new Error('Cannot omit file headers on a multi-file patch. '
-                + '(The result would be unparseable; how would a tool trying to apply '
-                + 'the patch know which changes are to which file?)');
-        }
-        return patch.map(function (p) { return formatPatch(p, headerOptions); }).join('\n');
-    }
-    var ret = [];
-    if (headerOptions.includeIndex && patch.oldFileName == patch.newFileName) {
-        ret.push('Index: ' + patch.oldFileName);
-    }
-    if (headerOptions.includeUnderline) {
-        ret.push('===================================================================');
-    }
-    if (headerOptions.includeFileHeaders) {
-        ret.push('--- ' + patch.oldFileName + (typeof patch.oldHeader === 'undefined' ? '' : '\t' + patch.oldHeader));
-        ret.push('+++ ' + patch.newFileName + (typeof patch.newHeader === 'undefined' ? '' : '\t' + patch.newHeader));
-    }
-    for (var i = 0; i < patch.hunks.length; i++) {
-        var hunk = patch.hunks[i];
-        // Unified Diff Format quirk: If the chunk size is 0,
-        // the first number is one lower than one would expect.
-        // https://www.artima.com/weblogs/viewpost.jsp?thread=164293
-        if (hunk.oldLines === 0) {
-            hunk.oldStart -= 1;
-        }
-        if (hunk.newLines === 0) {
-            hunk.newStart -= 1;
-        }
-        ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines
-            + ' +' + hunk.newStart + ',' + hunk.newLines
-            + ' @@');
-        for (var _i = 0, _a = hunk.lines; _i < _a.length; _i++) {
-            var line = _a[_i];
-            ret.push(line);
-        }
-    }
-    return ret.join('\n') + '\n';
-}
-function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
-    if (typeof options === 'function') {
-        options = { callback: options };
-    }
-    if (!(options === null || options === void 0 ? void 0 : options.callback)) {
-        var patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
-        if (!patchObj) {
-            return;
-        }
-        return formatPatch(patchObj, options === null || options === void 0 ? void 0 : options.headerOptions);
-    }
-    else {
-        var callback_2 = options.callback;
-        structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, __assign(__assign({}, options), { callback: function (patchObj) {
-                if (!patchObj) {
-                    callback_2(undefined);
-                }
-                else {
-                    callback_2(formatPatch(patchObj, options.headerOptions));
-                }
-            } }));
-    }
-}
-function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
-    return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);
-}
-/**
- * Split `text` into an array of lines, including the trailing newline character (where present)
- */
-function splitLines(text) {
-    var hasTrailingNl = text.endsWith('\n');
-    var result = text.split('\n').map(function (line) { return line + '\n'; });
-    if (hasTrailingNl) {
-        result.pop();
-    }
-    else {
-        result.push(result.pop().slice(0, -1));
-    }
-    return result;
-}

package/node_modules/diff/libcjs/patch/line-endings.d.ts

@@ -1,17 +0,0 @@
-import type { StructuredPatch } from '../types.js';
-export declare function unixToWin(patch: StructuredPatch): StructuredPatch;
-export declare function unixToWin(patches: StructuredPatch[]): StructuredPatch[];
-export declare function unixToWin(patch: StructuredPatch | StructuredPatch[]): StructuredPatch | StructuredPatch[];
-export declare function winToUnix(patch: StructuredPatch): StructuredPatch;
-export declare function winToUnix(patches: StructuredPatch[]): StructuredPatch[];
-export declare function winToUnix(patch: StructuredPatch | StructuredPatch[]): StructuredPatch | StructuredPatch[];
-/**
- * Returns true if the patch consistently uses Unix line endings (or only involves one line and has
- * no line endings).
- */
-export declare function isUnix(patch: StructuredPatch | StructuredPatch[]): boolean;
-/**
- * Returns true if the patch uses Windows line endings and only Windows line endings.
- */
-export declare function isWin(patch: StructuredPatch | StructuredPatch[]): boolean;
-//# sourceMappingURL=line-endings.d.ts.map