How to use the diff-match-patch.DIFF_INSERT function in diff-match-patch

diffs.forEach((diff) => {
        const operation = diff[0]; // Operation (insert, delete, equal)
        const text = diff[1]; // Text of change

        switch (operation) {
            case DiffMatchPatch.DIFF_INSERT:
                pattern += "I";
                break;
            case DiffMatchPatch.DIFF_DELETE:
                pattern += "D";
                break;
            case DiffMatchPatch.DIFF_EQUAL:
                pattern += "E";
                break;
        }

        changes += text;
    });
}

pattern += "I";
                break;
            case DiffMatchPatch.DIFF_DELETE:
                pattern += "D";
                break;
            case DiffMatchPatch.DIFF_EQUAL:
                pattern += "E";
                break;
        }

        changes += text;
    });
}

const DIFF_DELETE: number = DiffMatchPatch.DIFF_DELETE;
const DIFF_INSERT: number = DiffMatchPatch.DIFF_INSERT;
const DIFF_EQUAL: number = DiffMatchPatch.DIFF_EQUAL;
const dmp = new DiffMatchPatch.diff_match_patch();

// DIFF TEST FUNCTIONS

function testDiffCommonPrefix() {
    assertEquals(0, dmp.diff_commonPrefix('abc', 'xyz'));
}

function testDiffCommonSuffix() {
    assertEquals(0, dmp.diff_commonSuffix('abc', 'xyz'));
}

function testDiffCommonOverlap() {
    assertEquals(0, dmp.diff_commonOverlap_('', 'abcd'));
}

this.checkKeyPressAndroid = 0;

    this.avoidAndroidIssueWhenPressSpaceText = '';
    this.justToolAdded = false;
    this.state = {
      selectedTag: 'body',
      selection: { start: 0, end: 0 },
      avoidUpdateText: false,
    };

    this.dmp = new DiffMatchPatch();
    this.oldText = '';
    this.reCalculateTextOnUpate = false;
    // You can also use the following properties:
    DiffMatchPatch.DIFF_DELETE = -1;
    DiffMatchPatch.DIFF_INSERT = 1;
    DiffMatchPatch.DIFF_EQUAL = 0;
  }

render() {
    const marker = this.props.chunk.marker;
    switch (marker) {
      case DiffMatchPatch.DIFF_INSERT:
        return this.renderChunk(
          this.renderAdded.bind(this),
          /* collapsedLabel= */ "added",
          /* expandButtonClass= */ "added",
          MIN_COLLAPSED_CHANGED_REGION_NUM_LINES
        );
      case DiffMatchPatch.DIFF_DELETE:
        return this.renderChunk(
          this.renderRemoved.bind(this),
          /* collapsedLabel= */ "removed",
          /* expandButtonClass= */ "removed",
          MIN_COLLAPSED_CHANGED_REGION_NUM_LINES
        );
      case DiffMatchPatch.DIFF_EQUAL:
      default:
        return this.renderChunk(

// Otherwise find the diff between the current and desired contents, and
    // apply corresponding editor ops to close them.
    const dmp = new DiffMatchPatch.diff_match_patch()
    const diff = dmp.diff_main(oldContent, newContent)
    // The diff lib doesn't give indicies so we need to compute them ourself as
    // we go along.
    let at = 0
    for (let i = 0; i < diff.length; i += 1) {
      const [type, str] = diff[i]
      switch (type) {
        case DiffMatchPatch.DIFF_EQUAL: {
          at += str.length
          break
        }
        case DiffMatchPatch.DIFF_INSERT: {
          const fromPos = codeMirrorDoc.posFromIndex(at)
          codeMirrorDoc.replaceRange(str, fromPos, undefined, "automerge")
          at += str.length
          break
        }
        case DiffMatchPatch.DIFF_DELETE: {
          const fromPos = codeMirrorDoc.posFromIndex(at)
          const toPos = codeMirrorDoc.posFromIndex(at + str.length)
          codeMirrorDoc.replaceRange("", fromPos, toPos, "automerge")
          break
        }
        default: {
          throw new Error(`Did not expect diff type ${type}`)
        }
      }
    }

patch.diffs.forEach(function([type, value]) {
			switch (type) {
				case diffMatchPatch.DIFF_DELETE:
					ops.push({ sd: value, p: [...path, offset] });
					break;
				case diffMatchPatch.DIFF_INSERT:
					ops.push({ si: value, p: [...path, offset] });
					// falls through intentionally
				case diffMatchPatch.DIFF_EQUAL:
					offset += value.length;
					break;
				default: throw Error(`Unsupported operation type: ${type}`);
			}
		});
	});

(function () {
  "use strict";
  const CodeMirror = require("codemirror/lib/codemirror");
  var diff_match_patch = require("diff-match-patch");
  var DIFF_EQUAL = diff_match_patch.DIFF_EQUAL;
  var DIFF_INSERT = diff_match_patch.DIFF_INSERT;
  var DIFF_DELETE = diff_match_patch.DIFF_DELETE;

  var Pos = CodeMirror.Pos;
  var svgNS = "http://www.w3.org/2000/svg";

  function DiffView(mv, type) {
    this.mv = mv;
    this.type = type;
    this.classes =
      type == "left"
        ? {
          chunk: "CodeMirror-merge-l-chunk",
          start: "CodeMirror-merge-l-chunk-start",
          end: "CodeMirror-merge-l-chunk-end",
          insert: "CodeMirror-merge-l-inserted",
          del: "CodeMirror-merge-l-deleted",

const getTextClass = diffType => {
    switch (diffType) {
      case DiffMatchPatch.DIFF_DELETE:
        return 'pretty-diff-component-delete';
      case DiffMatchPatch.DIFF_INSERT:
        return 'pretty-diff-component-insert';
      default:
        return 'pretty-diff-component-equal';
    }
  };

export default function diff(a, b) {
  const result = dmp.diff_main(a, b);
  const html = [];

  dmp.diff_cleanupSemantic(result);

  for (let i = 0; i < result.length; i++) {
    const op = result[i][0];
    const text = highlightRO(result[i][1]);
    if (op === DMP.DIFF_INSERT) {
      html[i] = `<span class="diff-insert">${text}</span>`;
    } else if (op === DMP.DIFF_DELETE) {
      html[i] = `<span class="diff-delete">${text}</span>`;
    } else if (op === DMP.DIFF_EQUAL) {
      html[i] = text;
    }
  }

  return html.join('');
}