@venos-inc/venos 0.1.14 → 0.1.15

package/etc/mcp-server/node_modules/diff/libesm/package.json

@@ -0,0 +1 @@
+{"type":"module","sideEffects":false}

package/etc/mcp-server/node_modules/diff/libesm/patch/apply.d.ts

@@ -0,0 +1,62 @@
+import type { StructuredPatch } from '../types.js';
+export interface ApplyPatchOptions {
+    /**
+     * Maximum Levenshtein distance (in lines deleted, added, or subtituted) between the context shown in a patch hunk and the lines found in the file.
+     * @default 0
+     */
+    fuzzFactor?: number;
+    /**
+     * If `true`, and if the file to be patched consistently uses different line endings to the patch (i.e. either the file always uses Unix line endings while the patch uses Windows ones, or vice versa), then `applyPatch` will behave as if the line endings in the patch were the same as those in the source file.
+     * (If `false`, the patch will usually fail to apply in such circumstances since lines deleted in the patch won't be considered to match those in the source file.)
+     * @default true
+     */
+    autoConvertLineEndings?: boolean;
+    /**
+     * Callback used to compare to given lines to determine if they should be considered equal when patching.
+     * Defaults to strict equality but may be overridden to provide fuzzier comparison.
+     * Should return false if the lines should be rejected.
+     */
+    compareLine?: (lineNumber: number, line: string, operation: string, patchContent: string) => boolean;
+}
+/**
+ * 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.
+ */
+export declare function applyPatch(source: string, patch: string | StructuredPatch | [StructuredPatch], options?: ApplyPatchOptions): string | false;
+export interface ApplyPatchesOptions extends ApplyPatchOptions {
+    loadFile: (index: StructuredPatch, callback: (err: any, data: string) => void) => void;
+    patched: (index: StructuredPatch, content: string | false, callback: (err: any) => void) => void;
+    complete: (err?: any) => void;
+}
+/**
+ * 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.
+ */
+export declare function applyPatches(uniDiff: string | StructuredPatch[], options: ApplyPatchesOptions): void;
+//# sourceMappingURL=apply.d.ts.map

package/etc/mcp-server/node_modules/diff/libesm/patch/apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.d.ts","sourceRoot":"","sources":["../../src/patch/apply.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,OAAO,CAAC;CACtG;AAOD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,GAAG,eAAe,GAAG,CAAC,eAAe,CAAC,EACnD,OAAO,GAAE,iBAAsB,GAC9B,MAAM,GAAG,KAAK,CAehB;AAyPD,MAAM,WAAW,mBAAoB,SAAQ,iBAAiB;IAC5D,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,KAAK,IAAI,CAAC;IACvF,OAAO,EAAE,CAAC,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,GAAG,KAAK,EAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,IAAI,KAAK,IAAI,CAAC;IACjG,QAAQ,EAAE,CAAC,GAAG,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE,EAAE,OAAO,EAAE,mBAAmB,GAAG,IAAI,CA0BpG"}

package/etc/mcp-server/node_modules/diff/libesm/patch/apply.js

@@ -0,0 +1,257 @@
+import { hasOnlyWinLineEndings, hasOnlyUnixLineEndings } from '../util/string.js';
+import { isWin, isUnix, unixToWin, winToUnix } from './line-endings.js';
+import { parsePatch } from './parse.js';
+import distanceIterator from '../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.
+ */
+export function applyPatch(source, patch, options = {}) {
+    let patches;
+    if (typeof patch === 'string') {
+        patches = 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.autoConvertLineEndings || options.autoConvertLineEndings == null) {
+        if (hasOnlyWinLineEndings(source) && isUnix(patch)) {
+            patch = unixToWin(patch);
+        }
+        else if (hasOnlyUnixLineEndings(source) && isWin(patch)) {
+            patch = winToUnix(patch);
+        }
+    }
+    // Apply the diff to the input
+    const lines = source.split('\n'), hunks = patch.hunks, compareLine = options.compareLine || ((lineNumber, line, operation, patchContent) => line === patchContent), fuzzFactor = options.fuzzFactor || 0;
+    let 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:
+    let prevLine = '', removeEOFNL = false, addEOFNL = false;
+    for (let i = 0; i < hunks[hunks.length - 1].lines.length; i++) {
+        const 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 = 0, lastContextLineMatched = true, patchedLines = [], patchedLinesLength = 0) {
+        let nConsecutiveOldContextLines = 0;
+        let nextContextLineMustMatch = false;
+        for (; hunkLinesI < hunkLines.length; hunkLinesI++) {
+            const 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,
+            oldLineLastI: toPos - 1
+        };
+    }
+    const resultLines = [];
+    // Search best fit offsets for each hunk based on the previous ones
+    let prevHunkOffset = 0;
+    for (let i = 0; i < hunks.length; i++) {
+        const hunk = hunks[i];
+        let hunkResult;
+        const maxLine = lines.length - hunk.oldLines + fuzzFactor;
+        let toPos;
+        for (let maxErrors = 0; maxErrors <= fuzzFactor; maxErrors++) {
+            toPos = hunk.oldStart + prevHunkOffset - 1;
+            const iterator = distanceIterator(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 (let i = minLine; i < toPos; i++) {
+            resultLines.push(lines[i]);
+        }
+        // Add the lines produced by applying the hunk:
+        for (let i = 0; i < hunkResult.patchedLines.length; i++) {
+            const line = hunkResult.patchedLines[i];
+            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 (let 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.
+ */
+export function applyPatches(uniDiff, options) {
+    const spDiff = typeof uniDiff === 'string' ? parsePatch(uniDiff) : uniDiff;
+    let currentIndex = 0;
+    function processIndex() {
+        const index = spDiff[currentIndex++];
+        if (!index) {
+            return options.complete();
+        }
+        options.loadFile(index, function (err, data) {
+            if (err) {
+                return options.complete(err);
+            }
+            const updatedContent = applyPatch(data, index, options);
+            options.patched(index, updatedContent, function (err) {
+                if (err) {
+                    return options.complete(err);
+                }
+                processIndex();
+            });
+        });
+    }
+    processIndex();
+}

package/etc/mcp-server/node_modules/diff/libesm/patch/create.d.ts

@@ -0,0 +1,122 @@
+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/etc/mcp-server/node_modules/diff/libesm/patch/create.d.ts.map

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