expxagents 0.28.0 → 0.28.2

package/node_modules/jsondiffpatch/lib/filters/lcs.js

@@ -0,0 +1,74 @@
+/*
+
+LCS implementation that supports arrays or strings
+
+reference: http://en.wikipedia.org/wiki/Longest_common_subsequence_problem
+
+*/
+const defaultMatch = function (array1, array2, index1, index2) {
+    return array1[index1] === array2[index2];
+};
+const lengthMatrix = function (array1, array2, match, context) {
+    const len1 = array1.length;
+    const len2 = array2.length;
+    let x, y;
+    // initialize empty matrix of len1+1 x len2+1
+    const matrix = new Array(len1 + 1);
+    for (x = 0; x < len1 + 1; x++) {
+        matrix[x] = new Array(len2 + 1);
+        for (y = 0; y < len2 + 1; y++) {
+            matrix[x][y] = 0;
+        }
+    }
+    matrix.match = match;
+    // save sequence lengths for each coordinate
+    for (x = 1; x < len1 + 1; x++) {
+        for (y = 1; y < len2 + 1; y++) {
+            if (match(array1, array2, x - 1, y - 1, context)) {
+                matrix[x][y] = matrix[x - 1][y - 1] + 1;
+            }
+            else {
+                matrix[x][y] = Math.max(matrix[x - 1][y], matrix[x][y - 1]);
+            }
+        }
+    }
+    return matrix;
+};
+const backtrack = function (matrix, array1, array2, context) {
+    let index1 = array1.length;
+    let index2 = array2.length;
+    const subsequence = {
+        sequence: [],
+        indices1: [],
+        indices2: [],
+    };
+    while (index1 !== 0 && index2 !== 0) {
+        const sameLetter = matrix.match(array1, array2, index1 - 1, index2 - 1, context);
+        if (sameLetter) {
+            subsequence.sequence.unshift(array1[index1 - 1]);
+            subsequence.indices1.unshift(index1 - 1);
+            subsequence.indices2.unshift(index2 - 1);
+            --index1;
+            --index2;
+        }
+        else {
+            const valueAtMatrixAbove = matrix[index1][index2 - 1];
+            const valueAtMatrixLeft = matrix[index1 - 1][index2];
+            if (valueAtMatrixAbove > valueAtMatrixLeft) {
+                --index2;
+            }
+            else {
+                --index1;
+            }
+        }
+    }
+    return subsequence;
+};
+const get = function (array1, array2, match, context) {
+    const innerContext = context || {};
+    const matrix = lengthMatrix(array1, array2, match || defaultMatch, innerContext);
+    return backtrack(matrix, array1, array2, innerContext);
+};
+export default {
+    get,
+};

package/node_modules/jsondiffpatch/lib/filters/nested.d.ts

@@ -0,0 +1,10 @@
+import DiffContext from '../contexts/diff.js';
+import PatchContext from '../contexts/patch.js';
+import ReverseContext from '../contexts/reverse.js';
+import type { Filter } from '../types.js';
+export declare const collectChildrenDiffFilter: Filter<DiffContext>;
+export declare const objectsDiffFilter: Filter<DiffContext>;
+export declare const patchFilter: Filter<PatchContext>;
+export declare const collectChildrenPatchFilter: Filter<PatchContext>;
+export declare const reverseFilter: Filter<ReverseContext>;
+export declare const collectChildrenReverseFilter: Filter<ReverseContext>;

package/node_modules/jsondiffpatch/lib/filters/nested.js

@@ -0,0 +1,144 @@
+import DiffContext from '../contexts/diff.js';
+import PatchContext from '../contexts/patch.js';
+import ReverseContext from '../contexts/reverse.js';
+export const collectChildrenDiffFilter = (context) => {
+    if (!context || !context.children) {
+        return;
+    }
+    const length = context.children.length;
+    let child;
+    let result = context.result;
+    for (let index = 0; index < length; index++) {
+        child = context.children[index];
+        if (typeof child.result === 'undefined') {
+            continue;
+        }
+        result = result || {};
+        result[child.childName] = child.result;
+    }
+    if (result && context.leftIsArray) {
+        result._t = 'a';
+    }
+    context.setResult(result).exit();
+};
+collectChildrenDiffFilter.filterName = 'collectChildren';
+export const objectsDiffFilter = (context) => {
+    if (context.leftIsArray || context.leftType !== 'object') {
+        return;
+    }
+    const left = context.left;
+    const right = context.right;
+    let name;
+    let child;
+    const propertyFilter = context.options.propertyFilter;
+    for (name in left) {
+        if (!Object.prototype.hasOwnProperty.call(left, name)) {
+            continue;
+        }
+        if (propertyFilter && !propertyFilter(name, context)) {
+            continue;
+        }
+        child = new DiffContext(left[name], right[name]);
+        context.push(child, name);
+    }
+    for (name in right) {
+        if (!Object.prototype.hasOwnProperty.call(right, name)) {
+            continue;
+        }
+        if (propertyFilter && !propertyFilter(name, context)) {
+            continue;
+        }
+        if (typeof left[name] === 'undefined') {
+            child = new DiffContext(undefined, right[name]);
+            context.push(child, name);
+        }
+    }
+    if (!context.children || context.children.length === 0) {
+        context.setResult(undefined).exit();
+        return;
+    }
+    context.exit();
+};
+objectsDiffFilter.filterName = 'objects';
+export const patchFilter = function nestedPatchFilter(context) {
+    if (!context.nested) {
+        return;
+    }
+    const nestedDelta = context.delta;
+    if (nestedDelta._t) {
+        return;
+    }
+    const objectDelta = nestedDelta;
+    let name;
+    let child;
+    for (name in objectDelta) {
+        child = new PatchContext(context.left[name], objectDelta[name]);
+        context.push(child, name);
+    }
+    context.exit();
+};
+patchFilter.filterName = 'objects';
+export const collectChildrenPatchFilter = function collectChildrenPatchFilter(context) {
+    if (!context || !context.children) {
+        return;
+    }
+    const deltaWithChildren = context.delta;
+    if (deltaWithChildren._t) {
+        return;
+    }
+    const object = context.left;
+    const length = context.children.length;
+    let child;
+    for (let index = 0; index < length; index++) {
+        child = context.children[index];
+        const property = child.childName;
+        if (Object.prototype.hasOwnProperty.call(context.left, property) &&
+            child.result === undefined) {
+            delete object[property];
+        }
+        else if (object[property] !== child.result) {
+            object[property] = child.result;
+        }
+    }
+    context.setResult(object).exit();
+};
+collectChildrenPatchFilter.filterName = 'collectChildren';
+export const reverseFilter = function nestedReverseFilter(context) {
+    if (!context.nested) {
+        return;
+    }
+    const nestedDelta = context.delta;
+    if (nestedDelta._t) {
+        return;
+    }
+    const objectDelta = context.delta;
+    let name;
+    let child;
+    for (name in objectDelta) {
+        child = new ReverseContext(objectDelta[name]);
+        context.push(child, name);
+    }
+    context.exit();
+};
+reverseFilter.filterName = 'objects';
+export const collectChildrenReverseFilter = (context) => {
+    if (!context || !context.children) {
+        return;
+    }
+    const deltaWithChildren = context.delta;
+    if (deltaWithChildren._t) {
+        return;
+    }
+    const length = context.children.length;
+    let child;
+    const delta = {};
+    for (let index = 0; index < length; index++) {
+        child = context.children[index];
+        const property = child.childName;
+        if (delta[property] !== child.result) {
+            delta[property] = child.result;
+        }
+    }
+    context.setResult(delta).exit();
+};
+collectChildrenReverseFilter.filterName = 'collectChildren';

package/node_modules/jsondiffpatch/lib/filters/texts.d.ts

@@ -0,0 +1,7 @@
+import type DiffContext from '../contexts/diff.js';
+import type PatchContext from '../contexts/patch.js';
+import type ReverseContext from '../contexts/reverse.js';
+import type { Filter } from '../types.js';
+export declare const diffFilter: Filter<DiffContext>;
+export declare const patchFilter: Filter<PatchContext>;
+export declare const reverseFilter: Filter<ReverseContext>;

package/node_modules/jsondiffpatch/lib/filters/texts.js

@@ -0,0 +1,134 @@
+const TEXT_DIFF = 2;
+const DEFAULT_MIN_LENGTH = 60;
+let cachedDiffPatch = null;
+function getDiffMatchPatch(options, required) {
+    var _a;
+    if (!cachedDiffPatch) {
+        let instance;
+        if ((_a = options === null || options === void 0 ? void 0 : options.textDiff) === null || _a === void 0 ? void 0 : _a.diffMatchPatch) {
+            instance = new options.textDiff.diffMatchPatch();
+        }
+        else {
+            if (!required) {
+                return null;
+            }
+            const error = new Error('The diff-match-patch library was not provided. Pass the library in through the options or use the `jsondiffpatch/with-text-diffs` entry-point.');
+            // eslint-disable-next-line camelcase
+            error.diff_match_patch_not_found = true;
+            throw error;
+        }
+        cachedDiffPatch = {
+            diff: function (txt1, txt2) {
+                return instance.patch_toText(instance.patch_make(txt1, txt2));
+            },
+            patch: function (txt1, patch) {
+                const results = instance.patch_apply(instance.patch_fromText(patch), txt1);
+                for (let i = 0; i < results[1].length; i++) {
+                    if (!results[1][i]) {
+                        const error = new Error('text patch failed');
+                        error.textPatchFailed = true;
+                    }
+                }
+                return results[0];
+            },
+        };
+    }
+    return cachedDiffPatch;
+}
+export const diffFilter = function textsDiffFilter(context) {
+    if (context.leftType !== 'string') {
+        return;
+    }
+    const left = context.left;
+    const right = context.right;
+    const minLength = (context.options &&
+        context.options.textDiff &&
+        context.options.textDiff.minLength) ||
+        DEFAULT_MIN_LENGTH;
+    if (left.length < minLength || right.length < minLength) {
+        context.setResult([left, right]).exit();
+        return;
+    }
+    // large text, try to use a text-diff algorithm
+    const diffMatchPatch = getDiffMatchPatch(context.options);
+    if (!diffMatchPatch) {
+        // diff-match-patch library not available,
+        // fallback to regular string replace
+        context.setResult([left, right]).exit();
+        return;
+    }
+    const diff = diffMatchPatch.diff;
+    context.setResult([diff(left, right), 0, TEXT_DIFF]).exit();
+};
+diffFilter.filterName = 'texts';
+export const patchFilter = function textsPatchFilter(context) {
+    if (context.nested) {
+        return;
+    }
+    const nonNestedDelta = context.delta;
+    if (nonNestedDelta[2] !== TEXT_DIFF) {
+        return;
+    }
+    const textDiffDelta = nonNestedDelta;
+    // text-diff, use a text-patch algorithm
+    const patch = getDiffMatchPatch(context.options, true).patch;
+    context.setResult(patch(context.left, textDiffDelta[0])).exit();
+};
+patchFilter.filterName = 'texts';
+const textDeltaReverse = function (delta) {
+    let i;
+    let l;
+    let line;
+    let lineTmp;
+    let header = null;
+    const headerRegex = /^@@ +-(\d+),(\d+) +\+(\d+),(\d+) +@@$/;
+    let lineHeader;
+    const lines = delta.split('\n');
+    for (i = 0, l = lines.length; i < l; i++) {
+        line = lines[i];
+        const lineStart = line.slice(0, 1);
+        if (lineStart === '@') {
+            header = headerRegex.exec(line);
+            lineHeader = i;
+            // fix header
+            lines[lineHeader] =
+                '@@ -' +
+                    header[3] +
+                    ',' +
+                    header[4] +
+                    ' +' +
+                    header[1] +
+                    ',' +
+                    header[2] +
+                    ' @@';
+        }
+        else if (lineStart === '+') {
+            lines[i] = '-' + lines[i].slice(1);
+            if (lines[i - 1].slice(0, 1) === '+') {
+                // swap lines to keep default order (-+)
+                lineTmp = lines[i];
+                lines[i] = lines[i - 1];
+                lines[i - 1] = lineTmp;
+            }
+        }
+        else if (lineStart === '-') {
+            lines[i] = '+' + lines[i].slice(1);
+        }
+    }
+    return lines.join('\n');
+};
+export const reverseFilter = function textsReverseFilter(context) {
+    if (context.nested) {
+        return;
+    }
+    const nonNestedDelta = context.delta;
+    if (nonNestedDelta[2] !== TEXT_DIFF) {
+        return;
+    }
+    const textDiffDelta = nonNestedDelta;
+    // text-diff, use a text-diff algorithm
+    context
+        .setResult([textDeltaReverse(textDiffDelta[0]), 0, TEXT_DIFF])
+        .exit();
+};
+reverseFilter.filterName = 'texts';

package/node_modules/jsondiffpatch/lib/filters/trivial.d.ts

@@ -0,0 +1,7 @@
+import type DiffContext from '../contexts/diff.js';
+import type PatchContext from '../contexts/patch.js';
+import type ReverseContext from '../contexts/reverse.js';
+import type { Filter } from '../types.js';
+export declare const diffFilter: Filter<DiffContext>;
+export declare const patchFilter: Filter<PatchContext>;
+export declare const reverseFilter: Filter<ReverseContext>;

package/node_modules/jsondiffpatch/lib/filters/trivial.js

@@ -0,0 +1,105 @@
+export const diffFilter = function trivialMatchesDiffFilter(context) {
+    if (context.left === context.right) {
+        context.setResult(undefined).exit();
+        return;
+    }
+    if (typeof context.left === 'undefined') {
+        if (typeof context.right === 'function') {
+            throw new Error('functions are not supported');
+        }
+        context.setResult([context.right]).exit();
+        return;
+    }
+    if (typeof context.right === 'undefined') {
+        context.setResult([context.left, 0, 0]).exit();
+        return;
+    }
+    if (typeof context.left === 'function' ||
+        typeof context.right === 'function') {
+        throw new Error('functions are not supported');
+    }
+    context.leftType = context.left === null ? 'null' : typeof context.left;
+    context.rightType = context.right === null ? 'null' : typeof context.right;
+    if (context.leftType !== context.rightType) {
+        context.setResult([context.left, context.right]).exit();
+        return;
+    }
+    if (context.leftType === 'boolean' || context.leftType === 'number') {
+        context.setResult([context.left, context.right]).exit();
+        return;
+    }
+    if (context.leftType === 'object') {
+        context.leftIsArray = Array.isArray(context.left);
+    }
+    if (context.rightType === 'object') {
+        context.rightIsArray = Array.isArray(context.right);
+    }
+    if (context.leftIsArray !== context.rightIsArray) {
+        context.setResult([context.left, context.right]).exit();
+        return;
+    }
+    if (context.left instanceof RegExp) {
+        if (context.right instanceof RegExp) {
+            context
+                .setResult([context.left.toString(), context.right.toString()])
+                .exit();
+        }
+        else {
+            context.setResult([context.left, context.right]).exit();
+        }
+    }
+};
+diffFilter.filterName = 'trivial';
+export const patchFilter = function trivialMatchesPatchFilter(context) {
+    if (typeof context.delta === 'undefined') {
+        context.setResult(context.left).exit();
+        return;
+    }
+    context.nested = !Array.isArray(context.delta);
+    if (context.nested) {
+        return;
+    }
+    const nonNestedDelta = context.delta;
+    if (nonNestedDelta.length === 1) {
+        context.setResult(nonNestedDelta[0]).exit();
+        return;
+    }
+    if (nonNestedDelta.length === 2) {
+        if (context.left instanceof RegExp) {
+            const regexArgs = /^\/(.*)\/([gimyu]+)$/.exec(nonNestedDelta[1]);
+            if (regexArgs) {
+                context.setResult(new RegExp(regexArgs[1], regexArgs[2])).exit();
+                return;
+            }
+        }
+        context.setResult(nonNestedDelta[1]).exit();
+        return;
+    }
+    if (nonNestedDelta.length === 3 && nonNestedDelta[2] === 0) {
+        context.setResult(undefined).exit();
+    }
+};
+patchFilter.filterName = 'trivial';
+export const reverseFilter = function trivialReferseFilter(context) {
+    if (typeof context.delta === 'undefined') {
+        context.setResult(context.delta).exit();
+        return;
+    }
+    context.nested = !Array.isArray(context.delta);
+    if (context.nested) {
+        return;
+    }
+    const nonNestedDelta = context.delta;
+    if (nonNestedDelta.length === 1) {
+        context.setResult([nonNestedDelta[0], 0, 0]).exit();
+        return;
+    }
+    if (nonNestedDelta.length === 2) {
+        context.setResult([nonNestedDelta[1], nonNestedDelta[0]]).exit();
+        return;
+    }
+    if (nonNestedDelta.length === 3 && nonNestedDelta[2] === 0) {
+        context.setResult([nonNestedDelta[0]]).exit();
+    }
+};
+reverseFilter.filterName = 'trivial';

package/node_modules/jsondiffpatch/lib/formatters/annotated.d.ts

@@ -0,0 +1,29 @@
+import BaseFormatter from './base.js';
+import type { BaseFormatterContext, DeltaType, NodeType } from './base.js';
+import type { AddedDelta, ArrayDelta, DeletedDelta, Delta, ModifiedDelta, MovedDelta, ObjectDelta, TextDiffDelta } from '../types.js';
+interface AnnotatedFormatterContext extends BaseFormatterContext {
+    indentLevel?: number;
+    indentPad?: string;
+    indent: (levels?: number) => void;
+    row: (json: string, htmlNote?: string) => void;
+}
+declare class AnnotatedFormatter extends BaseFormatter<AnnotatedFormatterContext> {
+    constructor();
+    prepareContext(context: Partial<AnnotatedFormatterContext>): void;
+    typeFormattterErrorFormatter(context: AnnotatedFormatterContext, err: unknown): void;
+    formatTextDiffString(context: AnnotatedFormatterContext, value: string): void;
+    rootBegin(context: AnnotatedFormatterContext, type: DeltaType, nodeType: NodeType): void;
+    rootEnd(context: AnnotatedFormatterContext, type: DeltaType): void;
+    nodeBegin(context: AnnotatedFormatterContext, key: string, leftKey: string | number, type: DeltaType, nodeType: NodeType): void;
+    nodeEnd(context: AnnotatedFormatterContext, key: string, leftKey: string | number, type: DeltaType, nodeType: NodeType, isLast: boolean): void;
+    format_unchanged(): void;
+    format_movedestination(): void;
+    format_node(context: AnnotatedFormatterContext, delta: ObjectDelta | ArrayDelta, left: unknown): void;
+    format_added(context: AnnotatedFormatterContext, delta: AddedDelta, left: unknown, key: string | undefined, leftKey: string | number | undefined): void;
+    format_modified(context: AnnotatedFormatterContext, delta: ModifiedDelta, left: unknown, key: string | undefined, leftKey: string | number | undefined): void;
+    format_deleted(context: AnnotatedFormatterContext, delta: DeletedDelta, left: unknown, key: string | undefined, leftKey: string | number | undefined): void;
+    format_moved(context: AnnotatedFormatterContext, delta: MovedDelta, left: unknown, key: string | undefined, leftKey: string | number | undefined): void;
+    format_textdiff(context: AnnotatedFormatterContext, delta: TextDiffDelta, left: unknown, key: string | undefined, leftKey: string | number | undefined): void;
+}
+export default AnnotatedFormatter;
+export declare function format(delta: Delta, left?: unknown): string | undefined;

package/node_modules/jsondiffpatch/lib/formatters/annotated.js

@@ -0,0 +1,169 @@
+import BaseFormatter from './base.js';
+class AnnotatedFormatter extends BaseFormatter {
+    constructor() {
+        super();
+        this.includeMoveDestinations = false;
+    }
+    prepareContext(context) {
+        super.prepareContext(context);
+        context.indent = function (levels) {
+            this.indentLevel =
+                (this.indentLevel || 0) + (typeof levels === 'undefined' ? 1 : levels);
+            this.indentPad = new Array(this.indentLevel + 1).join('  ');
+        };
+        context.row = (json, htmlNote) => {
+            context.out('<tr><td style="white-space: nowrap;">' +
+                '<pre class="jsondiffpatch-annotated-indent"' +
+                ' style="display: inline-block">');
+            if (context.indentPad != null)
+                context.out(context.indentPad);
+            context.out('</pre><pre style="display: inline-block">');
+            context.out(json);
+            context.out('</pre></td><td class="jsondiffpatch-delta-note"><div>');
+            if (htmlNote != null)
+                context.out(htmlNote);
+            context.out('</div></td></tr>');
+        };
+    }
+    typeFormattterErrorFormatter(context, err) {
+        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+        context.row('', `<pre class="jsondiffpatch-error">${err}</pre>`);
+    }
+    formatTextDiffString(context, value) {
+        const lines = this.parseTextDiff(value);
+        context.out('<ul class="jsondiffpatch-textdiff">');
+        for (let i = 0, l = lines.length; i < l; i++) {
+            const line = lines[i];
+            context.out('<li><div class="jsondiffpatch-textdiff-location">' +
+                `<span class="jsondiffpatch-textdiff-line-number">${line.location.line}</span><span class="jsondiffpatch-textdiff-char">${line.location.chr}</span></div><div class="jsondiffpatch-textdiff-line">`);
+            const pieces = line.pieces;
+            for (let pieceIndex = 0, piecesLength = pieces.length; pieceIndex < piecesLength; pieceIndex++) {
+                const piece = pieces[pieceIndex];
+                context.out(`<span class="jsondiffpatch-textdiff-${piece.type}">${piece.text}</span>`);
+            }
+            context.out('</div></li>');
+        }
+        context.out('</ul>');
+    }
+    rootBegin(context, type, nodeType) {
+        context.out('<table class="jsondiffpatch-annotated-delta">');
+        if (type === 'node') {
+            context.row('{');
+            context.indent();
+        }
+        if (nodeType === 'array') {
+            context.row('"_t": "a",', 'Array delta (member names indicate array indices)');
+        }
+    }
+    rootEnd(context, type) {
+        if (type === 'node') {
+            context.indent(-1);
+            context.row('}');
+        }
+        context.out('</table>');
+    }
+    nodeBegin(context, key, leftKey, type, nodeType) {
+        context.row(`&quot;${key}&quot;: {`);
+        if (type === 'node') {
+            context.indent();
+        }
+        if (nodeType === 'array') {
+            context.row('"_t": "a",', 'Array delta (member names indicate array indices)');
+        }
+    }
+    nodeEnd(context, key, leftKey, type, nodeType, isLast) {
+        if (type === 'node') {
+            context.indent(-1);
+        }
+        context.row(`}${isLast ? '' : ','}`);
+    }
+    format_unchanged() { }
+    format_movedestination() { }
+    format_node(context, delta, left) {
+        // recurse
+        this.formatDeltaChildren(context, delta, left);
+    }
+    format_added(context, delta, left, key, leftKey) {
+        formatAnyChange.call(this, context, delta, left, key, leftKey);
+    }
+    format_modified(context, delta, left, key, leftKey) {
+        formatAnyChange.call(this, context, delta, left, key, leftKey);
+    }
+    format_deleted(context, delta, left, key, leftKey) {
+        formatAnyChange.call(this, context, delta, left, key, leftKey);
+    }
+    format_moved(context, delta, left, key, leftKey) {
+        formatAnyChange.call(this, context, delta, left, key, leftKey);
+    }
+    format_textdiff(context, delta, left, key, leftKey) {
+        formatAnyChange.call(this, context, delta, left, key, leftKey);
+    }
+}
+const wrapPropertyName = (name) => `<pre style="display:inline-block">&quot;${name}&quot;</pre>`;
+const deltaAnnotations = {
+    added(delta, left, key, leftKey) {
+        const formatLegend = ' <pre>([newValue])</pre>';
+        if (typeof leftKey === 'undefined') {
+            return `new value${formatLegend}`;
+        }
+        if (typeof leftKey === 'number') {
+            return `insert at index ${leftKey}${formatLegend}`;
+        }
+        return `add property ${wrapPropertyName(leftKey)}${formatLegend}`;
+    },
+    modified(delta, left, key, leftKey) {
+        const formatLegend = ' <pre>([previousValue, newValue])</pre>';
+        if (typeof leftKey === 'undefined') {
+            return `modify value${formatLegend}`;
+        }
+        if (typeof leftKey === 'number') {
+            return `modify at index ${leftKey}${formatLegend}`;
+        }
+        return `modify property ${wrapPropertyName(leftKey)}${formatLegend}`;
+    },
+    deleted(delta, left, key, leftKey) {
+        const formatLegend = ' <pre>([previousValue, 0, 0])</pre>';
+        if (typeof leftKey === 'undefined') {
+            return `delete value${formatLegend}`;
+        }
+        if (typeof leftKey === 'number') {
+            return `remove index ${leftKey}${formatLegend}`;
+        }
+        return `delete property ${wrapPropertyName(leftKey)}${formatLegend}`;
+    },
+    moved(delta, left, key, leftKey) {
+        return ('move from <span title="(position to remove at original state)">' +
+            `index ${leftKey}</span> to <span title="(position to insert at final` +
+            ` state)">index ${delta[1]}</span>`);
+    },
+    textdiff(delta, left, key, leftKey) {
+        const location = typeof leftKey === 'undefined'
+            ? ''
+            : typeof leftKey === 'number'
+                ? ` at index ${leftKey}`
+                : ` at property ${wrapPropertyName(leftKey)}`;
+        return (`text diff${location}, format is <a href="https://code.google.com/` +
+            'p/google-diff-match-patch/wiki/Unidiff">a variation of Unidiff</a>');
+    },
+};
+const formatAnyChange = function (context, delta, left, key, leftKey) {
+    const deltaType = this.getDeltaType(delta);
+    const annotator = deltaAnnotations[deltaType];
+    const htmlNote = annotator && annotator(delta, left, key, leftKey);
+    let json = JSON.stringify(delta, null, 2);
+    if (deltaType === 'textdiff') {
+        // split text diffs lines
+        json = json.split('\\n').join('\\n"+\n   "');
+    }
+    context.indent();
+    context.row(json, htmlNote);
+    context.indent(-1);
+};
+export default AnnotatedFormatter;
+let defaultInstance;
+export function format(delta, left) {
+    if (!defaultInstance) {
+        defaultInstance = new AnnotatedFormatter();
+    }
+    return defaultInstance.format(delta, left);
+}