@inkeep/agents-cli 0.63.3 → 0.64.1

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/base.js

@@ -1,181 +0,0 @@
-//#region ../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/base.js
-var Diff = class {
-	diff(oldStr, newStr, options = {}) {
-		let callback;
-		if (typeof options === "function") {
-			callback = options;
-			options = {};
-		} else if ("callback" in options) callback = options.callback;
-		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;
-			} 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: void 0
-		}];
-		let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-		if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-		let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-		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) bestPath[diagonalPath - 1] = void 0;
-				let canAdd = false;
-				if (addPath) {
-					const addPathNewPos = addPath.oldPos - diagonalPath;
-					canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-				}
-				const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-				if (!canAdd && !canRemove) {
-					bestPath[diagonalPath] = void 0;
-					continue;
-				}
-				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) 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++;
-		};
-		if (callback) (function exec() {
-			setTimeout(function() {
-				if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) return callback(void 0);
-				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,
-				removed,
-				previousComponent: last.previousComponent
-			}
-		};
-		else return {
-			oldPos: path.oldPos + oldPosInc,
-			lastComponent: {
-				count: 1,
-				added,
-				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;
-	}
-	castInput(value, options) {
-		return value;
-	}
-	tokenize(value, options) {
-		return Array.from(value);
-	}
-	join(chars) {
-		return chars.join("");
-	}
-	postProcess(changeObjects, options) {
-		return changeObjects;
-	}
-	get useLongestToken() {
-		return false;
-	}
-	buildValues(lastComponent, newTokens, oldTokens) {
-		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$1, i) {
-						const oldValue = oldTokens[oldPos + i];
-						return oldValue.length > value$1.length ? oldValue : value$1;
-					});
-					component.value = this.join(value);
-				} else component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-				newPos += component.count;
-				if (!component.added) oldPos += component.count;
-			} else {
-				component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-				oldPos += component.count;
-			}
-		}
-		return components;
-	}
-};
-
-//#endregion
-export { Diff as default };
-//# sourceMappingURL=base.js.map

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/base.js.map

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

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/character.js

@@ -1,9 +0,0 @@
-import Diff from "./base.js";
-
-//#region ../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/character.js
-var CharacterDiff = class extends Diff {};
-const characterDiff = new CharacterDiff();
-
-//#endregion
-export {  };
-//# sourceMappingURL=character.js.map

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/character.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"character.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/character.js"],"sourcesContent":["import Diff from './base.js';\nclass CharacterDiff extends Diff {\n}\nexport const characterDiff = new CharacterDiff();\nexport function diffChars(oldStr, newStr, options) {\n    return characterDiff.diff(oldStr, newStr, options);\n}\n"],"x_google_ignoreList":[0],"mappings":";;;AACA,IAAM,gBAAN,cAA4B,KAAK;AAEjC,MAAa,gBAAgB,IAAI,eAAe"}

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/css.js

@@ -1,13 +0,0 @@
-import Diff from "./base.js";
-
-//#region ../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/css.js
-var CssDiff = class extends Diff {
-	tokenize(value) {
-		return value.split(/([{}:;,]|\s+)/);
-	}
-};
-const cssDiff = new CssDiff();
-
-//#endregion
-export {  };
-//# sourceMappingURL=css.js.map

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/css.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"css.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/css.js"],"sourcesContent":["import Diff from './base.js';\nclass CssDiff extends Diff {\n    tokenize(value) {\n        return value.split(/([{}:;,]|\\s+)/);\n    }\n}\nexport const cssDiff = new CssDiff();\nexport function diffCss(oldStr, newStr, options) {\n    return cssDiff.diff(oldStr, newStr, options);\n}\n"],"x_google_ignoreList":[0],"mappings":";;;AACA,IAAM,UAAN,cAAsB,KAAK;CACvB,SAAS,OAAO;AACZ,SAAO,MAAM,MAAM,gBAAgB;;;AAG3C,MAAa,UAAU,IAAI,SAAS"}

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/json.js

@@ -1,61 +0,0 @@
-import Diff from "./base.js";
-import { tokenize } from "./line.js";
-
-//#region ../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/json.js
-var JsonDiff = class extends Diff {
-	constructor() {
-		super(...arguments);
-		this.tokenize = tokenize;
-	}
-	get useLongestToken() {
-		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);
-	}
-};
-const jsonDiff = new JsonDiff();
-function canonicalize(obj, stack, replacementStack, replacer, key) {
-	stack = stack || [];
-	replacementStack = replacementStack || [];
-	if (replacer) obj = replacer(key === void 0 ? "" : 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$1;
-		for (key$1 in obj)
- /* istanbul ignore else */
-		if (Object.prototype.hasOwnProperty.call(obj, key$1)) sortedKeys.push(key$1);
-		sortedKeys.sort();
-		for (i = 0; i < sortedKeys.length; i += 1) {
-			key$1 = sortedKeys[i];
-			canonicalizedObj[key$1] = canonicalize(obj[key$1], stack, replacementStack, replacer, key$1);
-		}
-		stack.pop();
-		replacementStack.pop();
-	} else canonicalizedObj = obj;
-	return canonicalizedObj;
-}
-
-//#endregion
-export { canonicalize };
-//# sourceMappingURL=json.js.map

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.js","names":["key"],"sources":["../../../../../../../../../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/json.js"],"sourcesContent":["import Diff from './base.js';\nimport { tokenize } from './line.js';\nclass JsonDiff extends Diff {\n    constructor() {\n        super(...arguments);\n        this.tokenize = tokenize;\n    }\n    get useLongestToken() {\n        // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a\n        // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:\n        return true;\n    }\n    castInput(value, options) {\n        const { undefinedReplacement, stringifyReplacer = (k, v) => typeof v === 'undefined' ? undefinedReplacement : v } = options;\n        return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), null, '  ');\n    }\n    equals(left, right, options) {\n        return super.equals(left.replace(/,([\\r\\n])/g, '$1'), right.replace(/,([\\r\\n])/g, '$1'), options);\n    }\n}\nexport const jsonDiff = new JsonDiff();\nexport function diffJson(oldStr, newStr, options) {\n    return jsonDiff.diff(oldStr, newStr, options);\n}\n// This function handles the presence of circular references by bailing out when encountering an\n// object that is already on the \"stack\" of items being processed. Accepts an optional replacer\nexport function canonicalize(obj, stack, replacementStack, replacer, key) {\n    stack = stack || [];\n    replacementStack = replacementStack || [];\n    if (replacer) {\n        obj = replacer(key === undefined ? '' : key, obj);\n    }\n    let i;\n    for (i = 0; i < stack.length; i += 1) {\n        if (stack[i] === obj) {\n            return replacementStack[i];\n        }\n    }\n    let canonicalizedObj;\n    if ('[object Array]' === Object.prototype.toString.call(obj)) {\n        stack.push(obj);\n        canonicalizedObj = new Array(obj.length);\n        replacementStack.push(canonicalizedObj);\n        for (i = 0; i < obj.length; i += 1) {\n            canonicalizedObj[i] = canonicalize(obj[i], stack, replacementStack, replacer, String(i));\n        }\n        stack.pop();\n        replacementStack.pop();\n        return canonicalizedObj;\n    }\n    if (obj && obj.toJSON) {\n        obj = obj.toJSON();\n    }\n    if (typeof obj === 'object' && obj !== null) {\n        stack.push(obj);\n        canonicalizedObj = {};\n        replacementStack.push(canonicalizedObj);\n        const sortedKeys = [];\n        let key;\n        for (key in obj) {\n            /* istanbul ignore else */\n            if (Object.prototype.hasOwnProperty.call(obj, key)) {\n                sortedKeys.push(key);\n            }\n        }\n        sortedKeys.sort();\n        for (i = 0; i < sortedKeys.length; i += 1) {\n            key = sortedKeys[i];\n            canonicalizedObj[key] = canonicalize(obj[key], stack, replacementStack, replacer, key);\n        }\n        stack.pop();\n        replacementStack.pop();\n    }\n    else {\n        canonicalizedObj = obj;\n    }\n    return canonicalizedObj;\n}\n"],"x_google_ignoreList":[0],"mappings":";;;;AAEA,IAAM,WAAN,cAAuB,KAAK;CACxB,cAAc;AACV,QAAM,GAAG,UAAU;AACnB,OAAK,WAAW;;CAEpB,IAAI,kBAAkB;AAGlB,SAAO;;CAEX,UAAU,OAAO,SAAS;EACtB,MAAM,EAAE,sBAAsB,qBAAqB,GAAG,MAAM,OAAO,MAAM,cAAc,uBAAuB,MAAM;AACpH,SAAO,OAAO,UAAU,WAAW,QAAQ,KAAK,UAAU,aAAa,OAAO,MAAM,MAAM,kBAAkB,EAAE,MAAM,KAAK;;CAE7H,OAAO,MAAM,OAAO,SAAS;AACzB,SAAO,MAAM,OAAO,KAAK,QAAQ,cAAc,KAAK,EAAE,MAAM,QAAQ,cAAc,KAAK,EAAE,QAAQ;;;AAGzG,MAAa,WAAW,IAAI,UAAU;AAMtC,SAAgB,aAAa,KAAK,OAAO,kBAAkB,UAAU,KAAK;AACtE,SAAQ,SAAS,EAAE;AACnB,oBAAmB,oBAAoB,EAAE;AACzC,KAAI,SACA,OAAM,SAAS,QAAQ,SAAY,KAAK,KAAK,IAAI;CAErD,IAAI;AACJ,MAAK,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK,EAC/B,KAAI,MAAM,OAAO,IACb,QAAO,iBAAiB;CAGhC,IAAI;AACJ,KAAI,qBAAqB,OAAO,UAAU,SAAS,KAAK,IAAI,EAAE;AAC1D,QAAM,KAAK,IAAI;AACf,qBAAmB,IAAI,MAAM,IAAI,OAAO;AACxC,mBAAiB,KAAK,iBAAiB;AACvC,OAAK,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK,EAC7B,kBAAiB,KAAK,aAAa,IAAI,IAAI,OAAO,kBAAkB,UAAU,OAAO,EAAE,CAAC;AAE5F,QAAM,KAAK;AACX,mBAAiB,KAAK;AACtB,SAAO;;AAEX,KAAI,OAAO,IAAI,OACX,OAAM,IAAI,QAAQ;AAEtB,KAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM;AACzC,QAAM,KAAK,IAAI;AACf,qBAAmB,EAAE;AACrB,mBAAiB,KAAK,iBAAiB;EACvC,MAAM,aAAa,EAAE;EACrB,IAAIA;AACJ,OAAKA,SAAO;;AAER,MAAI,OAAO,UAAU,eAAe,KAAK,KAAKA,MAAI,CAC9C,YAAW,KAAKA,MAAI;AAG5B,aAAW,MAAM;AACjB,OAAK,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK,GAAG;AACvC,WAAM,WAAW;AACjB,oBAAiBA,SAAO,aAAa,IAAIA,QAAM,OAAO,kBAAkB,UAAUA,MAAI;;AAE1F,QAAM,KAAK;AACX,mBAAiB,KAAK;OAGtB,oBAAmB;AAEvB,QAAO"}

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/line.js

@@ -1,38 +0,0 @@
-import Diff from "./base.js";
-
-//#region ../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/line.js
-var LineDiff = class extends Diff {
-	constructor() {
-		super(...arguments);
-		this.tokenize = tokenize;
-	}
-	equals(left, right, 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);
-	}
-};
-const lineDiff = new LineDiff();
-function diffLines(oldStr, newStr, options) {
-	return lineDiff.diff(oldStr, newStr, options);
-}
-function tokenize(value, options) {
-	if (options.stripTrailingCr) value = value.replace(/\r\n/g, "\n");
-	const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-	if (!linesAndNewlines[linesAndNewlines.length - 1]) linesAndNewlines.pop();
-	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;
-}
-
-//#endregion
-export { diffLines, lineDiff, tokenize };
-//# sourceMappingURL=line.js.map

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/line.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"line.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/line.js"],"sourcesContent":["import Diff from './base.js';\nimport { generateOptions } from '../util/params.js';\nclass LineDiff extends Diff {\n    constructor() {\n        super(...arguments);\n        this.tokenize = tokenize;\n    }\n    equals(left, right, options) {\n        // If we're ignoring whitespace, we need to normalise lines by stripping\n        // whitespace before checking equality. (This has an annoying interaction\n        // with newlineIsToken that requires special handling: if newlines get their\n        // own token, then we DON'T want to trim the *newline* tokens down to empty\n        // strings, since this would cause us to treat whitespace-only line content\n        // as equal to a separator between lines, which would be weird and\n        // inconsistent with the documented behavior of the options.)\n        if (options.ignoreWhitespace) {\n            if (!options.newlineIsToken || !left.includes('\\n')) {\n                left = left.trim();\n            }\n            if (!options.newlineIsToken || !right.includes('\\n')) {\n                right = right.trim();\n            }\n        }\n        else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {\n            if (left.endsWith('\\n')) {\n                left = left.slice(0, -1);\n            }\n            if (right.endsWith('\\n')) {\n                right = right.slice(0, -1);\n            }\n        }\n        return super.equals(left, right, options);\n    }\n}\nexport const lineDiff = new LineDiff();\nexport function diffLines(oldStr, newStr, options) {\n    return lineDiff.diff(oldStr, newStr, options);\n}\nexport function diffTrimmedLines(oldStr, newStr, options) {\n    options = generateOptions(options, { ignoreWhitespace: true });\n    return lineDiff.diff(oldStr, newStr, options);\n}\n// Exported standalone so it can be used from jsonDiff too.\nexport function tokenize(value, options) {\n    if (options.stripTrailingCr) {\n        // remove one \\r before \\n to match GNU diff's --strip-trailing-cr behavior\n        value = value.replace(/\\r\\n/g, '\\n');\n    }\n    const retLines = [], linesAndNewlines = value.split(/(\\n|\\r\\n)/);\n    // Ignore the final empty token that occurs if the string ends with a new line\n    if (!linesAndNewlines[linesAndNewlines.length - 1]) {\n        linesAndNewlines.pop();\n    }\n    // Merge the content and line separators into single tokens\n    for (let i = 0; i < linesAndNewlines.length; i++) {\n        const line = linesAndNewlines[i];\n        if (i % 2 && !options.newlineIsToken) {\n            retLines[retLines.length - 1] += line;\n        }\n        else {\n            retLines.push(line);\n        }\n    }\n    return retLines;\n}\n"],"x_google_ignoreList":[0],"mappings":";;;AAEA,IAAM,WAAN,cAAuB,KAAK;CACxB,cAAc;AACV,QAAM,GAAG,UAAU;AACnB,OAAK,WAAW;;CAEpB,OAAO,MAAM,OAAO,SAAS;AAQzB,MAAI,QAAQ,kBAAkB;AAC1B,OAAI,CAAC,QAAQ,kBAAkB,CAAC,KAAK,SAAS,KAAK,CAC/C,QAAO,KAAK,MAAM;AAEtB,OAAI,CAAC,QAAQ,kBAAkB,CAAC,MAAM,SAAS,KAAK,CAChD,SAAQ,MAAM,MAAM;aAGnB,QAAQ,sBAAsB,CAAC,QAAQ,gBAAgB;AAC5D,OAAI,KAAK,SAAS,KAAK,CACnB,QAAO,KAAK,MAAM,GAAG,GAAG;AAE5B,OAAI,MAAM,SAAS,KAAK,CACpB,SAAQ,MAAM,MAAM,GAAG,GAAG;;AAGlC,SAAO,MAAM,OAAO,MAAM,OAAO,QAAQ;;;AAGjD,MAAa,WAAW,IAAI,UAAU;AACtC,SAAgB,UAAU,QAAQ,QAAQ,SAAS;AAC/C,QAAO,SAAS,KAAK,QAAQ,QAAQ,QAAQ;;AAOjD,SAAgB,SAAS,OAAO,SAAS;AACrC,KAAI,QAAQ,gBAER,SAAQ,MAAM,QAAQ,SAAS,KAAK;CAExC,MAAM,WAAW,EAAE,EAAE,mBAAmB,MAAM,MAAM,YAAY;AAEhE,KAAI,CAAC,iBAAiB,iBAAiB,SAAS,GAC5C,kBAAiB,KAAK;AAG1B,MAAK,IAAI,IAAI,GAAG,IAAI,iBAAiB,QAAQ,KAAK;EAC9C,MAAM,OAAO,iBAAiB;AAC9B,MAAI,IAAI,KAAK,CAAC,QAAQ,eAClB,UAAS,SAAS,SAAS,MAAM;MAGjC,UAAS,KAAK,KAAK;;AAG3B,QAAO"}

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/sentence.js

@@ -1,32 +0,0 @@
-import Diff from "./base.js";
-
-//#region ../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/sentence.js
-function isSentenceEndPunct(char) {
-	return char == "." || char == "!" || char == "?";
-}
-var SentenceDiff = class extends Diff {
-	tokenize(value) {
-		var _a;
-		const result = [];
-		let tokenStartI = 0;
-		for (let 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/)) {
-				result.push(value.slice(tokenStartI, i + 1));
-				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));
-				tokenStartI = i + 1;
-			}
-		}
-		return result;
-	}
-};
-const sentenceDiff = new SentenceDiff();
-
-//#endregion
-export {  };
-//# sourceMappingURL=sentence.js.map

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/sentence.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"sentence.js","names":[],"sources":["../../../../../../../../../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/sentence.js"],"sourcesContent":["import Diff from './base.js';\nfunction isSentenceEndPunct(char) {\n    return char == '.' || char == '!' || char == '?';\n}\nclass SentenceDiff extends Diff {\n    tokenize(value) {\n        var _a;\n        // If in future we drop support for environments that don't support lookbehinds, we can replace\n        // this entire function with:\n        //     return value.split(/(?<=[.!?])(\\s+|$)/);\n        // but until then, for similar reasons to the trailingWs function in string.ts, we are forced\n        // to do this verbosely \"by hand\" instead of using a regex.\n        const result = [];\n        let tokenStartI = 0;\n        for (let i = 0; i < value.length; i++) {\n            if (i == value.length - 1) {\n                result.push(value.slice(tokenStartI));\n                break;\n            }\n            if (isSentenceEndPunct(value[i]) && value[i + 1].match(/\\s/)) {\n                // We've hit a sentence break - i.e. a punctuation mark followed by whitespace.\n                // We now want to push TWO tokens to the result:\n                // 1. the sentence\n                result.push(value.slice(tokenStartI, i + 1));\n                // 2. the whitespace\n                i = tokenStartI = i + 1;\n                while ((_a = value[i + 1]) === null || _a === void 0 ? void 0 : _a.match(/\\s/)) {\n                    i++;\n                }\n                result.push(value.slice(tokenStartI, i + 1));\n                // Then the next token (a sentence) starts on the character after the whitespace.\n                // (It's okay if this is off the end of the string - then the outer loop will terminate\n                // here anyway.)\n                tokenStartI = i + 1;\n            }\n        }\n        return result;\n    }\n}\nexport const sentenceDiff = new SentenceDiff();\nexport function diffSentences(oldStr, newStr, options) {\n    return sentenceDiff.diff(oldStr, newStr, options);\n}\n"],"x_google_ignoreList":[0],"mappings":";;;AACA,SAAS,mBAAmB,MAAM;AAC9B,QAAO,QAAQ,OAAO,QAAQ,OAAO,QAAQ;;AAEjD,IAAM,eAAN,cAA2B,KAAK;CAC5B,SAAS,OAAO;EACZ,IAAI;EAMJ,MAAM,SAAS,EAAE;EACjB,IAAI,cAAc;AAClB,OAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACnC,OAAI,KAAK,MAAM,SAAS,GAAG;AACvB,WAAO,KAAK,MAAM,MAAM,YAAY,CAAC;AACrC;;AAEJ,OAAI,mBAAmB,MAAM,GAAG,IAAI,MAAM,IAAI,GAAG,MAAM,KAAK,EAAE;AAI1D,WAAO,KAAK,MAAM,MAAM,aAAa,IAAI,EAAE,CAAC;AAE5C,QAAI,cAAc,IAAI;AACtB,YAAQ,KAAK,MAAM,IAAI,QAAQ,QAAQ,OAAO,KAAK,IAAI,KAAK,IAAI,GAAG,MAAM,KAAK,CAC1E;AAEJ,WAAO,KAAK,MAAM,MAAM,aAAa,IAAI,EAAE,CAAC;AAI5C,kBAAc,IAAI;;;AAG1B,SAAO;;;AAGf,MAAa,eAAe,IAAI,cAAc"}

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/word.js

@@ -1,119 +0,0 @@
-import Diff from "./base.js";
-import { leadingWs, longestCommonPrefix, longestCommonSuffix, maximumOverlap, removePrefix, removeSuffix, replacePrefix, replaceSuffix, trailingWs } from "../util/string.js";
-
-//#region ../node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/word.js
-const 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}";
-const tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug");
-var WordDiff = class extends Diff {
-	equals(left, right, options) {
-		if (options.ignoreCase) {
-			left = left.toLowerCase();
-			right = right.toLowerCase();
-		}
-		return left.trim() === right.trim();
-	}
-	tokenize(value, options = {}) {
-		let parts;
-		if (options.intlSegmenter) {
-			const segmenter = options.intlSegmenter;
-			if (segmenter.resolvedOptions().granularity != "word") throw new Error("The segmenter passed must have a granularity of \"word\"");
-			parts = [];
-			for (const segmentObj of Array.from(segmenter.segment(value))) {
-				const 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) || [];
-		const tokens = [];
-		let prevPart = null;
-		parts.forEach((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;
-	}
-	join(tokens) {
-		return tokens.map((token, i) => {
-			if (i == 0) return token;
-			else return token.replace(/^\s+/, "");
-		}).join("");
-	}
-	postProcess(changes, options) {
-		if (!changes || options.oneChangePerToken) return changes;
-		let lastKeep = null;
-		let insertion = null;
-		let deletion = null;
-		changes.forEach((change) => {
-			if (change.added) insertion = change;
-			else if (change.removed) deletion = change;
-			else {
-				if (insertion || deletion) dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change);
-				lastKeep = change;
-				insertion = null;
-				deletion = null;
-			}
-		});
-		if (insertion || deletion) dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null);
-		return changes;
-	}
-};
-const wordDiff = new WordDiff();
-function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep) {
-	if (deletion && insertion) {
-		const oldWsPrefix = leadingWs(deletion.value);
-		const oldWsSuffix = trailingWs(deletion.value);
-		const newWsPrefix = leadingWs(insertion.value);
-		const newWsSuffix = trailingWs(insertion.value);
-		if (startKeep) {
-			const commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
-			startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix);
-			deletion.value = removePrefix(deletion.value, commonWsPrefix);
-			insertion.value = removePrefix(insertion.value, commonWsPrefix);
-		}
-		if (endKeep) {
-			const commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
-			endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix);
-			deletion.value = removeSuffix(deletion.value, commonWsSuffix);
-			insertion.value = removeSuffix(insertion.value, commonWsSuffix);
-		}
-	} else if (insertion) {
-		if (startKeep) {
-			const ws = leadingWs(insertion.value);
-			insertion.value = insertion.value.substring(ws.length);
-		}
-		if (endKeep) {
-			const ws = leadingWs(endKeep.value);
-			endKeep.value = endKeep.value.substring(ws.length);
-		}
-	} else if (startKeep && endKeep) {
-		const newWsFull = leadingWs(endKeep.value), delWsStart = leadingWs(deletion.value), delWsEnd = trailingWs(deletion.value);
-		const newWsStart = longestCommonPrefix(newWsFull, delWsStart);
-		deletion.value = removePrefix(deletion.value, newWsStart);
-		const newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
-		deletion.value = removeSuffix(deletion.value, newWsEnd);
-		endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd);
-		startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
-	} else if (endKeep) {
-		const endKeepWsPrefix = leadingWs(endKeep.value);
-		const overlap = maximumOverlap(trailingWs(deletion.value), endKeepWsPrefix);
-		deletion.value = removeSuffix(deletion.value, overlap);
-	} else if (startKeep) {
-		const overlap = maximumOverlap(trailingWs(startKeep.value), leadingWs(deletion.value));
-		deletion.value = removePrefix(deletion.value, overlap);
-	}
-}
-var WordsWithSpaceDiff = class extends Diff {
-	tokenize(value) {
-		const regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
-		return value.match(regex) || [];
-	}
-};
-const wordsWithSpaceDiff = new WordsWithSpaceDiff();
-
-//#endregion
-export {  };
-//# sourceMappingURL=word.js.map

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/diff/word.js.map

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

package/dist/node_modules/.pnpm/diff@8.0.3/node_modules/diff/libesm/index.js

@@ -1,11 +0,0 @@
-import Diff from "./diff/base.js";
-import "./diff/character.js";
-import "./diff/word.js";
-import { diffLines, lineDiff } from "./diff/line.js";
-import "./diff/sentence.js";
-import "./diff/css.js";
-import { canonicalize } from "./diff/json.js";
-import "./diff/array.js";
-import { INCLUDE_HEADERS, createTwoFilesPatch, formatPatch, structuredPatch } from "./patch/create.js";
-
-export {  };