@autobest-ui/agent 1.0.7 → 1.0.8

package/mcp/code-mcp-pr/node_modules/diff/libesm/convert/xml.d.ts

@@ -1,6 +0,0 @@
-import type { ChangeObject } from '../types.js';
-/**
- * converts a list of change objects to a serialized XML format
- */
-export declare function convertChangesToXML(changes: ChangeObject<string>[]): string;
-//# sourceMappingURL=xml.d.ts.map

package/mcp/code-mcp-pr/node_modules/diff/libesm/convert/xml.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"xml.d.ts","sourceRoot":"","sources":["../../src/convert/xml.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAE9C;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,MAAM,CAmB3E"}

package/mcp/code-mcp-pr/node_modules/diff/libesm/convert/xml.js

@@ -1,31 +0,0 @@
-/**
- * converts a list of change objects to a serialized XML format
- */
-export function convertChangesToXML(changes) {
-    const ret = [];
-    for (let i = 0; i < changes.length; i++) {
-        const change = changes[i];
-        if (change.added) {
-            ret.push('<ins>');
-        }
-        else if (change.removed) {
-            ret.push('<del>');
-        }
-        ret.push(escapeHTML(change.value));
-        if (change.added) {
-            ret.push('</ins>');
-        }
-        else if (change.removed) {
-            ret.push('</del>');
-        }
-    }
-    return ret.join('');
-}
-function escapeHTML(s) {
-    let n = s;
-    n = n.replace(/&/g, '&amp;');
-    n = n.replace(/</g, '&lt;');
-    n = n.replace(/>/g, '&gt;');
-    n = n.replace(/"/g, '&quot;');
-    return n;
-}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/array.d.ts

@@ -1,19 +0,0 @@
-import Diff from './base.js';
-import type { ChangeObject, DiffArraysOptionsNonabortable, CallbackOptionNonabortable, DiffArraysOptionsAbortable, DiffCallbackNonabortable, CallbackOptionAbortable } from '../types.js';
-declare class ArrayDiff<T> extends Diff<T, Array<T>> {
-    tokenize(value: Array<T>): T[];
-    join(value: Array<T>): T[];
-    removeEmpty(value: Array<T>): T[];
-}
-export declare const arrayDiff: ArrayDiff<unknown>;
-/**
- * diffs two arrays of tokens, comparing each item for strict equality (===).
- * @returns a list of change objects.
- */
-export declare function diffArrays<T>(oldArr: T[], newArr: T[], options: DiffCallbackNonabortable<T[]>): undefined;
-export declare function diffArrays<T>(oldArr: T[], newArr: T[], options: DiffArraysOptionsAbortable<T> & CallbackOptionAbortable<T[]>): undefined;
-export declare function diffArrays<T>(oldArr: T[], newArr: T[], options: DiffArraysOptionsNonabortable<T> & CallbackOptionNonabortable<T[]>): undefined;
-export declare function diffArrays<T>(oldArr: T[], newArr: T[], options: DiffArraysOptionsAbortable<T>): ChangeObject<T[]>[] | undefined;
-export declare function diffArrays<T>(oldArr: T[], newArr: T[], options?: DiffArraysOptionsNonabortable<T>): ChangeObject<T[]>[];
-export {};
-//# sourceMappingURL=array.d.ts.map

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/array.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"array.d.ts","sourceRoot":"","sources":["../../src/diff/array.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EAAC,YAAY,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,uBAAuB,EAAC,MAAM,aAAa,CAAC;AAExL,cAAM,SAAS,CAAC,CAAC,CAAE,SAAQ,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;IAC1C,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;IAIxB,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;IAIpB,WAAW,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC;CAG5B;AAED,eAAO,MAAM,SAAS,oBAAkB,CAAC;AAEzC;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAC1B,MAAM,EAAE,CAAC,EAAE,EACX,MAAM,EAAE,CAAC,EAAE,EACX,OAAO,EAAE,wBAAwB,CAAC,CAAC,EAAE,CAAC,GACrC,SAAS,CAAC;AACb,wBAAgB,UAAU,CAAC,CAAC,EAC1B,MAAM,EAAE,CAAC,EAAE,EACX,MAAM,EAAE,CAAC,EAAE,EACX,OAAO,EAAE,0BAA0B,CAAC,CAAC,CAAC,GAAG,uBAAuB,CAAC,CAAC,EAAE,CAAC,GACpE,SAAS,CAAA;AACZ,wBAAgB,UAAU,CAAC,CAAC,EAC1B,MAAM,EAAE,CAAC,EAAE,EACX,MAAM,EAAE,CAAC,EAAE,EACX,OAAO,EAAE,6BAA6B,CAAC,CAAC,CAAC,GAAG,0BAA0B,CAAC,CAAC,EAAE,CAAC,GAC1E,SAAS,CAAA;AACZ,wBAAgB,UAAU,CAAC,CAAC,EAC1B,MAAM,EAAE,CAAC,EAAE,EACX,MAAM,EAAE,CAAC,EAAE,EACX,OAAO,EAAE,0BAA0B,CAAC,CAAC,CAAC,GACrC,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,GAAG,SAAS,CAAA;AAClC,wBAAgB,UAAU,CAAC,CAAC,EAC1B,MAAM,EAAE,CAAC,EAAE,EACX,MAAM,EAAE,CAAC,EAAE,EACX,OAAO,CAAC,EAAE,6BAA6B,CAAC,CAAC,CAAC,GACzC,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,CAAA"}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/array.js

@@ -1,16 +0,0 @@
-import Diff from './base.js';
-class ArrayDiff extends Diff {
-    tokenize(value) {
-        return value.slice();
-    }
-    join(value) {
-        return value;
-    }
-    removeEmpty(value) {
-        return value;
-    }
-}
-export const arrayDiff = new ArrayDiff();
-export function diffArrays(oldArr, newArr, options) {
-    return arrayDiff.diff(oldArr, newArr, options);
-}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/base.d.ts

@@ -1,20 +0,0 @@
-import type { ChangeObject, AllDiffOptions, AbortableDiffOptions, DiffCallbackNonabortable, CallbackOptionAbortable, CallbackOptionNonabortable } from '../types.js';
-export default class Diff<TokenT, ValueT extends Iterable<TokenT> = Iterable<TokenT>, InputValueT = ValueT> {
-    diff(oldStr: InputValueT, newStr: InputValueT, options: DiffCallbackNonabortable<ValueT>): undefined;
-    diff(oldStr: InputValueT, newStr: InputValueT, options: AllDiffOptions & AbortableDiffOptions & CallbackOptionAbortable<ValueT>): undefined;
-    diff(oldStr: InputValueT, newStr: InputValueT, options: AllDiffOptions & CallbackOptionNonabortable<ValueT>): undefined;
-    diff(oldStr: InputValueT, newStr: InputValueT, options: AllDiffOptions & AbortableDiffOptions): ChangeObject<ValueT>[] | undefined;
-    diff(oldStr: InputValueT, newStr: InputValueT, options?: AllDiffOptions): ChangeObject<ValueT>[];
-    private diffWithOptionsObj;
-    private addToPath;
-    private extractCommon;
-    equals(left: TokenT, right: TokenT, options: AllDiffOptions): boolean;
-    removeEmpty(array: TokenT[]): TokenT[];
-    castInput(value: InputValueT, options: AllDiffOptions): ValueT;
-    tokenize(value: ValueT, options: AllDiffOptions): TokenT[];
-    join(chars: TokenT[]): ValueT;
-    postProcess(changeObjects: ChangeObject<ValueT>[], options: AllDiffOptions): ChangeObject<ValueT>[];
-    get useLongestToken(): boolean;
-    private buildValues;
-}
-//# sourceMappingURL=base.d.ts.map

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/base.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../src/diff/base.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAE,cAAc,EAAE,oBAAoB,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,0BAA0B,EAA4D,MAAM,aAAa,CAAC;AAuB9N,MAAM,CAAC,OAAO,OAAO,IAAI,CACvB,MAAM,EACN,MAAM,SAAS,QAAQ,CAAC,MAAM,CAAC,GAAG,QAAQ,CAAC,MAAM,CAAC,EAClD,WAAW,GAAG,MAAM;IAEpB,IAAI,CACF,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS;IACZ,IAAI,CACF,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,cAAc,GAAG,oBAAoB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GAC/E,SAAS;IACZ,IAAI,CACF,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,cAAc,GAAG,0BAA0B,CAAC,MAAM,CAAC,GAC3D,SAAS;IACZ,IAAI,CACF,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,WAAW,EACnB,OAAO,EAAE,cAAc,GAAG,oBAAoB,GAC7C,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS;IACrC,IAAI,CACF,MAAM,EAAE,WAAW,EACnB,MAAM,EAAE,WAAW,EACnB,OAAO,CAAC,EAAE,cAAc,GACvB,YAAY,CAAC,MAAM,CAAC,EAAE;IAwBzB,OAAO,CAAC,kBAAkB;IA0I1B,OAAO,CAAC,SAAS;IAqBjB,OAAO,CAAC,aAAa;IA8BrB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO;IASrE,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAWtC,SAAS,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM;IAK9D,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,MAAM,EAAE;IAI1D,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM;IAQ7B,WAAW,CACT,aAAa,EAAE,YAAY,CAAC,MAAM,CAAC,EAAE,EAErC,OAAO,EAAE,cAAc,GACtB,YAAY,CAAC,MAAM,CAAC,EAAE;IAIzB,IAAI,eAAe,IAAI,OAAO,CAE7B;IAED,OAAO,CAAC,WAAW;CAkDpB"}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/base.js

@@ -1,253 +0,0 @@
-export default class Diff {
-    diff(oldStr, newStr, 
-    // Type below is not accurate/complete - see above for full possibilities - but it compiles
-    options = {}) {
-        let callback;
-        if (typeof options === 'function') {
-            callback = options;
-            options = {};
-        }
-        else if ('callback' in options) {
-            callback = options.callback;
-        }
-        // Allow subclasses to massage the input prior to running
-        const oldString = this.castInput(oldStr, options);
-        const newString = this.castInput(newStr, options);
-        const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-        const newTokens = this.removeEmpty(this.tokenize(newString, options));
-        return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
-    }
-    diffWithOptionsObj(oldTokens, newTokens, options, callback) {
-        var _a;
-        const done = (value) => {
-            value = this.postProcess(value, options);
-            if (callback) {
-                setTimeout(function () { callback(value); }, 0);
-                return undefined;
-            }
-            else {
-                return value;
-            }
-        };
-        const newLen = newTokens.length, oldLen = oldTokens.length;
-        let editLength = 1;
-        let maxEditLength = newLen + oldLen;
-        if (options.maxEditLength != null) {
-            maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-        }
-        const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
-        const abortAfterTimestamp = Date.now() + maxExecutionTime;
-        const bestPath = [{ oldPos: -1, lastComponent: undefined }];
-        // Seed editLength = 0, i.e. the content starts with the same values
-        let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-        if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-            // Identity per the equality and tokenizer
-            return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-        }
-        // Once we hit the right edge of the edit graph on some diagonal k, we can
-        // definitely reach the end of the edit graph in no more than k edits, so
-        // there's no point in considering any moves to diagonal k+1 any more (from
-        // which we're guaranteed to need at least k+1 more edits).
-        // Similarly, once we've reached the bottom of the edit graph, there's no
-        // point considering moves to lower diagonals.
-        // We record this fact by setting minDiagonalToConsider and
-        // maxDiagonalToConsider to some finite value once we've hit the edge of
-        // the edit graph.
-        // This optimization is not faithful to the original algorithm presented in
-        // Myers's paper, which instead pointlessly extends D-paths off the end of
-        // the edit graph - see page 7 of Myers's paper which notes this point
-        // explicitly and illustrates it with a diagram. This has major performance
-        // implications for some common scenarios. For instance, to compute a diff
-        // where the new text simply appends d characters on the end of the
-        // original text of length n, the true Myers algorithm will take O(n+d^2)
-        // time while this optimization needs only O(n+d) time.
-        let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-        // Main worker method. checks all permutations of a given edit length for acceptance.
-        const execEditLength = () => {
-            for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-                let basePath;
-                const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-                if (removePath) {
-                    // No one else is going to attempt to use this value, clear it
-                    // @ts-expect-error - perf optimisation. This type-violating value will never be read.
-                    bestPath[diagonalPath - 1] = undefined;
-                }
-                let canAdd = false;
-                if (addPath) {
-                    // what newPos will be after we do an insertion:
-                    const addPathNewPos = addPath.oldPos - diagonalPath;
-                    canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-                }
-                const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-                if (!canAdd && !canRemove) {
-                    // If this path is a terminal then prune
-                    // @ts-expect-error - perf optimisation. This type-violating value will never be read.
-                    bestPath[diagonalPath] = undefined;
-                    continue;
-                }
-                // Select the diagonal that we want to branch from. We select the prior
-                // path whose position in the old string is the farthest from the origin
-                // and does not pass the bounds of the diff graph
-                if (!canRemove || (canAdd && removePath.oldPos < addPath.oldPos)) {
-                    basePath = this.addToPath(addPath, true, false, 0, options);
-                }
-                else {
-                    basePath = this.addToPath(removePath, false, true, 1, options);
-                }
-                newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
-                if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-                    // If we have hit the end of both strings, then we are done
-                    return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
-                }
-                else {
-                    bestPath[diagonalPath] = basePath;
-                    if (basePath.oldPos + 1 >= oldLen) {
-                        maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-                    }
-                    if (newPos + 1 >= newLen) {
-                        minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-                    }
-                }
-            }
-            editLength++;
-        };
-        // Performs the length of edit iteration. Is a bit fugly as this has to support the
-        // sync and async mode which is never fun. Loops over execEditLength until a value
-        // is produced, or until the edit length exceeds options.maxEditLength (if given),
-        // in which case it will return undefined.
-        if (callback) {
-            (function exec() {
-                setTimeout(function () {
-                    if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-                        return callback(undefined);
-                    }
-                    if (!execEditLength()) {
-                        exec();
-                    }
-                }, 0);
-            }());
-        }
-        else {
-            while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-                const ret = execEditLength();
-                if (ret) {
-                    return ret;
-                }
-            }
-        }
-    }
-    addToPath(path, added, removed, oldPosInc, options) {
-        const last = path.lastComponent;
-        if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-            return {
-                oldPos: path.oldPos + oldPosInc,
-                lastComponent: { count: last.count + 1, added: added, removed: removed, previousComponent: last.previousComponent }
-            };
-        }
-        else {
-            return {
-                oldPos: path.oldPos + oldPosInc,
-                lastComponent: { count: 1, added: added, removed: removed, previousComponent: last }
-            };
-        }
-    }
-    extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
-        const newLen = newTokens.length, oldLen = oldTokens.length;
-        let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-        while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
-            newPos++;
-            oldPos++;
-            commonCount++;
-            if (options.oneChangePerToken) {
-                basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
-            }
-        }
-        if (commonCount && !options.oneChangePerToken) {
-            basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
-        }
-        basePath.oldPos = oldPos;
-        return newPos;
-    }
-    equals(left, right, options) {
-        if (options.comparator) {
-            return options.comparator(left, right);
-        }
-        else {
-            return left === right
-                || (!!options.ignoreCase && left.toLowerCase() === right.toLowerCase());
-        }
-    }
-    removeEmpty(array) {
-        const ret = [];
-        for (let i = 0; i < array.length; i++) {
-            if (array[i]) {
-                ret.push(array[i]);
-            }
-        }
-        return ret;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    castInput(value, options) {
-        return value;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    tokenize(value, options) {
-        return Array.from(value);
-    }
-    join(chars) {
-        // Assumes ValueT is string, which is the case for most subclasses.
-        // When it's false, e.g. in diffArrays, this method needs to be overridden (e.g. with a no-op)
-        // Yes, the casts are verbose and ugly, because this pattern - of having the base class SORT OF
-        // assume tokens and values are strings, but not completely - is weird and janky.
-        return chars.join('');
-    }
-    postProcess(changeObjects, 
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    options) {
-        return changeObjects;
-    }
-    get useLongestToken() {
-        return false;
-    }
-    buildValues(lastComponent, newTokens, oldTokens) {
-        // First we convert our linked list of components in reverse order to an
-        // array in the right order:
-        const components = [];
-        let nextComponent;
-        while (lastComponent) {
-            components.push(lastComponent);
-            nextComponent = lastComponent.previousComponent;
-            delete lastComponent.previousComponent;
-            lastComponent = nextComponent;
-        }
-        components.reverse();
-        const componentLen = components.length;
-        let componentPos = 0, newPos = 0, oldPos = 0;
-        for (; componentPos < componentLen; componentPos++) {
-            const component = components[componentPos];
-            if (!component.removed) {
-                if (!component.added && this.useLongestToken) {
-                    let value = newTokens.slice(newPos, newPos + component.count);
-                    value = value.map(function (value, i) {
-                        const oldValue = oldTokens[oldPos + i];
-                        return oldValue.length > value.length ? oldValue : value;
-                    });
-                    component.value = this.join(value);
-                }
-                else {
-                    component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-                }
-                newPos += component.count;
-                // Common case
-                if (!component.added) {
-                    oldPos += component.count;
-                }
-            }
-            else {
-                component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-                oldPos += component.count;
-            }
-        }
-        return components;
-    }
-}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/character.d.ts

@@ -1,19 +0,0 @@
-import Diff from './base.js';
-import type { ChangeObject, CallbackOptionAbortable, CallbackOptionNonabortable, DiffCallbackNonabortable, DiffCharsOptionsAbortable, DiffCharsOptionsNonabortable } from '../types.js';
-declare class CharacterDiff extends Diff<string, string> {
-}
-export declare const characterDiff: CharacterDiff;
-/**
- * diffs two blocks of text, treating each character as a token.
- *
- * ("Characters" here means Unicode code points - the elements you get when you loop over a string with a `for ... of ...` loop.)
- *
- * @returns a list of change objects.
- */
-export declare function diffChars(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffChars(oldStr: string, newStr: string, options: DiffCharsOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffChars(oldStr: string, newStr: string, options: DiffCharsOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffChars(oldStr: string, newStr: string, options: DiffCharsOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffChars(oldStr: string, newStr: string, options?: DiffCharsOptionsNonabortable): ChangeObject<string>[];
-export {};
-//# sourceMappingURL=character.d.ts.map

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/character.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"character.d.ts","sourceRoot":"","sources":["../../src/diff/character.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;AAEvL,cAAM,aAAc,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;CAAG;AAEnD,eAAO,MAAM,aAAa,eAAsB,CAAC;AAEjD;;;;;;GAMG;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"}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/character.js

@@ -1,7 +0,0 @@
-import Diff from './base.js';
-class CharacterDiff extends Diff {
-}
-export const characterDiff = new CharacterDiff();
-export function diffChars(oldStr, newStr, options) {
-    return characterDiff.diff(oldStr, newStr, options);
-}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/css.d.ts

@@ -1,18 +0,0 @@
-import Diff from './base.js';
-import type { ChangeObject, CallbackOptionAbortable, CallbackOptionNonabortable, DiffCallbackNonabortable, DiffCssOptionsAbortable, DiffCssOptionsNonabortable } from '../types.js';
-declare class CssDiff extends Diff<string, string> {
-    tokenize(value: string): string[];
-}
-export declare const cssDiff: CssDiff;
-/**
- * diffs two blocks of text, comparing CSS tokens.
- *
- * @returns a list of change objects.
- */
-export declare function diffCss(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffCss(oldStr: string, newStr: string, options: DiffCssOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffCss(oldStr: string, newStr: string, options: DiffCssOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffCss(oldStr: string, newStr: string, options: DiffCssOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffCss(oldStr: string, newStr: string, options?: DiffCssOptionsNonabortable): ChangeObject<string>[];
-export {};
-//# sourceMappingURL=css.d.ts.map

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/css.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../src/diff/css.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,0BAA0B,EAAC,MAAM,aAAa,CAAC;AAEnL,cAAM,OAAQ,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM;CAGvB;AAED,eAAO,MAAM,OAAO,SAAgB,CAAC;AAErC;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,uBAAuB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACjE,SAAS,CAAA;AACZ,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,0BAA0B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACvE,SAAS,CAAA;AACZ,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,uBAAuB,GAC/B,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,OAAO,CACrB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,0BAA0B,GACnC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA"}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/css.js

@@ -1,10 +0,0 @@
-import Diff from './base.js';
-class CssDiff extends Diff {
-    tokenize(value) {
-        return value.split(/([{}:;,]|\s+)/);
-    }
-}
-export const cssDiff = new CssDiff();
-export function diffCss(oldStr, newStr, options) {
-    return cssDiff.diff(oldStr, newStr, options);
-}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/json.d.ts

@@ -1,24 +0,0 @@
-import Diff from './base.js';
-import type { ChangeObject, CallbackOptionAbortable, CallbackOptionNonabortable, DiffCallbackNonabortable, DiffJsonOptionsAbortable, DiffJsonOptionsNonabortable } from '../types.js';
-import { tokenize } from './line.js';
-declare class JsonDiff extends Diff<string, string, string | object> {
-    get useLongestToken(): boolean;
-    tokenize: typeof tokenize;
-    castInput(value: string | object, options: DiffJsonOptionsNonabortable | DiffJsonOptionsAbortable): string;
-    equals(left: string, right: string, options: DiffJsonOptionsNonabortable | DiffJsonOptionsAbortable): boolean;
-}
-export declare const jsonDiff: JsonDiff;
-/**
- * diffs two JSON-serializable objects by first serializing them to prettily-formatted JSON and then treating each line of the JSON as a token.
- * Object properties are ordered alphabetically in the serialized JSON, so the order of properties in the objects being compared doesn't affect the result.
- *
- * @returns a list of change objects.
- */
-export declare function diffJson(oldStr: string | object, newStr: string | object, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffJson(oldStr: string | object, newStr: string | object, options: DiffJsonOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffJson(oldStr: string | object, newStr: string | object, options: DiffJsonOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffJson(oldStr: string | object, newStr: string | object, options: DiffJsonOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffJson(oldStr: string | object, newStr: string | object, options?: DiffJsonOptionsNonabortable): ChangeObject<string>[];
-export declare function canonicalize(obj: any, stack: Array<any> | null, replacementStack: Array<any> | null, replacer: (k: string, v: any) => any, key?: string): any;
-export {};
-//# sourceMappingURL=json.d.ts.map

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/json.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../src/diff/json.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,wBAAwB,EAAE,2BAA2B,EAAC,MAAM,aAAa,CAAC;AACrL,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAErC,cAAM,QAAS,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1D,IAAI,eAAe,YAIlB;IAED,QAAQ,kBAAY;IAEpB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,2BAA2B,GAAG,wBAAwB;IAMjG,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,2BAA2B,GAAG,wBAAwB;CAGpG;AAED,eAAO,MAAM,QAAQ,UAAiB,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,EAAE,wBAAwB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GAClE,SAAS,CAAA;AACZ,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,EAAE,2BAA2B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACxE,SAAS,CAAA;AACZ,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,EAAE,wBAAwB,GAChC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,QAAQ,CACtB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,OAAO,CAAC,EAAE,2BAA2B,GACpC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA;AAQzB,wBAAgB,YAAY,CAC1B,GAAG,EAAE,GAAG,EACR,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,EAAE,gBAAgB,EAAE,KAAK,CAAC,GAAG,CAAC,GAAG,IAAI,EAC7D,QAAQ,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,GAAG,KAAK,GAAG,EACpC,GAAG,CAAC,EAAE,MAAM,OA0Db"}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/json.js

@@ -1,78 +0,0 @@
-import Diff from './base.js';
-import { tokenize } from './line.js';
-class JsonDiff extends Diff {
-    constructor() {
-        super(...arguments);
-        this.tokenize = tokenize;
-    }
-    get useLongestToken() {
-        // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
-        // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
-        return true;
-    }
-    castInput(value, options) {
-        const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === 'undefined' ? undefinedReplacement : v } = options;
-        return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, '  ');
-    }
-    equals(left, right, options) {
-        return super.equals(left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'), options);
-    }
-}
-export const jsonDiff = new JsonDiff();
-export function diffJson(oldStr, newStr, options) {
-    return jsonDiff.diff(oldStr, newStr, options);
-}
-// This function handles the presence of circular references by bailing out when encountering an
-// object that is already on the "stack" of items being processed. Accepts an optional replacer
-export function canonicalize(obj, stack, replacementStack, replacer, key) {
-    stack = stack || [];
-    replacementStack = replacementStack || [];
-    if (replacer) {
-        obj = replacer(key === undefined ? '' : key, obj);
-    }
-    let i;
-    for (i = 0; i < stack.length; i += 1) {
-        if (stack[i] === obj) {
-            return replacementStack[i];
-        }
-    }
-    let canonicalizedObj;
-    if ('[object Array]' === Object.prototype.toString.call(obj)) {
-        stack.push(obj);
-        canonicalizedObj = new Array(obj.length);
-        replacementStack.push(canonicalizedObj);
-        for (i = 0; i < obj.length; i += 1) {
-            canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));
-        }
-        stack.pop();
-        replacementStack.pop();
-        return canonicalizedObj;
-    }
-    if (obj && obj.toJSON) {
-        obj = obj.toJSON();
-    }
-    if (typeof obj === 'object' && obj !== null) {
-        stack.push(obj);
-        canonicalizedObj = {};
-        replacementStack.push(canonicalizedObj);
-        const sortedKeys = [];
-        let key;
-        for (key in obj) {
-            /* istanbul ignore else */
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                sortedKeys.push(key);
-            }
-        }
-        sortedKeys.sort();
-        for (i = 0; i < sortedKeys.length; i += 1) {
-            key = sortedKeys[i];
-            canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack, replacer, key);
-        }
-        stack.pop();
-        replacementStack.pop();
-    }
-    else {
-        canonicalizedObj = obj;
-    }
-    return canonicalizedObj;
-}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/line.d.ts

@@ -1,24 +0,0 @@
-import Diff from './base.js';
-import type { ChangeObject, CallbackOptionAbortable, CallbackOptionNonabortable, DiffCallbackNonabortable, DiffLinesOptionsAbortable, DiffLinesOptionsNonabortable } from '../types.js';
-declare class LineDiff extends Diff<string, string> {
-    tokenize: typeof tokenize;
-    equals(left: string, right: string, options: DiffLinesOptionsAbortable | DiffLinesOptionsNonabortable): boolean;
-}
-export declare const lineDiff: LineDiff;
-/**
- * diffs two blocks of text, treating each line as a token.
- * @returns a list of change objects.
- */
-export declare function diffLines(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffLines(oldStr: string, newStr: string, options: DiffLinesOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffLines(oldStr: string, newStr: string, options: DiffLinesOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffLines(oldStr: string, newStr: string, options: DiffLinesOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffLines(oldStr: string, newStr: string, options?: DiffLinesOptionsNonabortable): ChangeObject<string>[];
-export declare function diffTrimmedLines(oldStr: string, newStr: string, options: DiffCallbackNonabortable<string>): undefined;
-export declare function diffTrimmedLines(oldStr: string, newStr: string, options: DiffLinesOptionsAbortable & CallbackOptionAbortable<string>): undefined;
-export declare function diffTrimmedLines(oldStr: string, newStr: string, options: DiffLinesOptionsNonabortable & CallbackOptionNonabortable<string>): undefined;
-export declare function diffTrimmedLines(oldStr: string, newStr: string, options: DiffLinesOptionsAbortable): ChangeObject<string>[] | undefined;
-export declare function diffTrimmedLines(oldStr: string, newStr: string, options?: DiffLinesOptionsNonabortable): ChangeObject<string>[];
-export declare function tokenize(value: string, options: DiffLinesOptionsAbortable | DiffLinesOptionsNonabortable): string[];
-export {};
-//# sourceMappingURL=line.d.ts.map

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/line.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"line.d.ts","sourceRoot":"","sources":["../../src/diff/line.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;AAGvL,cAAM,QAAS,SAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC;IACzC,QAAQ,kBAAY;IAEpB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB,GAAG,4BAA4B;CAyBtG;AAED,eAAO,MAAM,QAAQ,UAAiB,CAAC;AAEvC;;;GAGG;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;AAWzB,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,wBAAwB,CAAC,MAAM,CAAC,GACxC,SAAS,CAAC;AACb,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GAAG,uBAAuB,CAAC,MAAM,CAAC,GACnE,SAAS,CAAA;AACZ,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,4BAA4B,GAAG,0BAA0B,CAAC,MAAM,CAAC,GACzE,SAAS,CAAA;AACZ,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,yBAAyB,GACjC,YAAY,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAA;AACrC,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,4BAA4B,GACrC,YAAY,CAAC,MAAM,CAAC,EAAE,CAAA;AAOzB,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB,GAAG,4BAA4B,YA0BxG"}

package/mcp/code-mcp-pr/node_modules/diff/libesm/diff/line.js

@@ -1,65 +0,0 @@
-import Diff from './base.js';
-import { generateOptions } from '../util/params.js';
-class LineDiff extends Diff {
-    constructor() {
-        super(...arguments);
-        this.tokenize = tokenize;
-    }
-    equals(left, right, options) {
-        // If we're ignoring whitespace, we need to normalise lines by stripping
-        // whitespace before checking equality. (This has an annoying interaction
-        // with newlineIsToken that requires special handling: if newlines get their
-        // own token, then we DON'T want to trim the *newline* tokens down to empty
-        // strings, since this would cause us to treat whitespace-only line content
-        // as equal to a separator between lines, which would be weird and
-        // inconsistent with the documented behavior of the options.)
-        if (options.ignoreWhitespace) {
-            if (!options.newlineIsToken || !left.includes('\n')) {
-                left = left.trim();
-            }
-            if (!options.newlineIsToken || !right.includes('\n')) {
-                right = right.trim();
-            }
-        }
-        else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-            if (left.endsWith('\n')) {
-                left = left.slice(0, -1);
-            }
-            if (right.endsWith('\n')) {
-                right = right.slice(0, -1);
-            }
-        }
-        return super.equals(left, right, options);
-    }
-}
-export const lineDiff = new LineDiff();
-export function diffLines(oldStr, newStr, options) {
-    return lineDiff.diff(oldStr, newStr, options);
-}
-export function diffTrimmedLines(oldStr, newStr, options) {
-    options = generateOptions(options, { ignoreWhitespace: true });
-    return lineDiff.diff(oldStr, newStr, options);
-}
-// Exported standalone so it can be used from jsonDiff too.
-export function tokenize(value, options) {
-    if (options.stripTrailingCr) {
-        // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior
-        value = value.replace(/\r\n/g, '\n');
-    }
-    const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-    // Ignore the final empty token that occurs if the string ends with a new line
-    if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-        linesAndNewlines.pop();
-    }
-    // Merge the content and line separators into single tokens
-    for (let i = 0; i < linesAndNewlines.length; i++) {
-        const line = linesAndNewlines[i];
-        if (i % 2 && !options.newlineIsToken) {
-            retLines[retLines.length - 1] += line;
-        }
-        else {
-            retLines.push(line);
-        }
-    }
-    return retLines;
-}