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

var CodeMirror = module.exports = require("code-mirror");
var diff_match_patch = require("diff-match-patch");
var DIFF_INSERT = diff_match_patch.DIFF_INSERT;
var DIFF_DELETE = diff_match_patch.DIFF_DELETE;
var DIFF_EQUAL = diff_match_patch.DIFF_EQUAL;
(function() {
  "use strict";
  // declare global: diff_match_patch, DIFF_INSERT, DIFF_DELETE, DIFF_EQUAL

  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",

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}`);
			}
		});
	});

this.AvoidAndroidIssueWhenPressSpace = 0;
    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(
          this.renderUnchanged.bind(this),
          /* collapsedLabel= */ "identical",
          /* expandButtonClass= */ "identical",
          MIN_COLLAPSED_UNCHANGED_REGION_NUM_LINES
        );
    }
  }

// 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 = this.codeMirror.posFromIndex(at)
          this.codeMirror.replaceRange(str, fromPos, null, 'automerge')
          at += str.length
          break
        }
        case DiffMatchPatch.DIFF_DELETE: {
          const fromPos = this.codeMirror.posFromIndex(at)
          const toPos = this.codeMirror.posFromIndex(at + str.length)
          this.codeMirror.replaceRange('', fromPos, toPos, 'automerge')
          break
        }
        default: {
          throw new Error(`Did not expect diff type ${type}`)
        }
      }
    }
  }

this.refs[i].range.end.character :
                    startChar + refCharLength
              }
            };
          }

        // If anything was deleted, we've made progress through the old file
        // but haven't moved our new position
        case diff.DIFF_DELETE:
          if (newLine) {
            oldPosition.line += diffLineLength;
            oldPosition.character = charOffset;
          } else {
            oldPosition.character += charOffset;
          }
          if (d[0] === diff.DIFF_DELETE) {
            break;
          }

        // If anything was inserted, we've made progress through the new file
        // but haven't moved our old position
        case diff.DIFF_INSERT:
          if (newLine) {
            newPosition.line += diffLineLength;
            newPosition.character = charOffset;
          } else {
            newPosition.character += charOffset;
          }
          break;


        default:

* (at your option) any later version.
 *
 * GLPI is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GLPI. If not, see .
 * ---------------------------------------------------------------------
 */

// diff-match-patch dependency
// 'diff_match_patch' function and DIFF_* constants have to be declared in global scope
window.diff_match_patch = require('diff-match-patch').diff_match_patch;
window.DIFF_DELETE = require('diff-match-patch').DIFF_DELETE;
window.DIFF_INSERT = require('diff-match-patch').DIFF_INSERT;
window.DIFF_EQUAL = require('diff-match-patch').DIFF_EQUAL;

// PrettyTextDiff jQuery plugin
require('jquery-prettytextdiff');

line += lines.length - 1;

            if (lines.length > 1) {
                character = lines[lines.length - 1].length;
            } else if (lines.length == 1) {
                character += lines[0].length;
            }

            switch (op) {
                case diffMatchPatch.DIFF_INSERT:
                    editors.push(vscode.TextEdit.insert(start, text));
                    // this new part should not affect counting of original document
                    line = start.line;
                    character = start.character;
                    break;
                case diffMatchPatch.DIFF_DELETE:
                    let end = new vscode.Position(line, character);
                    editors.push(vscode.TextEdit.delete(new vscode.Range(start, end)));
                    break;
                case diffMatchPatch.DIFF_EQUAL:
                    break;
            }
        });

// 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 = this.codeMirror.posFromIndex(at)
          this.codeMirror.replaceRange(str, fromPos, null, 'automerge')
          at += str.length
          break
        }
        case DiffMatchPatch.DIFF_DELETE: {
          const fromPos = this.codeMirror.posFromIndex(at)
          const toPos = this.codeMirror.posFromIndex(at + str.length)
          this.codeMirror.replaceRange('', fromPos, toPos, 'automerge')
          break
        }
        default: {
          throw new Error(`Did not expect diff type ${type}`)
        }
      }
    }
  }

diffs.forEach(function (diff) {
        var type = diff[0];
        var blockChars = diff[1];

        for (var i = 0; i < blockChars.length; ++i) {
            if (type === diff_match_patch.DIFF_EQUAL) {
                blockDiffs.push({
                    type: type,
                    key1: blockKeys1.get(index1),
                    key2: blockKeys2.get(index2)
                });
                index1++;
                index2++;
            } else if (type === diff_match_patch.DIFF_DELETE) {
                blockDiffs.push({
                    type: type,
                    key1: blockKeys1.get(index1),
                    key2: undefined
                });
                index1++;
            } else {
                blockDiffs.push({
                    type: type,
                    key1: undefined,
                    key2: blockKeys2.get(index2)
                });
                index2++;
            }
        }
    });