How to use the fast-diff function in fast-diff

export function getTextRangeChanges(
  before: string,
  after: string,
): Promise {
  const newRanges: TextEdit[] = [];
  let lineNumber = 0;
  let column = 0;

  const parts = diff(before, after);

  // Loop over every part, keeping track of:
  // 1. The current line no. and column in the `after` string
  // 2. Character ranges for all "added" parts in the `after` string
  parts.forEach(part => {
    const startLineNumber = lineNumber;
    const startColumn = column;
    if (part[0] === 0 || part[0] === -1) {
      // Split the part into lines. Loop through these lines to find
      // the line no. and column at the end of this part.
      const substring = part[1];
      const lines = substring.split("\n");
      lines.forEach((line, lineIndex) => {
        // The first `line` is actually just a continuation of the last line
        if (lineIndex === 0) {
          column += line.length;

const onTitleEditorChanged = () => {
    if (!titleCollab) {
      return
    }

    const oldTitle = titleCollab.shared.value().join('')
    const newTitle = titleEditor.value

    const diffs = Diff(oldTitle, newTitle)

    let pos = 0
    diffs.forEach((d) => {
      if (d[0] === 0) { // EQUAL
        pos += d[1].length
      } else if (d[0] === -1) { // DELETE
        const delText = d[1]
        for (let i = delText.length - 1; i >= 0; i--) {
          try {
            titleCollab.shared.removeAt(pos + i)
          } catch (err) {
            console.error(err)
            onStateChanged()
          }
        }
      } else { // INSERT

applyChanges (target, newText) {
    const { collaboration } = this.props
    const oldText = this.state.value
    const diffs = Diff(oldText, newText)
    let pos = 0
    diffs.forEach((d) => {
      if (d[0] === 0) { // EQUAL
        pos += d[1].length
      } else if (d[0] === -1) { // DELETE
        const delText = d[1]
        for (let i = delText.length - 1; i >= 0; i--) {
          collaboration.shared.removeAt(pos + i)
        }
      } else { // INSERT
        d[1].split('').forEach((c) => {
          collaboration.shared.insertAt(pos, d[1])
        })
        pos += d[1].length
      }
    })

onRemoteChange (oldText, newText) {
    console.log('onValueChanged', oldText, newText)
    const textArea = this.refs.collaborativeTextArea
    if (textArea.value === newText) {
      console.log('value is the same', textArea.value)
      return
    }
    const cursor = {
      start: textArea.selectionStart,
      end: textArea.selectionEnd
    }

    const diffs = Diff(oldText, newText)

    let pos = 0
    diffs.forEach((d) => {
      if (d[0] === 0) { // EQUAL
        pos += d[1].length
      } else if (d[0] === -1) { // DELETE
        const delText = d[1]
        if (pos < cursor.start) {
          cursor.start -= delText.length
        }
        if (pos < cursor.end) {
          cursor.end -= delText.length
        }
      } else { // INSERT
        const insertText = d[1]
        if (pos < cursor.start) {

private async applyComposedEdit(original: string, edit: TextEdit): Promise {
    // check complex edit
    let { range, newText } = edit
    let { nvim, ranges } = this
    let doc = TextDocument.create('file:///1', '', 0, original)
    let edits: TextEdit[] = []
    let diffs = fastDiff(original, newText)
    let offset = 0
    for (let i = 0; i < diffs.length; i++) {
      let diff = diffs[i]
      let pos = adjustPosition(range.start, doc.positionAt(offset))
      if (diff[0] == fastDiff.EQUAL) {
        offset = offset + diff[1].length
      } else if (diff[0] == fastDiff.DELETE) {
        let end = adjustPosition(range.start, doc.positionAt(offset + diff[1].length))
        if (diffs[i + 1] && diffs[i + 1][0] == fastDiff.INSERT) {
          // change
          edits.push({ range: Range.create(pos, end), newText: diffs[i + 1][1] })
          i = i + 1
        } else {
          // delete
          edits.push({ range: Range.create(pos, end), newText: '' })
        }

workspace.watchOption('runtimepath', async (oldValue, newValue) => {
      let result = fastDiff(oldValue, newValue)
      for (let [changeType, value] of result) {
        if (changeType == 1) {
          let paths = value.replace(/,$/, '').split(',')
          for (let p of paths) {
            if (p) await this.loadExtension(p, true)
          }
        }
      }
    })
    commandManager.register({

let doc = this.document
    if (doc.version - this.version == 1) return
    let { fileItems } = this
    if (!fileItems.length) return
    let change = e.contentChanges[0]
    let { original } = e
    if (change.range.end.line < 2) return
    doc.buffer.setOption('modified', true, true)
    let { range, text } = change
    let lines = text.split('\n')
    let lineChange = lines.length - (range.end.line - range.start.line) - 1
    if (lineChange == 0) return
    let lineChanges: LineChange[] = []
    if (text.indexOf('\u3000') !== -1) {
      let startLine = range.start.line
      let diffs = fastDiff(original, text)
      let offset = 0
      let orig = TextDocument.create('file:///1', '', 0, original)
      for (let i = 0; i < diffs.length; i++) {
        let diff = diffs[i]
        let pos = orig.positionAt(offset)
        if (diff[0] == fastDiff.EQUAL) {
          offset = offset + diff[1].length
        } else if (diff[0] == fastDiff.DELETE) {
          let end = orig.positionAt(offset + diff[1].length)
          if (diffs[i + 1] && diffs[i + 1][0] == fastDiff.INSERT) {
            let delta = diffs[i + 1][1].split('\n').length - (end.line - pos.line) - 1
            if (delta != 0) lineChanges.push({ delta, lnum: pos.line + startLine })
            i = i + 1
          } else {
            let delta = - (end.line - pos.line)
            if (delta != 0) lineChanges.push({ delta, lnum: pos.line + startLine })

}).sortBy((property) => {
                var values = Object.keys(summary[property].values);
                var sortby = diff(values[0], values.slice(-1)[0]).filter((diff) => {
                    return diff[0] !== 0;
                }).length;
                return sortby;
            }).reverse().value()[0];
        if (candidatePropertyForX) {

const onCodeMirrorChange = (editor) => {
    editorValueCache = undefined
    if (!initialised || locked) {
      return
    }
    const diffs = Diff(doc.shared.value().join(''), getEditorValue())
    applyDiffs(0, diffs)
  }