@posthog/agent 1.24.2 → 1.26.0

package/dist/node_modules/diff/libesm/diff/base.js

@@ -0,0 +1,256 @@
+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;
+    }
+}
+
+export { Diff as default };
+//# sourceMappingURL=base.js.map

package/dist/node_modules/diff/libesm/diff/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sources":["../../../../../../../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"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/diff/libesm/diff/line.js

@@ -0,0 +1,64 @@
+import Diff from './base.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);
+    }
+}
+const lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+    return lineDiff.diff(oldStr, newStr, options);
+}
+// Exported standalone so it can be used from jsonDiff too.
+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;
+}
+
+export { diffLines, lineDiff, tokenize };
+//# sourceMappingURL=line.js.map

package/dist/node_modules/diff/libesm/diff/line.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"line.js","sources":["../../../../../../../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"],"names":[],"mappings":";;AAEA,MAAM,QAAQ,SAAS,IAAI,CAAC;AAC5B,IAAI,WAAW,GAAG;AAClB,QAAQ,KAAK,CAAC,GAAG,SAAS,CAAC;AAC3B,QAAQ,IAAI,CAAC,QAAQ,GAAG,QAAQ;AAChC,IAAI;AACJ,IAAI,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE;AACjC;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ,IAAI,OAAO,CAAC,gBAAgB,EAAE;AACtC,YAAY,IAAI,CAAC,OAAO,CAAC,cAAc,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AACjE,gBAAgB,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE;AAClC,YAAY;AACZ,YAAY,IAAI,CAAC,OAAO,CAAC,cAAc,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AAClE,gBAAgB,KAAK,GAAG,KAAK,CAAC,IAAI,EAAE;AACpC,YAAY;AACZ,QAAQ;AACR,aAAa,IAAI,OAAO,CAAC,kBAAkB,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE;AACxE,YAAY,IAAI,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AACrC,gBAAgB,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;AACxC,YAAY;AACZ,YAAY,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;AACtC,gBAAgB,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;AAC1C,YAAY;AACZ,QAAQ;AACR,QAAQ,OAAO,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC;AACjD,IAAI;AACJ;AACY,MAAC,QAAQ,GAAG,IAAI,QAAQ;AAC7B,SAAS,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE;AACnD,IAAI,OAAO,QAAQ,CAAC,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC;AACjD;AAKA;AACO,SAAS,QAAQ,CAAC,KAAK,EAAE,OAAO,EAAE;AACzC,IAAI,IAAI,OAAO,CAAC,eAAe,EAAE;AACjC;AACA,QAAQ,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC;AAC5C,IAAI;AACJ,IAAI,MAAM,QAAQ,GAAG,EAAE,EAAE,gBAAgB,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,CAAC;AACpE;AACA,IAAI,IAAI,CAAC,gBAAgB,CAAC,gBAAgB,CAAC,MAAM,GAAG,CAAC,CAAC,EAAE;AACxD,QAAQ,gBAAgB,CAAC,GAAG,EAAE;AAC9B,IAAI;AACJ;AACA,IAAI,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE;AACtD,QAAQ,MAAM,IAAI,GAAG,gBAAgB,CAAC,CAAC,CAAC;AACxC,QAAQ,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE;AAC9C,YAAY,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,IAAI,IAAI;AACjD,QAAQ;AACR,aAAa;AACb,YAAY,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC;AAC/B,QAAQ;AACR,IAAI;AACJ,IAAI,OAAO,QAAQ;AACnB;;;;","x_google_ignoreList":[0]}

package/dist/node_modules/diff/libesm/patch/create.js

@@ -0,0 +1,185 @@
+import { diffLines } from '../diff/line.js';
+
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+    let optionsObj;
+    {
+        optionsObj = {};
+    }
+    if (typeof optionsObj.context === 'undefined') {
+        optionsObj.context = 4;
+    }
+    // We copy this into its own variable to placate TypeScript, which thinks
+    // optionsObj.context might be undefined in the callbacks below.
+    const context = optionsObj.context;
+    // @ts-expect-error (runtime check for something that is correctly a static type error)
+    if (optionsObj.newlineIsToken) {
+        throw new Error('newlineIsToken may not be used with patch-generation functions, only with diffing functions');
+    }
+    if (!optionsObj.callback) {
+        return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+    }
+    else {
+        const { callback } = optionsObj;
+        diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+                const patch = diffLinesResultToPatch(diff);
+                // TypeScript is unhappy without the cast because it does not understand that `patch` may
+                // be undefined here only if `callback` is StructuredPatchCallbackAbortable:
+                callback(patch);
+            } }));
+    }
+    function diffLinesResultToPatch(diff) {
+        // STEP 1: Build up the patch with no "" lines and with the arrays
+        //         of lines containing trailing newline characters. We'll tidy up later...
+        if (!diff) {
+            return;
+        }
+        diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier
+        function contextLines(lines) {
+            return lines.map(function (entry) { return ' ' + entry; });
+        }
+        const hunks = [];
+        let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+        for (let i = 0; i < diff.length; i++) {
+            const current = diff[i], lines = current.lines || splitLines(current.value);
+            current.lines = lines;
+            if (current.added || current.removed) {
+                // If we have previous context, start with that
+                if (!oldRangeStart) {
+                    const prev = diff[i - 1];
+                    oldRangeStart = oldLine;
+                    newRangeStart = newLine;
+                    if (prev) {
+                        curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];
+                        oldRangeStart -= curRange.length;
+                        newRangeStart -= curRange.length;
+                    }
+                }
+                // Output our changes
+                for (const line of lines) {
+                    curRange.push((current.added ? '+' : '-') + line);
+                }
+                // Track the updated file position
+                if (current.added) {
+                    newLine += lines.length;
+                }
+                else {
+                    oldLine += lines.length;
+                }
+            }
+            else {
+                // Identical context lines. Track line changes
+                if (oldRangeStart) {
+                    // Close out any changes that have been output (or join overlapping)
+                    if (lines.length <= context * 2 && i < diff.length - 2) {
+                        // Overlapping
+                        for (const line of contextLines(lines)) {
+                            curRange.push(line);
+                        }
+                    }
+                    else {
+                        // end the range and output
+                        const contextSize = Math.min(lines.length, context);
+                        for (const line of contextLines(lines.slice(0, contextSize))) {
+                            curRange.push(line);
+                        }
+                        const hunk = {
+                            oldStart: oldRangeStart,
+                            oldLines: (oldLine - oldRangeStart + contextSize),
+                            newStart: newRangeStart,
+                            newLines: (newLine - newRangeStart + contextSize),
+                            lines: curRange
+                        };
+                        hunks.push(hunk);
+                        oldRangeStart = 0;
+                        newRangeStart = 0;
+                        curRange = [];
+                    }
+                }
+                oldLine += lines.length;
+                newLine += lines.length;
+            }
+        }
+        // Step 2: eliminate the trailing `\n` from each line of each hunk, and, where needed, add
+        //         "".
+        for (const hunk of hunks) {
+            for (let i = 0; i < hunk.lines.length; i++) {
+                if (hunk.lines[i].endsWith('\n')) {
+                    hunk.lines[i] = hunk.lines[i].slice(0, -1);
+                }
+                else {
+                    hunk.lines.splice(i + 1, 0, '\');
+                    i++; // Skip the line we just added, then continue iterating
+                }
+            }
+        }
+        return {
+            oldFileName: oldFileName, newFileName: newFileName,
+            oldHeader: oldHeader, newHeader: newHeader,
+            hunks: hunks
+        };
+    }
+}
+/**
+ * creates a unified diff patch.
+ * @param patch either a single structured patch object (as returned by `structuredPatch`) or an array of them (as returned by `parsePatch`)
+ */
+function formatPatch(patch) {
+    if (Array.isArray(patch)) {
+        return patch.map(formatPatch).join('\n');
+    }
+    const ret = [];
+    if (patch.oldFileName == patch.newFileName) {
+        ret.push('Index: ' + patch.oldFileName);
+    }
+    ret.push('===================================================================');
+    ret.push('--- ' + patch.oldFileName + (typeof patch.oldHeader === 'undefined' ? '' : '\t' + patch.oldHeader));
+    ret.push('+++ ' + patch.newFileName + (typeof patch.newHeader === 'undefined' ? '' : '\t' + patch.newHeader));
+    for (let i = 0; i < patch.hunks.length; i++) {
+        const hunk = patch.hunks[i];
+        // Unified Diff Format quirk: If the chunk size is 0,
+        // the first number is one lower than one would expect.
+        // https://www.artima.com/weblogs/viewpost.jsp?thread=164293
+        if (hunk.oldLines === 0) {
+            hunk.oldStart -= 1;
+        }
+        if (hunk.newLines === 0) {
+            hunk.newStart -= 1;
+        }
+        ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines
+            + ' +' + hunk.newStart + ',' + hunk.newLines
+            + ' @@');
+        for (const line of hunk.lines) {
+            ret.push(line);
+        }
+    }
+    return ret.join('\n') + '\n';
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+    {
+        const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader);
+        if (!patchObj) {
+            return;
+        }
+        return formatPatch(patchObj);
+    }
+}
+function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {
+    return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader);
+}
+/**
+ * Split `text` into an array of lines, including the trailing newline character (where present)
+ */
+function splitLines(text) {
+    const hasTrailingNl = text.endsWith('\n');
+    const result = text.split('\n').map(line => line + '\n');
+    if (hasTrailingNl) {
+        result.pop();
+    }
+    else {
+        result.push(result.pop().slice(0, -1));
+    }
+    return result;
+}
+
+export { createPatch, createTwoFilesPatch, formatPatch, structuredPatch };
+//# sourceMappingURL=create.js.map

package/dist/node_modules/diff/libesm/patch/create.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create.js","sources":["../../../../../../../node_modules/diff/libesm/patch/create.js"],"sourcesContent":["import { diffLines } from '../diff/line.js';\nexport function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n    let optionsObj;\n    if (!options) {\n        optionsObj = {};\n    }\n    else if (typeof options === 'function') {\n        optionsObj = { callback: options };\n    }\n    else {\n        optionsObj = options;\n    }\n    if (typeof optionsObj.context === 'undefined') {\n        optionsObj.context = 4;\n    }\n    // We copy this into its own variable to placate TypeScript, which thinks\n    // optionsObj.context might be undefined in the callbacks below.\n    const context = optionsObj.context;\n    // @ts-expect-error (runtime check for something that is correctly a static type error)\n    if (optionsObj.newlineIsToken) {\n        throw new Error('newlineIsToken may not be used with patch-generation functions, only with diffing functions');\n    }\n    if (!optionsObj.callback) {\n        return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));\n    }\n    else {\n        const { callback } = optionsObj;\n        diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {\n                const patch = diffLinesResultToPatch(diff);\n                // TypeScript is unhappy without the cast because it does not understand that `patch` may\n                // be undefined here only if `callback` is StructuredPatchCallbackAbortable:\n                callback(patch);\n            } }));\n    }\n    function diffLinesResultToPatch(diff) {\n        // STEP 1: Build up the patch with no \"\\" lines and with the arrays\n        //         of lines containing trailing newline characters. We'll tidy up later...\n        if (!diff) {\n            return;\n        }\n        diff.push({ value: '', lines: [] }); // Append an empty value to make cleanup easier\n        function contextLines(lines) {\n            return lines.map(function (entry) { return ' ' + entry; });\n        }\n        const hunks = [];\n        let oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;\n        for (let i = 0; i < diff.length; i++) {\n            const current = diff[i], lines = current.lines || splitLines(current.value);\n            current.lines = lines;\n            if (current.added || current.removed) {\n                // If we have previous context, start with that\n                if (!oldRangeStart) {\n                    const prev = diff[i - 1];\n                    oldRangeStart = oldLine;\n                    newRangeStart = newLine;\n                    if (prev) {\n                        curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [];\n                        oldRangeStart -= curRange.length;\n                        newRangeStart -= curRange.length;\n                    }\n                }\n                // Output our changes\n                for (const line of lines) {\n                    curRange.push((current.added ? '+' : '-') + line);\n                }\n                // Track the updated file position\n                if (current.added) {\n                    newLine += lines.length;\n                }\n                else {\n                    oldLine += lines.length;\n                }\n            }\n            else {\n                // Identical context lines. Track line changes\n                if (oldRangeStart) {\n                    // Close out any changes that have been output (or join overlapping)\n                    if (lines.length <= context * 2 && i < diff.length - 2) {\n                        // Overlapping\n                        for (const line of contextLines(lines)) {\n                            curRange.push(line);\n                        }\n                    }\n                    else {\n                        // end the range and output\n                        const contextSize = Math.min(lines.length, context);\n                        for (const line of contextLines(lines.slice(0, contextSize))) {\n                            curRange.push(line);\n                        }\n                        const hunk = {\n                            oldStart: oldRangeStart,\n                            oldLines: (oldLine - oldRangeStart + contextSize),\n                            newStart: newRangeStart,\n                            newLines: (newLine - newRangeStart + contextSize),\n                            lines: curRange\n                        };\n                        hunks.push(hunk);\n                        oldRangeStart = 0;\n                        newRangeStart = 0;\n                        curRange = [];\n                    }\n                }\n                oldLine += lines.length;\n                newLine += lines.length;\n            }\n        }\n        // Step 2: eliminate the trailing `\\n` from each line of each hunk, and, where needed, add\n        //         \"\\".\n        for (const hunk of hunks) {\n            for (let i = 0; i < hunk.lines.length; i++) {\n                if (hunk.lines[i].endsWith('\\n')) {\n                    hunk.lines[i] = hunk.lines[i].slice(0, -1);\n                }\n                else {\n                    hunk.lines.splice(i + 1, 0, '\\\');\n                    i++; // Skip the line we just added, then continue iterating\n                }\n            }\n        }\n        return {\n            oldFileName: oldFileName, newFileName: newFileName,\n            oldHeader: oldHeader, newHeader: newHeader,\n            hunks: hunks\n        };\n    }\n}\n/**\n * creates a unified diff patch.\n * @param patch either a single structured patch object (as returned by `structuredPatch`) or an array of them (as returned by `parsePatch`)\n */\nexport function formatPatch(patch) {\n    if (Array.isArray(patch)) {\n        return patch.map(formatPatch).join('\\n');\n    }\n    const ret = [];\n    if (patch.oldFileName == patch.newFileName) {\n        ret.push('Index: ' + patch.oldFileName);\n    }\n    ret.push('===================================================================');\n    ret.push('--- ' + patch.oldFileName + (typeof patch.oldHeader === 'undefined' ? '' : '\\t' + patch.oldHeader));\n    ret.push('+++ ' + patch.newFileName + (typeof patch.newHeader === 'undefined' ? '' : '\\t' + patch.newHeader));\n    for (let i = 0; i < patch.hunks.length; i++) {\n        const hunk = patch.hunks[i];\n        // Unified Diff Format quirk: If the chunk size is 0,\n        // the first number is one lower than one would expect.\n        // https://www.artima.com/weblogs/viewpost.jsp?thread=164293\n        if (hunk.oldLines === 0) {\n            hunk.oldStart -= 1;\n        }\n        if (hunk.newLines === 0) {\n            hunk.newStart -= 1;\n        }\n        ret.push('@@ -' + hunk.oldStart + ',' + hunk.oldLines\n            + ' +' + hunk.newStart + ',' + hunk.newLines\n            + ' @@');\n        for (const line of hunk.lines) {\n            ret.push(line);\n        }\n    }\n    return ret.join('\\n') + '\\n';\n}\nexport function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {\n    if (typeof options === 'function') {\n        options = { callback: options };\n    }\n    if (!(options === null || options === void 0 ? void 0 : options.callback)) {\n        const patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);\n        if (!patchObj) {\n            return;\n        }\n        return formatPatch(patchObj);\n    }\n    else {\n        const { callback } = options;\n        structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: patchObj => {\n                if (!patchObj) {\n                    callback(undefined);\n                }\n                else {\n                    callback(formatPatch(patchObj));\n                }\n            } }));\n    }\n}\nexport function createPatch(fileName, oldStr, newStr, oldHeader, newHeader, options) {\n    return createTwoFilesPatch(fileName, fileName, oldStr, newStr, oldHeader, newHeader, options);\n}\n/**\n * Split `text` into an array of lines, including the trailing newline character (where present)\n */\nfunction splitLines(text) {\n    const hasTrailingNl = text.endsWith('\\n');\n    const result = text.split('\\n').map(line => line + '\\n');\n    if (hasTrailingNl) {\n        result.pop();\n    }\n    else {\n        result.push(result.pop().slice(0, -1));\n    }\n    return result;\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/fast-deep-equal/index.js

@@ -0,0 +1,47 @@
+// do not edit .js files directly - edit src/index.jst
+
+
+
+var fastDeepEqual = function equal(a, b) {
+  if (a === b) return true;
+
+  if (a && b && typeof a == 'object' && typeof b == 'object') {
+    if (a.constructor !== b.constructor) return false;
+
+    var length, i, keys;
+    if (Array.isArray(a)) {
+      length = a.length;
+      if (length != b.length) return false;
+      for (i = length; i-- !== 0;)
+        if (!equal(a[i], b[i])) return false;
+      return true;
+    }
+
+
+
+    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
+    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
+
+    keys = Object.keys(a);
+    length = keys.length;
+    if (length !== Object.keys(b).length) return false;
+
+    for (i = length; i-- !== 0;)
+      if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+
+    for (i = length; i-- !== 0;) {
+      var key = keys[i];
+
+      if (!equal(a[key], b[key])) return false;
+    }
+
+    return true;
+  }
+
+  // true if both NaN, false otherwise
+  return a!==a && b!==b;
+};
+
+export { fastDeepEqual as f };
+//# sourceMappingURL=index.js.map