@venos-inc/venos 0.1.14 → 0.1.15

package/etc/mcp-server/node_modules/diff/libcjs/patch/line-endings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"line-endings.d.ts","sourceRoot":"","sources":["../../src/patch/line-endings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,wBAAgB,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,CAAC;AACnE,wBAAgB,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAAC;AACzE,wBAAgB,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,EAAE,GAAG,eAAe,GAAG,eAAe,EAAE,CAAC;AA0B3G,wBAAgB,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,CAAC;AACnE,wBAAgB,SAAS,CAAC,OAAO,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAAC;AACzE,wBAAgB,SAAS,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,EAAE,GAAG,eAAe,GAAG,eAAe,EAAE,CAAC;AAgB3G;;;GAGG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,EAAE,GAAG,OAAO,CAS1E;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,KAAK,EAAE,eAAe,GAAG,eAAe,EAAE,GAAG,OAAO,CAUzE"}

package/etc/mcp-server/node_modules/diff/libcjs/patch/line-endings.js

@@ -0,0 +1,61 @@
+"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.unixToWin = unixToWin;
+exports.winToUnix = winToUnix;
+exports.isUnix = isUnix;
+exports.isWin = isWin;
+function unixToWin(patch) {
+    if (Array.isArray(patch)) {
+        // It would be cleaner if instead of the line below we could just write
+        //     return patch.map(unixToWin)
+        // but mysteriously TypeScript (v5.7.3 at the time of writing) does not like this and it will
+        // refuse to compile, thinking that unixToWin could then return StructuredPatch[][] and the
+        // result would be incompatible with the overload signatures.
+        // See bug report at https://github.com/microsoft/TypeScript/issues/61398.
+        return patch.map(function (p) { return unixToWin(p); });
+    }
+    return __assign(__assign({}, patch), { hunks: patch.hunks.map(function (hunk) { return (__assign(__assign({}, hunk), { lines: hunk.lines.map(function (line, i) {
+                var _a;
+                return (line.startsWith('\\') || line.endsWith('\r') || ((_a = hunk.lines[i + 1]) === null || _a === void 0 ? void 0 : _a.startsWith('\\')))
+                    ? line
+                    : line + '\r';
+            }) })); }) });
+}
+function winToUnix(patch) {
+    if (Array.isArray(patch)) {
+        // (See comment above equivalent line in unixToWin)
+        return patch.map(function (p) { return winToUnix(p); });
+    }
+    return __assign(__assign({}, patch), { hunks: patch.hunks.map(function (hunk) { return (__assign(__assign({}, hunk), { lines: hunk.lines.map(function (line) { return line.endsWith('\r') ? line.substring(0, line.length - 1) : line; }) })); }) });
+}
+/**
+ * Returns true if the patch consistently uses Unix line endings (or only involves one line and has
+ * no line endings).
+ */
+function isUnix(patch) {
+    if (!Array.isArray(patch)) {
+        patch = [patch];
+    }
+    return !patch.some(function (index) { return index.hunks.some(function (hunk) { return hunk.lines.some(function (line) { return !line.startsWith('\\') && line.endsWith('\r'); }); }); });
+}
+/**
+ * Returns true if the patch uses Windows line endings and only Windows line endings.
+ */
+function isWin(patch) {
+    if (!Array.isArray(patch)) {
+        patch = [patch];
+    }
+    return patch.some(function (index) { return index.hunks.some(function (hunk) { return hunk.lines.some(function (line) { return line.endsWith('\r'); }); }); })
+        && patch.every(function (index) { return index.hunks.every(function (hunk) { return hunk.lines.every(function (line, i) { var _a; return line.startsWith('\\') || line.endsWith('\r') || ((_a = hunk.lines[i + 1]) === null || _a === void 0 ? void 0 : _a.startsWith('\\')); }); }); });
+}

package/etc/mcp-server/node_modules/diff/libcjs/patch/parse.d.ts

@@ -0,0 +1,8 @@
+import type { StructuredPatch } from '../types.js';
+/**
+ * Parses a patch into structured data, in the same structure returned by `structuredPatch`.
+ *
+ * @return a JSON object representation of the a patch, suitable for use with the `applyPatch` method.
+ */
+export declare function parsePatch(uniDiff: string): StructuredPatch[];
+//# sourceMappingURL=parse.d.ts.map

package/etc/mcp-server/node_modules/diff/libcjs/patch/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/patch/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,eAAe,EAAE,CAmK7D"}

package/etc/mcp-server/node_modules/diff/libcjs/patch/parse.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parsePatch = parsePatch;
+/**
+ * Parses a patch into structured data, in the same structure returned by `structuredPatch`.
+ *
+ * @return a JSON object representation of the a patch, suitable for use with the `applyPatch` method.
+ */
+function parsePatch(uniDiff) {
+    var diffstr = uniDiff.split(/\n/), list = [];
+    var i = 0;
+    function parseIndex() {
+        var index = {};
+        list.push(index);
+        // Parse diff metadata
+        while (i < diffstr.length) {
+            var line = diffstr[i];
+            // File header found, end parsing diff metadata
+            if ((/^(---|\+\+\+|@@)\s/).test(line)) {
+                break;
+            }
+            // Try to parse the line as a diff header, like
+            //     Index: README.md
+            // or
+            //     diff -r 9117c6561b0b -r 273ce12ad8f1 .hgignore
+            // or
+            //     Index: something with multiple words
+            // and extract the filename (or whatever else is used as an index name)
+            // from the end (i.e. 'README.md', '.hgignore', or
+            // 'something with multiple words' in the examples above).
+            //
+            // TODO: It seems awkward that we indiscriminately trim off trailing
+            //       whitespace here. Theoretically, couldn't that be meaningful -
+            //       e.g. if the patch represents a diff of a file whose name ends
+            //       with a space? Seems wrong to nuke it.
+            //       But this behaviour has been around since v2.2.1 in 2015, so if
+            //       it's going to change, it should be done cautiously and in a new
+            //       major release, for backwards-compat reasons.
+            //       -- ExplodingCabbage
+            var headerMatch = (/^(?:Index:|diff(?: -r \w+)+)\s+/).exec(line);
+            if (headerMatch) {
+                index.index = line.substring(headerMatch[0].length).trim();
+            }
+            i++;
+        }
+        // Parse file headers if they are defined. Unified diff requires them, but
+        // there's no technical issues to have an isolated hunk without file header
+        parseFileHeader(index);
+        parseFileHeader(index);
+        // Parse hunks
+        index.hunks = [];
+        while (i < diffstr.length) {
+            var line = diffstr[i];
+            if ((/^(Index:\s|diff\s|---\s|\+\+\+\s|===================================================================)/).test(line)) {
+                break;
+            }
+            else if ((/^@@/).test(line)) {
+                index.hunks.push(parseHunk());
+            }
+            else if (line) {
+                throw new Error('Unknown line ' + (i + 1) + ' ' + JSON.stringify(line));
+            }
+            else {
+                i++;
+            }
+        }
+    }
+    // Parses the --- and +++ headers, if none are found, no lines
+    // are consumed.
+    function parseFileHeader(index) {
+        var fileHeaderMatch = (/^(---|\+\+\+)\s+/).exec(diffstr[i]);
+        if (fileHeaderMatch) {
+            var prefix = fileHeaderMatch[1], data = diffstr[i].substring(3).trim().split('\t', 2), header = (data[1] || '').trim();
+            var fileName = data[0].replace(/\\\\/g, '\\');
+            if (fileName.startsWith('"') && fileName.endsWith('"')) {
+                fileName = fileName.substr(1, fileName.length - 2);
+            }
+            if (prefix === '---') {
+                index.oldFileName = fileName;
+                index.oldHeader = header;
+            }
+            else {
+                index.newFileName = fileName;
+                index.newHeader = header;
+            }
+            i++;
+        }
+    }
+    // Parses a hunk
+    // This assumes that we are at the start of a hunk.
+    function parseHunk() {
+        var _a;
+        var chunkHeaderIndex = i, chunkHeaderLine = diffstr[i++], chunkHeader = chunkHeaderLine.split(/@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+        var hunk = {
+            oldStart: +chunkHeader[1],
+            oldLines: typeof chunkHeader[2] === 'undefined' ? 1 : +chunkHeader[2],
+            newStart: +chunkHeader[3],
+            newLines: typeof chunkHeader[4] === 'undefined' ? 1 : +chunkHeader[4],
+            lines: []
+        };
+        // 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;
+        }
+        var addCount = 0, removeCount = 0;
+        for (; i < diffstr.length && (removeCount < hunk.oldLines || addCount < hunk.newLines || ((_a = diffstr[i]) === null || _a === void 0 ? void 0 : _a.startsWith('\\'))); i++) {
+            var operation = (diffstr[i].length == 0 && i != (diffstr.length - 1)) ? ' ' : diffstr[i][0];
+            if (operation === '+' || operation === '-' || operation === ' ' || operation === '\\') {
+                hunk.lines.push(diffstr[i]);
+                if (operation === '+') {
+                    addCount++;
+                }
+                else if (operation === '-') {
+                    removeCount++;
+                }
+                else if (operation === ' ') {
+                    addCount++;
+                    removeCount++;
+                }
+            }
+            else {
+                throw new Error("Hunk at line ".concat(chunkHeaderIndex + 1, " contained invalid line ").concat(diffstr[i]));
+            }
+        }
+        // Handle the empty block count case
+        if (!addCount && hunk.newLines === 1) {
+            hunk.newLines = 0;
+        }
+        if (!removeCount && hunk.oldLines === 1) {
+            hunk.oldLines = 0;
+        }
+        // Perform sanity checking
+        if (addCount !== hunk.newLines) {
+            throw new Error('Added line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
+        }
+        if (removeCount !== hunk.oldLines) {
+            throw new Error('Removed line count did not match for hunk at line ' + (chunkHeaderIndex + 1));
+        }
+        return hunk;
+    }
+    while (i < diffstr.length) {
+        parseIndex();
+    }
+    return list;
+}

package/etc/mcp-server/node_modules/diff/libcjs/patch/reverse.d.ts

@@ -0,0 +1,9 @@
+import type { StructuredPatch } from '../types.js';
+/**
+ * @param patch either a single structured patch object (as returned by `structuredPatch`) or an array of them (as returned by `parsePatch`).
+ * @returns a new structured patch which when applied will undo the original `patch`.
+ */
+export declare function reversePatch(structuredPatch: StructuredPatch): StructuredPatch;
+export declare function reversePatch(structuredPatch: StructuredPatch[]): StructuredPatch[];
+export declare function reversePatch(structuredPatch: StructuredPatch | StructuredPatch[]): StructuredPatch | StructuredPatch[];
+//# sourceMappingURL=reverse.d.ts.map

package/etc/mcp-server/node_modules/diff/libcjs/patch/reverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse.d.ts","sourceRoot":"","sources":["../../src/patch/reverse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD;;;GAGG;AACH,wBAAgB,YAAY,CAAC,eAAe,EAAE,eAAe,GAAG,eAAe,CAAC;AAChF,wBAAgB,YAAY,CAAC,eAAe,EAAE,eAAe,EAAE,GAAG,eAAe,EAAE,CAAC;AACpF,wBAAgB,YAAY,CAAC,eAAe,EAAE,eAAe,GAAG,eAAe,EAAE,GAAG,eAAe,GAAG,eAAe,EAAE,CAAC"}

package/etc/mcp-server/node_modules/diff/libcjs/patch/reverse.js

@@ -0,0 +1,37 @@
+"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.reversePatch = reversePatch;
+function reversePatch(structuredPatch) {
+    if (Array.isArray(structuredPatch)) {
+        // (See comment in unixToWin for why we need the pointless-looking anonymous function here)
+        return structuredPatch.map(function (patch) { return reversePatch(patch); }).reverse();
+    }
+    return __assign(__assign({}, structuredPatch), { oldFileName: structuredPatch.newFileName, oldHeader: structuredPatch.newHeader, newFileName: structuredPatch.oldFileName, newHeader: structuredPatch.oldHeader, hunks: structuredPatch.hunks.map(function (hunk) {
+            return {
+                oldLines: hunk.newLines,
+                oldStart: hunk.newStart,
+                newLines: hunk.oldLines,
+                newStart: hunk.oldStart,
+                lines: hunk.lines.map(function (l) {
+                    if (l.startsWith('-')) {
+                        return "+".concat(l.slice(1));
+                    }
+                    if (l.startsWith('+')) {
+                        return "-".concat(l.slice(1));
+                    }
+                    return l;
+                })
+            };
+        }) });
+}

package/etc/mcp-server/node_modules/diff/libcjs/types.d.ts

@@ -0,0 +1,213 @@
+export interface ChangeObject<ValueT> {
+    /**
+     * The concatenated content of all the tokens represented by this change object - i.e. generally the text that is either added, deleted, or common, as a single string.
+     * In cases where tokens are considered common but are non-identical (e.g. because an option like `ignoreCase` or a custom `comparator` was used), the value from the *new* string will be provided here.
+     */
+    value: ValueT;
+    /**
+     * true if the value was inserted into the new string, otherwise false
+     */
+    added: boolean;
+    /**
+     * true if the value was removed from the old string, otherwise false
+     */
+    removed: boolean;
+    /**
+     * How many tokens (e.g. chars for `diffChars`, lines for `diffLines`) the value in the change object consists of
+     */
+    count: number;
+}
+export type Change = ChangeObject<string>;
+export type ArrayChange<T> = ChangeObject<T[]>;
+export interface CommonDiffOptions {
+    /**
+     * If `true`, the array of change objects returned will contain one change object per token (e.g. one per line if calling `diffLines`), instead of runs of consecutive tokens that are all added / all removed / all conserved being combined into a single change object.
+     */
+    oneChangePerToken?: boolean;
+}
+export interface TimeoutOption {
+    /**
+     * A number of milliseconds after which the diffing algorithm will abort and return `undefined`.
+     * Supported by the same functions as `maxEditLength`.
+     */
+    timeout: number;
+}
+export interface MaxEditLengthOption {
+    /**
+     * A number specifying the maximum edit distance to consider between the old and new texts.
+     * You can use this to limit the computational cost of diffing large, very different texts by giving up early if the cost will be huge.
+     * This option can be passed either to diffing functions (`diffLines`, `diffChars`, etc) or to patch-creation function (`structuredPatch`, `createPatch`, etc), all of which will indicate that the max edit length was reached by returning `undefined` instead of whatever they'd normally return.
+     */
+    maxEditLength: number;
+}
+export type AbortableDiffOptions = TimeoutOption | MaxEditLengthOption;
+export type DiffCallbackNonabortable<T> = (result: ChangeObject<T>[]) => void;
+export type DiffCallbackAbortable<T> = (result: ChangeObject<T>[] | undefined) => void;
+export interface CallbackOptionNonabortable<T> {
+    /**
+     * 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: DiffCallbackNonabortable<T>;
+}
+export interface CallbackOptionAbortable<T> {
+    /**
+     * 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: DiffCallbackAbortable<T>;
+}
+interface DiffArraysOptions<T> extends CommonDiffOptions {
+    comparator?: (a: T, b: T) => boolean;
+}
+export interface DiffArraysOptionsNonabortable<T> extends DiffArraysOptions<T> {
+    /**
+     * 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?: DiffCallbackNonabortable<T[]>;
+}
+export type DiffArraysOptionsAbortable<T> = DiffArraysOptions<T> & AbortableDiffOptions & Partial<CallbackOptionAbortable<T[]>>;
+interface DiffCharsOptions extends CommonDiffOptions {
+    /**
+     * If `true`, the uppercase and lowercase forms of a character are considered equal.
+     * @default false
+     */
+    ignoreCase?: boolean;
+}
+export interface DiffCharsOptionsNonabortable extends DiffCharsOptions {
+    /**
+     * 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?: DiffCallbackNonabortable<string>;
+}
+export type DiffCharsOptionsAbortable = DiffCharsOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+interface DiffLinesOptions extends CommonDiffOptions {
+    /**
+     * `true` to remove all trailing CR (`\r`) characters before performing the diff.
+     * This helps to get a useful diff when diffing UNIX text files against Windows text files.
+     * @default false
+     */
+    stripTrailingCr?: boolean;
+    /**
+     * `true` to treat the newline character at the end of each line as its own token.
+     * This allows for changes to the newline structure to occur independently of the line content and to be treated as such.
+     * In general this is the more human friendly form of `diffLines`; the default behavior with this option turned off is better suited for patches and other computer friendly output.
+     *
+     * Note that while using `ignoreWhitespace` in combination with `newlineIsToken` is not an error, results may not be as expected.
+     * With `ignoreWhitespace: true` and `newlineIsToken: false`, changing a completely empty line to contain some spaces is treated as a non-change, but with `ignoreWhitespace: true` and `newlineIsToken: true`, it is treated as an insertion.
+     * This is because the content of a completely blank line is not a token at all in `newlineIsToken` mode.
+     *
+     * @default false
+     */
+    newlineIsToken?: boolean;
+    /**
+     * `true` to ignore a missing newline character at the end of the last line when comparing it to other lines.
+     * (By default, the line `'b\n'` in text `'a\nb\nc'` is not considered equal to the line `'b'` in text `'a\nb'`; this option makes them be considered equal.)
+     * Ignored if `ignoreWhitespace` or `newlineIsToken` are also true.
+     * @default false
+     */
+    ignoreNewlineAtEof?: boolean;
+    /**
+     * `true` to ignore leading and trailing whitespace characters when checking if two lines are equal.
+     * @default false
+     */
+    ignoreWhitespace?: boolean;
+}
+export interface DiffLinesOptionsNonabortable extends DiffLinesOptions {
+    /**
+     * 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?: DiffCallbackNonabortable<string>;
+}
+export type DiffLinesOptionsAbortable = DiffLinesOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+interface DiffWordsOptions extends CommonDiffOptions {
+    /**
+     * Same as in `diffChars`.
+     * @default false
+     */
+    ignoreCase?: boolean;
+    /**
+     * An optional [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter) object (which must have a `granularity` of `'word'`) for `diffWords` to use to split the text into words.
+     *
+     * Note that this is (deliberately) incorrectly typed as `any` to avoid users whose `lib` & `target` settings in tsconfig.json are older than es2022 getting type errors when they build about `Intl.Segmenter` not existing.
+     * This is kind of ugly, since it makes the type declarations worse for users who genuinely use this feature, but seemed worth it to avoid the majority of the library's users (who probably do not use this particular option) getting confusing errors and being forced to change their `lib` to es2022 (even if their own code doesn't use any es2022 functions).
+     *
+     * By default, `diffWords` does not use an `Intl.Segmenter`, just some regexes for splitting text into words. This will tend to give worse results than `Intl.Segmenter` would, but ensures the results are consistent across environments; `Intl.Segmenter` behaviour is only loosely specced and the implementations in browsers could in principle change dramatically in future. If you want to use `diffWords` with an `Intl.Segmenter` but ensure it behaves the same whatever environment you run it in, use an `Intl.Segmenter` polyfill instead of the JavaScript engine's native `Intl.Segmenter` implementation.
+     *
+     * Using an `Intl.Segmenter` should allow better word-level diffing of non-English text than the default behaviour. For instance, `Intl.Segmenter`s can generally identify via built-in dictionaries which sequences of adjacent Chinese characters form words, allowing word-level diffing of Chinese. By specifying a language when instantiating the segmenter (e.g. `new Intl.Segmenter('sv', {granularity: 'word'})`) you can also support language-specific rules, like treating Swedish's colon separated contractions (like *k:a* for *kyrka*) as single words; by default this would be seen as two words separated by a colon.
+     */
+    intlSegmenter?: any;
+}
+export interface DiffWordsOptionsNonabortable extends DiffWordsOptions {
+    /**
+     * 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?: DiffCallbackNonabortable<string>;
+}
+export type DiffWordsOptionsAbortable = DiffWordsOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+interface DiffSentencesOptions extends CommonDiffOptions {
+}
+export interface DiffSentencesOptionsNonabortable extends DiffSentencesOptions {
+    /**
+     * 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?: DiffCallbackNonabortable<string>;
+}
+export type DiffSentencesOptionsAbortable = DiffSentencesOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+interface DiffJsonOptions extends CommonDiffOptions {
+    /**
+     * A value to replace `undefined` with. Ignored if a `stringifyReplacer` is provided.
+     */
+    undefinedReplacement?: any;
+    /**
+     * A custom replacer function.
+     * Operates similarly to the `replacer` parameter to [`JSON.stringify()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#the_replacer_parameter), but must be a function.
+     */
+    stringifyReplacer?: (k: string, v: any) => any;
+}
+export interface DiffJsonOptionsNonabortable extends DiffJsonOptions {
+    /**
+     * 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?: DiffCallbackNonabortable<string>;
+}
+export type DiffJsonOptionsAbortable = DiffJsonOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+interface DiffCssOptions extends CommonDiffOptions {
+}
+export interface DiffCssOptionsNonabortable extends DiffCssOptions {
+    /**
+     * 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?: DiffCallbackNonabortable<string>;
+}
+export type DiffCssOptionsAbortable = DiffCssOptions & AbortableDiffOptions & Partial<CallbackOptionAbortable<string>>;
+/**
+ * Note that this contains the union of ALL options accepted by any of the built-in diffing
+ * functions. The README notes which options are usable which functions. Using an option with a
+ * diffing function that doesn't support it might yield unreasonable results.
+ */
+export type AllDiffOptions = DiffArraysOptions<unknown> & DiffCharsOptions & DiffWordsOptions & DiffLinesOptions & DiffJsonOptions;
+export interface StructuredPatch {
+    oldFileName: string;
+    newFileName: string;
+    oldHeader: string | undefined;
+    newHeader: string | undefined;
+    hunks: StructuredPatchHunk[];
+    index?: string;
+}
+export interface StructuredPatchHunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: string[];
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/etc/mcp-server/node_modules/diff/libcjs/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY,CAAC,MAAM;IAClC;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;IACf;;OAEG;IACH,OAAO,EAAE,OAAO,CAAC;IACjB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;CACf;AAMD,MAAM,MAAM,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;AAC1C,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC;AAE/C,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;CAC7B;AAED,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAAG,mBAAmB,CAAC;AAEvE,MAAM,MAAM,wBAAwB,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,CAAC;AAC9E,MAAM,MAAM,qBAAqB,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,GAAG,SAAS,KAAK,IAAI,CAAC;AAEvF,MAAM,WAAW,0BAA0B,CAAC,CAAC;IAC3C;;;OAGG;IACH,QAAQ,EAAE,wBAAwB,CAAC,CAAC,CAAC,CAAA;CACtC;AACD,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC;;;OAGG;IACH,QAAQ,EAAE,qBAAqB,CAAC,CAAC,CAAC,CAAA;CACnC;AAED,UAAU,iBAAiB,CAAC,CAAC,CAAE,SAAQ,iBAAiB;IACtD,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,OAAO,CAAC;CACtC;AACD,MAAM,WAAW,6BAA6B,CAAC,CAAC,CAAE,SAAQ,iBAAiB,CAAC,CAAC,CAAC;IAC5E;;;OAGG;IACH,QAAQ,CAAC,EAAE,wBAAwB,CAAC,CAAC,EAAE,CAAC,CAAA;CACzC;AACD,MAAM,MAAM,0BAA0B,CAAC,CAAC,IAAI,iBAAiB,CAAC,CAAC,CAAC,GAAG,oBAAoB,GAAG,OAAO,CAAC,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;AAG/H,UAAU,gBAAiB,SAAQ,iBAAiB;IAClD;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AACD,MAAM,WAAW,4BAA6B,SAAQ,gBAAgB;IACpE;;;OAGG;IACH,QAAQ,CAAC,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAA;CAC5C;AACD,MAAM,MAAM,yBAAyB,GAAG,gBAAgB,GAAG,oBAAoB,GAAG,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAA;AAE1H,UAAU,gBAAiB,SAAQ,iBAAiB;IAClD;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;;;;;;;;OAUG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AACD,MAAM,WAAW,4BAA6B,SAAQ,gBAAgB;IACpE;;;OAGG;IACH,QAAQ,CAAC,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAA;CAC5C;AACD,MAAM,MAAM,yBAAyB,GAAG,gBAAgB,GAAG,oBAAoB,GAAG,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAA;AAG1H,UAAU,gBAAiB,SAAQ,iBAAiB;IAClD;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAA;IAEpB;;;;;;;;;OASG;IACH,aAAa,CAAC,EAAE,GAAG,CAAC;CACrB;AACD,MAAM,WAAW,4BAA6B,SAAQ,gBAAgB;IACpE;;;OAGG;IACH,QAAQ,CAAC,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAA;CAC5C;AACD,MAAM,MAAM,yBAAyB,GAAG,gBAAgB,GAAG,oBAAoB,GAAG,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAA;AAG1H,UAAU,oBAAqB,SAAQ,iBAAiB;CAAG;AAC3D,MAAM,WAAW,gCAAiC,SAAQ,oBAAoB;IAC5E;;;OAGG;IACH,QAAQ,CAAC,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAA;CAC5C;AACD,MAAM,MAAM,6BAA6B,GAAG,oBAAoB,GAAG,oBAAoB,GAAG,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAA;AAGlI,UAAU,eAAgB,SAAQ,iBAAiB;IACjD;;OAEG;IACH,oBAAoB,CAAC,EAAE,GAAG,CAAC;IAC3B;;;OAGG;IACH,iBAAiB,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,KAAK,GAAG,CAAC;CAChD;AACD,MAAM,WAAW,2BAA4B,SAAQ,eAAe;IAClE;;;OAGG;IACH,QAAQ,CAAC,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAA;CAC5C;AACD,MAAM,MAAM,wBAAwB,GAAG,eAAe,GAAG,oBAAoB,GAAG,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAA;AAGxH,UAAU,cAAe,SAAQ,iBAAiB;CAAG;AACrD,MAAM,WAAW,0BAA2B,SAAQ,cAAc;IAChE;;;OAGG;IACH,QAAQ,CAAC,EAAE,wBAAwB,CAAC,MAAM,CAAC,CAAA;CAC5C;AACD,MAAM,MAAM,uBAAuB,GAAG,cAAc,GAAG,oBAAoB,GAAG,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAAA;AAGtH;;;;GAIG;AACH,MAAM,MAAM,cAAc,GACxB,iBAAiB,CAAC,OAAO,CAAC,GAC1B,gBAAgB,GAChB,gBAAgB,GAChB,gBAAgB,GAChB,eAAe,CAAC;AAElB,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB"}

package/etc/mcp-server/node_modules/diff/libcjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/etc/mcp-server/node_modules/diff/libcjs/util/array.d.ts

@@ -0,0 +1,3 @@
+export declare function arrayEqual(a: any[], b: any[]): boolean;
+export declare function arrayStartsWith(array: any[], start: any[]): boolean;
+//# sourceMappingURL=array.d.ts.map

package/etc/mcp-server/node_modules/diff/libcjs/util/array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/util/array.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,CAAC,EAAE,GAAG,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,OAAO,CAMtD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,OAAO,CAYnE"}

package/etc/mcp-server/node_modules/diff/libcjs/util/array.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayEqual = arrayEqual;
+exports.arrayStartsWith = arrayStartsWith;
+function arrayEqual(a, b) {
+    if (a.length !== b.length) {
+        return false;
+    }
+    return arrayStartsWith(a, b);
+}
+function arrayStartsWith(array, start) {
+    if (start.length > array.length) {
+        return false;
+    }
+    for (var i = 0; i < start.length; i++) {
+        if (start[i] !== array[i]) {
+            return false;
+        }
+    }
+    return true;
+}

package/etc/mcp-server/node_modules/diff/libcjs/util/distance-iterator.d.ts

@@ -0,0 +1,2 @@
+export default function (start: number, minLine: number, maxLine: number): () => number | undefined;
+//# sourceMappingURL=distance-iterator.d.ts.map

package/etc/mcp-server/node_modules/diff/libcjs/util/distance-iterator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distance-iterator.d.ts","sourceRoot":"","sources":["../../src/util/distance-iterator.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,OAAO,WAAU,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,MAAM,GAAG,SAAS,CA0CjG"}

package/etc/mcp-server/node_modules/diff/libcjs/util/distance-iterator.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+// Iterator that traverses in the range of [min, max], stepping
+// by distance from a given start position. I.e. for [0, 4], with
+// start of 2, this will iterate 2, 3, 1, 4, 0.
+function default_1(start, minLine, maxLine) {
+    var wantForward = true, backwardExhausted = false, forwardExhausted = false, localOffset = 1;
+    return function iterator() {
+        if (wantForward && !forwardExhausted) {
+            if (backwardExhausted) {
+                localOffset++;
+            }
+            else {
+                wantForward = false;
+            }
+            // Check if trying to fit beyond text length, and if not, check it fits
+            // after offset location (or desired location on first iteration)
+            if (start + localOffset <= maxLine) {
+                return start + localOffset;
+            }
+            forwardExhausted = true;
+        }
+        if (!backwardExhausted) {
+            if (!forwardExhausted) {
+                wantForward = true;
+            }
+            // Check if trying to fit before text beginning, and if not, check it fits
+            // before offset location
+            if (minLine <= start - localOffset) {
+                return start - localOffset++;
+            }
+            backwardExhausted = true;
+            return iterator();
+        }
+        // We tried to fit hunk before text beginning and beyond text length, then
+        // hunk can't fit on the text. Return undefined
+        return undefined;
+    };
+}

package/etc/mcp-server/node_modules/diff/libcjs/util/params.d.ts

@@ -0,0 +1,4 @@
+export declare function generateOptions(options: {
+    [key: string]: any;
+} | ((_: unknown) => void), defaults: any): object;
+//# sourceMappingURL=params.d.ts.map

package/etc/mcp-server/node_modules/diff/libcjs/util/params.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"params.d.ts","sourceRoot":"","sources":["../../src/util/params.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAC7B,OAAO,EAAE;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC,EACtD,QAAQ,EAAE,GAAG,GACZ,MAAM,CAYR"}

package/etc/mcp-server/node_modules/diff/libcjs/util/params.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOptions = generateOptions;
+function generateOptions(options, defaults) {
+    if (typeof options === 'function') {
+        defaults.callback = options;
+    }
+    else if (options) {
+        for (var name in options) {
+            /* istanbul ignore else */
+            if (Object.prototype.hasOwnProperty.call(options, name)) {
+                defaults[name] = options[name];
+            }
+        }
+    }
+    return defaults;
+}

package/etc/mcp-server/node_modules/diff/libcjs/util/string.d.ts

@@ -0,0 +1,18 @@
+export declare function longestCommonPrefix(str1: string, str2: string): string;
+export declare function longestCommonSuffix(str1: string, str2: string): string;
+export declare function replacePrefix(string: string, oldPrefix: string, newPrefix: string): string;
+export declare function replaceSuffix(string: string, oldSuffix: string, newSuffix: string): string;
+export declare function removePrefix(string: string, oldPrefix: string): string;
+export declare function removeSuffix(string: string, oldSuffix: string): string;
+export declare function maximumOverlap(string1: string, string2: string): string;
+/**
+ * Returns true if the string consistently uses Windows line endings.
+ */
+export declare function hasOnlyWinLineEndings(string: string): boolean;
+/**
+ * Returns true if the string consistently uses Unix line endings.
+ */
+export declare function hasOnlyUnixLineEndings(string: string): boolean;
+export declare function trailingWs(string: string): string;
+export declare function leadingWs(string: string): string;
+//# sourceMappingURL=string.d.ts.map

package/etc/mcp-server/node_modules/diff/libcjs/util/string.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/util/string.ts"],"names":[],"mappings":"AAAA,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAQtE;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAgBtE;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAK1F;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAS1F;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvE;AAkCD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE9D;AAED,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAmBjD;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAIhD"}