@venos-inc/venos 0.1.14 → 0.1.15

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

@@ -0,0 +1,21 @@
+import Diff from './base.js';
+import type { ChangeObject, CallbackOptionAbortable, CallbackOptionNonabortable, DiffCallbackNonabortable, DiffSentencesOptionsAbortable, DiffSentencesOptionsNonabortable } from '../types.js';
+declare class SentenceDiff extends Diff<string, string> {
+    tokenize(value: string): string[];
+}
+export declare const sentenceDiff: SentenceDiff;
+/**
+ * diffs two blocks of text, treating each sentence, and the whitespace between each pair of sentences, as a token.
+ * The characters `.`, `!`, and `?`, when followed by whitespace, are treated as marking the end of a sentence; nothing else besides the end of the string is considered to mark a sentence end.
+ *
+ * (For more sophisticated detection of sentence breaks, including support for non-English punctuation, consider instead tokenizing with an [`Intl.Segmenter`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Segmenter) with `granularity: 'sentence'` and passing the result to `diffArrays`.)
+ *
+ * @returns a list of change objects.
+ */
+export declare function diffSentences(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
+export declare function diffSentences(oldStr: string, newStr: string, options: DiffSentencesOptionsAbortable & CallbackOptionAbortable<string>): undefined;
+export declare function diffSentences(oldStr: string, newStr: string, options: DiffSentencesOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
+export declare function diffSentences(oldStr: string, newStr: string, options: DiffSentencesOptionsAbortable): ChangeObject<string>[] | undefined;
+export declare function diffSentences(oldStr: string, newStr: string, options?: DiffSentencesOptionsNonabortable): ChangeObject<string>[];
+export {};
+//# sourceMappingURL=sentence.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sentence.d.ts","sourceRoot":"","sources":["../../src/diff/sentence.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EACV,YAAY,EACZ,uBAAuB,EACvB,0BAA0B,EAC1B,wBAAwB,EACxB,6BAA6B,EAC7B,gCAAgC,EACjC,MAAM,aAAa,CAAC;AAMrB,cAAM,YAAa,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IAC7C,QAAQ,CAAC,KAAK,EAAE,MAAM;CAoCvB;AAED,eAAO,MAAM,YAAY,cAAqB,CAAC;AAE/C;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,6BAA6B,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACvE,SAAS,CAAA;AACZ,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,gCAAgC,GAAG,0BAA0B,CAAC,MAAM,CAAC,GAC7E,SAAS,CAAA;AACZ,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,6BAA6B,GACrC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,gCAAgC,GACzC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA"}

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

@@ -0,0 +1,67 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sentenceDiff = void 0;
+exports.diffSentences = diffSentences;
+var base_js_1 = require("./base.js");
+function isSentenceEndPunct(char) {
+    return char == '.' || char == '!' || char == '?';
+}
+var SentenceDiff = /** @class */ (function (_super) {
+    __extends(SentenceDiff, _super);
+    function SentenceDiff() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    SentenceDiff.prototype.tokenize = function (value) {
+        var _a;
+        // If in future we drop support for environments that don't support lookbehinds, we can replace
+        // this entire function with:
+        //     return value.split(/(?<=[.!?])(\s+|$)/);
+        // but until then, for similar reasons to the trailingWs function in string.ts, we are forced
+        // to do this verbosely "by hand" instead of using a regex.
+        var result = [];
+        var tokenStartI = 0;
+        for (var i = 0; i < value.length; i++) {
+            if (i == value.length - 1) {
+                result.push(value.slice(tokenStartI));
+                break;
+            }
+            if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\s/)) {
+                // We've hit a sentence break - i.e. a punctuation mark followed by whitespace.
+                // We now want to push TWO tokens to the result:
+                // 1. the sentence
+                result.push(value.slice(tokenStartI, i + 1));
+                // 2. the whitespace
+                i = tokenStartI = i + 1;
+                while ((_a = value[i + 1]) === null || _a === void 0 ? void 0 : _a.match(/\s/)) {
+                    i++;
+                }
+                result.push(value.slice(tokenStartI, i + 1));
+                // Then the next token (a sentence) starts on the character after the whitespace.
+                // (It's okay if this is off the end of the string - then the outer loop will terminate
+                // here anyway.)
+                tokenStartI = i + 1;
+            }
+        }
+        return result;
+    };
+    return SentenceDiff;
+}(base_js_1.default));
+exports.sentenceDiff = new SentenceDiff();
+function diffSentences(oldStr, newStr, options) {
+    return exports.sentenceDiff.diff(oldStr, newStr, options);
+}

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

@@ -0,0 +1,35 @@
+import Diff from './base.js';
+import type { ChangeObject, CallbackOptionAbortable, CallbackOptionNonabortable, DiffCallbackNonabortable, DiffWordsOptionsAbortable, DiffWordsOptionsNonabortable } from '../types.js';
+declare class WordDiff extends Diff<string, string> {
+    equals(left: string, right: string, options: DiffWordsOptionsAbortable | DiffWordsOptionsNonabortable): boolean;
+    tokenize(value: string, options?: DiffWordsOptionsAbortable | DiffWordsOptionsNonabortable): string[];
+    join(tokens: string[]): string;
+    postProcess(changes: ChangeObject<string>[], options: any): ChangeObject<string>[];
+}
+export declare const wordDiff: WordDiff;
+/**
+ * diffs two blocks of text, treating each word and each punctuation mark as a token.
+ * Whitespace is ignored when computing the diff (but preserved as far as possible in the final change objects).
+ *
+ * @returns a list of change objects.
+ */
+export declare function diffWords(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
+export declare function diffWords(oldStr: string, newStr: string, options: DiffWordsOptionsAbortable & CallbackOptionAbortable<string>): undefined;
+export declare function diffWords(oldStr: string, newStr: string, options: DiffWordsOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
+export declare function diffWords(oldStr: string, newStr: string, options: DiffWordsOptionsAbortable): ChangeObject<string>[] | undefined;
+export declare function diffWords(oldStr: string, newStr: string, options?: DiffWordsOptionsNonabortable): ChangeObject<string>[];
+declare class WordsWithSpaceDiff extends Diff<string, string> {
+    tokenize(value: string): [] | RegExpMatchArray;
+}
+export declare const wordsWithSpaceDiff: WordsWithSpaceDiff;
+/**
+ * diffs two blocks of text, treating each word, punctuation mark, newline, or run of (non-newline) whitespace as a token.
+ * @returns a list of change objects
+ */
+export declare function diffWordsWithSpace(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
+export declare function diffWordsWithSpace(oldStr: string, newStr: string, options: DiffWordsOptionsAbortable & CallbackOptionAbortable<string>): undefined;
+export declare function diffWordsWithSpace(oldStr: string, newStr: string, options: DiffWordsOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
+export declare function diffWordsWithSpace(oldStr: string, newStr: string, options: DiffWordsOptionsAbortable): ChangeObject<string>[] | undefined;
+export declare function diffWordsWithSpace(oldStr: string, newStr: string, options?: DiffWordsOptionsNonabortable): ChangeObject<string>[];
+export {};
+//# sourceMappingURL=word.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"word.d.ts","sourceRoot":"","sources":["../../src/diff/word.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,yBAAyB,EAAE,4BAA4B,EAAC,MAAM,aAAa,CAAC;AAqDvL,cAAM,QAAS,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IACzC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB,GAAG,4BAA4B;IASrG,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,yBAAyB,GAAG,4BAAiC;IAoD9F,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE;IAerB,WAAW,CAAC,OAAO,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,EAAE,OAAO,EAAE,GAAG;CA6B1D;AAED,eAAO,MAAM,QAAQ,UAAiB,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACnE,SAAS,CAAA;AACZ,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,4BAA4B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACzE,SAAS,CAAA;AACZ,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GACjC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,SAAS,CACvB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA;AA8IzB,cAAM,kBAAmB,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM;CASvB;AAED,eAAO,MAAM,kBAAkB,oBAA2B,CAAC;AAE3D;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACnE,SAAS,CAAA;AACZ,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,4BAA4B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACzE,SAAS,CAAA;AACZ,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GACjC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA"}

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

@@ -0,0 +1,328 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wordsWithSpaceDiff = exports.wordDiff = void 0;
+exports.diffWords = diffWords;
+exports.diffWordsWithSpace = diffWordsWithSpace;
+var base_js_1 = require("./base.js");
+var string_js_1 = require("../util/string.js");
+// Based on https://en.wikipedia.org/wiki/Latin_script_in_Unicode
+//
+// Chars/ranges counted as "word" characters by this regex are as follows:
+//
+// + U+00AD  Soft hyphen
+// + 00C0–00FF (letters with diacritics from the Latin-1 Supplement), except:
+//   - U+00D7  × Multiplication sign
+//   - U+00F7  ÷ Division sign
+// + Latin Extended-A, 0100–017F
+// + Latin Extended-B, 0180–024F
+// + IPA Extensions, 0250–02AF
+// + Spacing Modifier Letters, 02B0–02FF, except:
+//   - U+02C7  ˇ ˇ  Caron
+//   - U+02D8  ˘ ˘  Breve
+//   - U+02D9  ˙ ˙  Dot Above
+//   - U+02DA  ˚ ˚  Ring Above
+//   - U+02DB  ˛ ˛  Ogonek
+//   - U+02DC  ˜ ˜  Small Tilde
+//   - U+02DD  ˝ ˝  Double Acute Accent
+// + Latin Extended Additional, 1E00–1EFF
+var extendedWordChars = 'a-zA-Z0-9_\\u{AD}\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}';
+// Each token is one of the following:
+// - A punctuation mark plus the surrounding whitespace
+// - A word plus the surrounding whitespace
+// - Pure whitespace (but only in the special case where the entire text
+//   is just whitespace)
+//
+// We have to include surrounding whitespace in the tokens because the two
+// alternative approaches produce horribly broken results:
+// * If we just discard the whitespace, we can't fully reproduce the original
+//   text from the sequence of tokens and any attempt to render the diff will
+//   get the whitespace wrong.
+// * If we have separate tokens for whitespace, then in a typical text every
+//   second token will be a single space character. But this often results in
+//   the optimal diff between two texts being a perverse one that preserves
+//   the spaces between words but deletes and reinserts actual common words.
+//   See https://github.com/kpdecker/jsdiff/issues/160#issuecomment-1866099640
+//   for an example.
+//
+// Keeping the surrounding whitespace of course has implications for .equals
+// and .join, not just .tokenize.
+// This regex does NOT fully implement the tokenization rules described above.
+// Instead, it gives runs of whitespace their own "token". The tokenize method
+// then handles stitching whitespace tokens onto adjacent word or punctuation
+// tokens.
+var tokenizeIncludingWhitespace = new RegExp("[".concat(extendedWordChars, "]+|\\s+|[^").concat(extendedWordChars, "]"), 'ug');
+var WordDiff = /** @class */ (function (_super) {
+    __extends(WordDiff, _super);
+    function WordDiff() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WordDiff.prototype.equals = function (left, right, options) {
+        if (options.ignoreCase) {
+            left = left.toLowerCase();
+            right = right.toLowerCase();
+        }
+        return left.trim() === right.trim();
+    };
+    WordDiff.prototype.tokenize = function (value, options) {
+        if (options === void 0) { options = {}; }
+        var parts;
+        if (options.intlSegmenter) {
+            var segmenter = options.intlSegmenter;
+            if (segmenter.resolvedOptions().granularity != 'word') {
+                throw new Error('The segmenter passed must have a granularity of "word"');
+            }
+            // We want `parts` to be an array whose elements alternate between being
+            // pure whitespace and being pure non-whitespace. This is ALMOST what the
+            // segments returned by a word-based Intl.Segmenter already look like,
+            // and therefore we can ALMOST get what we want by simply doing...
+            //     parts = Array.from(segmenter.segment(value), segment => segment.segment);
+            // ... but not QUITE, because there's of one annoying special case: every
+            // newline character gets its own segment, instead of sharing a segment
+            // with other surrounding whitespace. We therefore need to manually merge
+            // consecutive segments of whitespace into a single part:
+            parts = [];
+            for (var _i = 0, _a = Array.from(segmenter.segment(value)); _i < _a.length; _i++) {
+                var segmentObj = _a[_i];
+                var segment = segmentObj.segment;
+                if (parts.length && (/\s/).test(parts[parts.length - 1]) && (/\s/).test(segment)) {
+                    parts[parts.length - 1] += segment;
+                }
+                else {
+                    parts.push(segment);
+                }
+            }
+        }
+        else {
+            parts = value.match(tokenizeIncludingWhitespace) || [];
+        }
+        var tokens = [];
+        var prevPart = null;
+        parts.forEach(function (part) {
+            if ((/\s/).test(part)) {
+                if (prevPart == null) {
+                    tokens.push(part);
+                }
+                else {
+                    tokens.push(tokens.pop() + part);
+                }
+            }
+            else if (prevPart != null && (/\s/).test(prevPart)) {
+                if (tokens[tokens.length - 1] == prevPart) {
+                    tokens.push(tokens.pop() + part);
+                }
+                else {
+                    tokens.push(prevPart + part);
+                }
+            }
+            else {
+                tokens.push(part);
+            }
+            prevPart = part;
+        });
+        return tokens;
+    };
+    WordDiff.prototype.join = function (tokens) {
+        // Tokens being joined here will always have appeared consecutively in the
+        // same text, so we can simply strip off the leading whitespace from all the
+        // tokens except the first (and except any whitespace-only tokens - but such
+        // a token will always be the first and only token anyway) and then join them
+        // and the whitespace around words and punctuation will end up correct.
+        return tokens.map(function (token, i) {
+            if (i == 0) {
+                return token;
+            }
+            else {
+                return token.replace((/^\s+/), '');
+            }
+        }).join('');
+    };
+    WordDiff.prototype.postProcess = function (changes, options) {
+        if (!changes || options.oneChangePerToken) {
+            return changes;
+        }
+        var lastKeep = null;
+        // Change objects representing any insertion or deletion since the last
+        // "keep" change object. There can be at most one of each.
+        var insertion = null;
+        var deletion = null;
+        changes.forEach(function (change) {
+            if (change.added) {
+                insertion = change;
+            }
+            else if (change.removed) {
+                deletion = change;
+            }
+            else {
+                if (insertion || deletion) { // May be false at start of text
+                    dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
+                }
+                lastKeep = change;
+                insertion = null;
+                deletion = null;
+            }
+        });
+        if (insertion || deletion) {
+            dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
+        }
+        return changes;
+    };
+    return WordDiff;
+}(base_js_1.default));
+exports.wordDiff = new WordDiff();
+function diffWords(oldStr, newStr, options) {
+    // This option has never been documented and never will be (it's clearer to
+    // just call `diffWordsWithSpace` directly if you need that behavior), but
+    // has existed in jsdiff for a long time, so we retain support for it here
+    // for the sake of backwards compatibility.
+    if ((options === null || options === void 0 ? void 0 : options.ignoreWhitespace) != null && !options.ignoreWhitespace) {
+        return diffWordsWithSpace(oldStr, newStr, options);
+    }
+    return exports.wordDiff.diff(oldStr, newStr, options);
+}
+function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
+    // Before returning, we tidy up the leading and trailing whitespace of the
+    // change objects to eliminate cases where trailing whitespace in one object
+    // is repeated as leading whitespace in the next.
+    // Below are examples of the outcomes we want here to explain the code.
+    // I=insert, K=keep, D=delete
+    // 1. diffing 'foo bar baz' vs 'foo baz'
+    //    Prior to cleanup, we have K:'foo ' D:' bar ' K:' baz'
+    //    After cleanup, we want:   K:'foo ' D:'bar ' K:'baz'
+    //
+    // 2. Diffing 'foo bar baz' vs 'foo qux baz'
+    //    Prior to cleanup, we have K:'foo ' D:' bar ' I:' qux ' K:' baz'
+    //    After cleanup, we want K:'foo ' D:'bar' I:'qux' K:' baz'
+    //
+    // 3. Diffing 'foo\nbar baz' vs 'foo baz'
+    //    Prior to cleanup, we have K:'foo ' D:'\nbar ' K:' baz'
+    //    After cleanup, we want K'foo' D:'\nbar' K:' baz'
+    //
+    // 4. Diffing 'foo baz' vs 'foo\nbar baz'
+    //    Prior to cleanup, we have K:'foo\n' I:'\nbar ' K:' baz'
+    //    After cleanup, we ideally want K'foo' I:'\nbar' K:' baz'
+    //    but don't actually manage this currently (the pre-cleanup change
+    //    objects don't contain enough information to make it possible).
+    //
+    // 5. Diffing 'foo   bar baz' vs 'foo  baz'
+    //    Prior to cleanup, we have K:'foo  ' D:'   bar ' K:'  baz'
+    //    After cleanup, we want K:'foo  ' D:' bar ' K:'baz'
+    //
+    // Our handling is unavoidably imperfect in the case where there's a single
+    // indel between keeps and the whitespace has changed. For instance, consider
+    // diffing 'foo\tbar\nbaz' vs 'foo baz'. Unless we create an extra change
+    // object to represent the insertion of the space character (which isn't even
+    // a token), we have no way to avoid losing information about the texts'
+    // original whitespace in the result we return. Still, we do our best to
+    // output something that will look sensible if we e.g. print it with
+    // insertions in green and deletions in red.
+    // Between two "keep" change objects (or before the first or after the last
+    // change object), we can have either:
+    // * A "delete" followed by an "insert"
+    // * Just an "insert"
+    // * Just a "delete"
+    // We handle the three cases separately.
+    if (deletion && insertion) {
+        var oldWsPrefix = (0, string_js_1.leadingWs)(deletion.value);
+        var oldWsSuffix = (0, string_js_1.trailingWs)(deletion.value);
+        var newWsPrefix = (0, string_js_1.leadingWs)(insertion.value);
+        var newWsSuffix = (0, string_js_1.trailingWs)(insertion.value);
+        if (startKeep) {
+            var commonWsPrefix = (0, string_js_1.longestCommonPrefix)(oldWsPrefix, newWsPrefix);
+            startKeep.value = (0, string_js_1.replaceSuffix)(startKeep.value, newWsPrefix, commonWsPrefix);
+            deletion.value = (0, string_js_1.removePrefix)(deletion.value, commonWsPrefix);
+            insertion.value = (0, string_js_1.removePrefix)(insertion.value, commonWsPrefix);
+        }
+        if (endKeep) {
+            var commonWsSuffix = (0, string_js_1.longestCommonSuffix)(oldWsSuffix, newWsSuffix);
+            endKeep.value = (0, string_js_1.replacePrefix)(endKeep.value, newWsSuffix, commonWsSuffix);
+            deletion.value = (0, string_js_1.removeSuffix)(deletion.value, commonWsSuffix);
+            insertion.value = (0, string_js_1.removeSuffix)(insertion.value, commonWsSuffix);
+        }
+    }
+    else if (insertion) {
+        // The whitespaces all reflect what was in the new text rather than
+        // the old, so we essentially have no information about whitespace
+        // insertion or deletion. We just want to dedupe the whitespace.
+        // We do that by having each change object keep its trailing
+        // whitespace and deleting duplicate leading whitespace where
+        // present.
+        if (startKeep) {
+            var ws = (0, string_js_1.leadingWs)(insertion.value);
+            insertion.value = insertion.value.substring(ws.length);
+        }
+        if (endKeep) {
+            var ws = (0, string_js_1.leadingWs)(endKeep.value);
+            endKeep.value = endKeep.value.substring(ws.length);
+        }
+        // otherwise we've got a deletion and no insertion
+    }
+    else if (startKeep && endKeep) {
+        var newWsFull = (0, string_js_1.leadingWs)(endKeep.value), delWsStart = (0, string_js_1.leadingWs)(deletion.value), delWsEnd = (0, string_js_1.trailingWs)(deletion.value);
+        // Any whitespace that comes straight after startKeep in both the old and
+        // new texts, assign to startKeep and remove from the deletion.
+        var newWsStart = (0, string_js_1.longestCommonPrefix)(newWsFull, delWsStart);
+        deletion.value = (0, string_js_1.removePrefix)(deletion.value, newWsStart);
+        // Any whitespace that comes straight before endKeep in both the old and
+        // new texts, and hasn't already been assigned to startKeep, assign to
+        // endKeep and remove from the deletion.
+        var newWsEnd = (0, string_js_1.longestCommonSuffix)((0, string_js_1.removePrefix)(newWsFull, newWsStart), delWsEnd);
+        deletion.value = (0, string_js_1.removeSuffix)(deletion.value, newWsEnd);
+        endKeep.value = (0, string_js_1.replacePrefix)(endKeep.value, newWsFull, newWsEnd);
+        // If there's any whitespace from the new text that HASN'T already been
+        // assigned, assign it to the start:
+        startKeep.value = (0, string_js_1.replaceSuffix)(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+    }
+    else if (endKeep) {
+        // We are at the start of the text. Preserve all the whitespace on
+        // endKeep, and just remove whitespace from the end of deletion to the
+        // extent that it overlaps with the start of endKeep.
+        var endKeepWsPrefix = (0, string_js_1.leadingWs)(endKeep.value);
+        var deletionWsSuffix = (0, string_js_1.trailingWs)(deletion.value);
+        var overlap = (0, string_js_1.maximumOverlap)(deletionWsSuffix, endKeepWsPrefix);
+        deletion.value = (0, string_js_1.removeSuffix)(deletion.value, overlap);
+    }
+    else if (startKeep) {
+        // We are at the END of the text. Preserve all the whitespace on
+        // startKeep, and just remove whitespace from the start of deletion to
+        // the extent that it overlaps with the end of startKeep.
+        var startKeepWsSuffix = (0, string_js_1.trailingWs)(startKeep.value);
+        var deletionWsPrefix = (0, string_js_1.leadingWs)(deletion.value);
+        var overlap = (0, string_js_1.maximumOverlap)(startKeepWsSuffix, deletionWsPrefix);
+        deletion.value = (0, string_js_1.removePrefix)(deletion.value, overlap);
+    }
+}
+var WordsWithSpaceDiff = /** @class */ (function (_super) {
+    __extends(WordsWithSpaceDiff, _super);
+    function WordsWithSpaceDiff() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    WordsWithSpaceDiff.prototype.tokenize = function (value) {
+        // Slightly different to the tokenizeIncludingWhitespace regex used above in
+        // that this one treats each individual newline as a distinct token, rather
+        // than merging them into other surrounding whitespace. This was requested
+        // in https://github.com/kpdecker/jsdiff/issues/180 &
+        //    https://github.com/kpdecker/jsdiff/issues/211
+        var regex = new RegExp("(\\r?\\n)|[".concat(extendedWordChars, "]+|[^\\S\\n\\r]+|[^").concat(extendedWordChars, "]"), 'ug');
+        return value.match(regex) || [];
+    };
+    return WordsWithSpaceDiff;
+}(base_js_1.default));
+exports.wordsWithSpaceDiff = new WordsWithSpaceDiff();
+function diffWordsWithSpace(oldStr, newStr, options) {
+    return exports.wordsWithSpaceDiff.diff(oldStr, newStr, options);
+}

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

@@ -0,0 +1,20 @@
+import Diff from './diff/base.js';
+import { diffChars, characterDiff } from './diff/character.js';
+import { diffWords, diffWordsWithSpace, wordDiff, wordsWithSpaceDiff } from './diff/word.js';
+import { diffLines, diffTrimmedLines, lineDiff } from './diff/line.js';
+import { diffSentences, sentenceDiff } from './diff/sentence.js';
+import { diffCss, cssDiff } from './diff/css.js';
+import { diffJson, canonicalize, jsonDiff } from './diff/json.js';
+import { diffArrays, arrayDiff } from './diff/array.js';
+import { applyPatch, applyPatches } from './patch/apply.js';
+import type { ApplyPatchOptions, ApplyPatchesOptions } from './patch/apply.js';
+import { parsePatch } from './patch/parse.js';
+import { reversePatch } from './patch/reverse.js';
+import { structuredPatch, createTwoFilesPatch, createPatch, formatPatch, INCLUDE_HEADERS, FILE_HEADERS_ONLY, OMIT_HEADERS } from './patch/create.js';
+import type { StructuredPatchOptionsAbortable, StructuredPatchOptionsNonabortable, CreatePatchOptionsAbortable, CreatePatchOptionsNonabortable, HeaderOptions } from './patch/create.js';
+import { convertChangesToDMP } from './convert/dmp.js';
+import { convertChangesToXML } from './convert/xml.js';
+import type { ChangeObject, Change, ArrayChange, DiffArraysOptionsAbortable, DiffArraysOptionsNonabortable, DiffCharsOptionsAbortable, DiffCharsOptionsNonabortable, DiffLinesOptionsAbortable, DiffLinesOptionsNonabortable, DiffWordsOptionsAbortable, DiffWordsOptionsNonabortable, DiffSentencesOptionsAbortable, DiffSentencesOptionsNonabortable, DiffJsonOptionsAbortable, DiffJsonOptionsNonabortable, DiffCssOptionsAbortable, DiffCssOptionsNonabortable, StructuredPatch, StructuredPatchHunk } from './types.js';
+export { Diff, diffChars, characterDiff, diffWords, wordDiff, diffWordsWithSpace, wordsWithSpaceDiff, diffLines, lineDiff, diffTrimmedLines, diffSentences, sentenceDiff, diffCss, cssDiff, diffJson, jsonDiff, diffArrays, arrayDiff, structuredPatch, createTwoFilesPatch, createPatch, formatPatch, INCLUDE_HEADERS, FILE_HEADERS_ONLY, OMIT_HEADERS, applyPatch, applyPatches, parsePatch, reversePatch, convertChangesToDMP, convertChangesToXML, canonicalize };
+export type { ChangeObject, Change, ArrayChange, DiffArraysOptionsAbortable, DiffArraysOptionsNonabortable, DiffCharsOptionsAbortable, DiffCharsOptionsNonabortable, DiffLinesOptionsAbortable, DiffLinesOptionsNonabortable, DiffWordsOptionsAbortable, DiffWordsOptionsNonabortable, DiffSentencesOptionsAbortable, DiffSentencesOptionsNonabortable, DiffJsonOptionsAbortable, DiffJsonOptionsNonabortable, DiffCssOptionsAbortable, DiffCssOptionsNonabortable, StructuredPatch, StructuredPatchHunk, ApplyPatchOptions, ApplyPatchesOptions, StructuredPatchOptionsAbortable, StructuredPatchOptionsNonabortable, CreatePatchOptionsAbortable, CreatePatchOptionsNonabortable, HeaderOptions };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAgBA,OAAO,IAAI,MAAM,gBAAgB,CAAC;AAClC,OAAO,EAAC,SAAS,EAAE,aAAa,EAAC,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAC,SAAS,EAAE,kBAAkB,EAAE,QAAQ,EAAE,kBAAkB,EAAC,MAAM,gBAAgB,CAAC;AAC3F,OAAO,EAAC,SAAS,EAAE,gBAAgB,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AACrE,OAAO,EAAC,aAAa,EAAE,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAE/D,OAAO,EAAC,OAAO,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAC/C,OAAO,EAAC,QAAQ,EAAE,YAAY,EAAE,QAAQ,EAAC,MAAM,gBAAgB,CAAC;AAEhE,OAAO,EAAC,UAAU,EAAE,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAEtD,OAAO,EAAC,UAAU,EAAE,YAAY,EAAC,MAAM,kBAAkB,CAAC;AAC1D,OAAO,KAAK,EAAC,iBAAiB,EAAE,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AAC7E,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAChD,OAAO,EACL,eAAe,EACf,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,YAAY,EACb,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,+BAA+B,EAC/B,kCAAkC,EAClC,2BAA2B,EAC3B,8BAA8B,EAC9B,aAAa,EACd,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAC,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AACrD,OAAO,EAAC,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EACV,YAAY,EACZ,MAAM,EACN,WAAW,EACX,0BAA0B,EAC1B,6BAA6B,EAC7B,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,4BAA4B,EAC5B,6BAA6B,EAC7B,gCAAgC,EAChC,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,0BAA0B,EAC1B,eAAe,EACf,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,IAAI,EAEJ,SAAS,EACT,aAAa,EACb,SAAS,EACT,QAAQ,EACR,kBAAkB,EAClB,kBAAkB,EAClB,SAAS,EACT,QAAQ,EACR,gBAAgB,EAChB,aAAa,EACb,YAAY,EACZ,OAAO,EACP,OAAO,EACP,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,SAAS,EAET,eAAe,EACf,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,mBAAmB,EACnB,mBAAmB,EACnB,YAAY,EACb,CAAC;AAEF,YAAY,EACV,YAAY,EACZ,MAAM,EACN,WAAW,EACX,0BAA0B,EAC1B,6BAA6B,EAC7B,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,4BAA4B,EAC5B,yBAAyB,EACzB,4BAA4B,EAC5B,6BAA6B,EAC7B,gCAAgC,EAChC,wBAAwB,EACxB,2BAA2B,EAC3B,uBAAuB,EACvB,0BAA0B,EAC1B,eAAe,EACf,mBAAmB,EAEnB,iBAAiB,EACjB,mBAAmB,EAEnB,+BAA+B,EAC/B,kCAAkC,EAClC,2BAA2B,EAC3B,8BAA8B,EAC9B,aAAa,EACd,CAAC"}

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

@@ -0,0 +1,64 @@
+"use strict";
+/* See LICENSE file for terms of use */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalize = exports.convertChangesToXML = exports.convertChangesToDMP = exports.reversePatch = exports.parsePatch = exports.applyPatches = exports.applyPatch = exports.OMIT_HEADERS = exports.FILE_HEADERS_ONLY = exports.INCLUDE_HEADERS = exports.formatPatch = exports.createPatch = exports.createTwoFilesPatch = exports.structuredPatch = exports.arrayDiff = exports.diffArrays = exports.jsonDiff = exports.diffJson = exports.cssDiff = exports.diffCss = exports.sentenceDiff = exports.diffSentences = exports.diffTrimmedLines = exports.lineDiff = exports.diffLines = exports.wordsWithSpaceDiff = exports.diffWordsWithSpace = exports.wordDiff = exports.diffWords = exports.characterDiff = exports.diffChars = exports.Diff = void 0;
+/*
+ * Text diff implementation.
+ *
+ * This library supports the following APIs:
+ * Diff.diffChars: Character by character diff
+ * Diff.diffWords: Word (as defined by \b regex) diff which ignores whitespace
+ * Diff.diffLines: Line based diff
+ *
+ * Diff.diffCss: Diff targeted at CSS content
+ *
+ * These methods are based on the implementation proposed in
+ * "An O(ND) Difference Algorithm and its Variations" (Myers, 1986).
+ * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.4.6927
+ */
+var base_js_1 = require("./diff/base.js");
+exports.Diff = base_js_1.default;
+var character_js_1 = require("./diff/character.js");
+Object.defineProperty(exports, "diffChars", { enumerable: true, get: function () { return character_js_1.diffChars; } });
+Object.defineProperty(exports, "characterDiff", { enumerable: true, get: function () { return character_js_1.characterDiff; } });
+var word_js_1 = require("./diff/word.js");
+Object.defineProperty(exports, "diffWords", { enumerable: true, get: function () { return word_js_1.diffWords; } });
+Object.defineProperty(exports, "diffWordsWithSpace", { enumerable: true, get: function () { return word_js_1.diffWordsWithSpace; } });
+Object.defineProperty(exports, "wordDiff", { enumerable: true, get: function () { return word_js_1.wordDiff; } });
+Object.defineProperty(exports, "wordsWithSpaceDiff", { enumerable: true, get: function () { return word_js_1.wordsWithSpaceDiff; } });
+var line_js_1 = require("./diff/line.js");
+Object.defineProperty(exports, "diffLines", { enumerable: true, get: function () { return line_js_1.diffLines; } });
+Object.defineProperty(exports, "diffTrimmedLines", { enumerable: true, get: function () { return line_js_1.diffTrimmedLines; } });
+Object.defineProperty(exports, "lineDiff", { enumerable: true, get: function () { return line_js_1.lineDiff; } });
+var sentence_js_1 = require("./diff/sentence.js");
+Object.defineProperty(exports, "diffSentences", { enumerable: true, get: function () { return sentence_js_1.diffSentences; } });
+Object.defineProperty(exports, "sentenceDiff", { enumerable: true, get: function () { return sentence_js_1.sentenceDiff; } });
+var css_js_1 = require("./diff/css.js");
+Object.defineProperty(exports, "diffCss", { enumerable: true, get: function () { return css_js_1.diffCss; } });
+Object.defineProperty(exports, "cssDiff", { enumerable: true, get: function () { return css_js_1.cssDiff; } });
+var json_js_1 = require("./diff/json.js");
+Object.defineProperty(exports, "diffJson", { enumerable: true, get: function () { return json_js_1.diffJson; } });
+Object.defineProperty(exports, "canonicalize", { enumerable: true, get: function () { return json_js_1.canonicalize; } });
+Object.defineProperty(exports, "jsonDiff", { enumerable: true, get: function () { return json_js_1.jsonDiff; } });
+var array_js_1 = require("./diff/array.js");
+Object.defineProperty(exports, "diffArrays", { enumerable: true, get: function () { return array_js_1.diffArrays; } });
+Object.defineProperty(exports, "arrayDiff", { enumerable: true, get: function () { return array_js_1.arrayDiff; } });
+var apply_js_1 = require("./patch/apply.js");
+Object.defineProperty(exports, "applyPatch", { enumerable: true, get: function () { return apply_js_1.applyPatch; } });
+Object.defineProperty(exports, "applyPatches", { enumerable: true, get: function () { return apply_js_1.applyPatches; } });
+var parse_js_1 = require("./patch/parse.js");
+Object.defineProperty(exports, "parsePatch", { enumerable: true, get: function () { return parse_js_1.parsePatch; } });
+var reverse_js_1 = require("./patch/reverse.js");
+Object.defineProperty(exports, "reversePatch", { enumerable: true, get: function () { return reverse_js_1.reversePatch; } });
+var create_js_1 = require("./patch/create.js");
+Object.defineProperty(exports, "structuredPatch", { enumerable: true, get: function () { return create_js_1.structuredPatch; } });
+Object.defineProperty(exports, "createTwoFilesPatch", { enumerable: true, get: function () { return create_js_1.createTwoFilesPatch; } });
+Object.defineProperty(exports, "createPatch", { enumerable: true, get: function () { return create_js_1.createPatch; } });
+Object.defineProperty(exports, "formatPatch", { enumerable: true, get: function () { return create_js_1.formatPatch; } });
+Object.defineProperty(exports, "INCLUDE_HEADERS", { enumerable: true, get: function () { return create_js_1.INCLUDE_HEADERS; } });
+Object.defineProperty(exports, "FILE_HEADERS_ONLY", { enumerable: true, get: function () { return create_js_1.FILE_HEADERS_ONLY; } });
+Object.defineProperty(exports, "OMIT_HEADERS", { enumerable: true, get: function () { return create_js_1.OMIT_HEADERS; } });
+var dmp_js_1 = require("./convert/dmp.js");
+Object.defineProperty(exports, "convertChangesToDMP", { enumerable: true, get: function () { return dmp_js_1.convertChangesToDMP; } });
+var xml_js_1 = require("./convert/xml.js");
+Object.defineProperty(exports, "convertChangesToXML", { enumerable: true, get: function () { return xml_js_1.convertChangesToXML; } });

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

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

package/etc/mcp-server/node_modules/diff/libcjs/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/libcjs/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"}