@createiq/htmldiff 1.0.2 → 1.0.4-beta.0

package/dist/HtmlDiff.js

@@ -1,827 +0,0 @@
-// src/Action.ts
-var Action = /* @__PURE__ */ ((Action2) => {
-  Action2[Action2["Equal"] = 0] = "Equal";
-  Action2[Action2["Delete"] = 1] = "Delete";
-  Action2[Action2["Insert"] = 2] = "Insert";
-  Action2[Action2["None"] = 3] = "None";
-  Action2[Action2["Replace"] = 4] = "Replace";
-  return Action2;
-})(Action || {});
-var Action_default = Action;
-
-// src/Match.ts
-var Match = class {
-  _startInOld;
-  _startInNew;
-  _size;
-  constructor(startInOld, startInNew, size) {
-    this._startInOld = startInOld;
-    this._startInNew = startInNew;
-    this._size = size;
-  }
-  get startInOld() {
-    return this._startInOld;
-  }
-  get startInNew() {
-    return this._startInNew;
-  }
-  get size() {
-    return this._size;
-  }
-  get endInOld() {
-    return this._startInOld + this._size;
-  }
-  get endInNew() {
-    return this._startInNew + this._size;
-  }
-};
-
-// src/Utils.ts
-var openingTagRegex = /^\s*<[^>]+>\s*$/;
-var closingTagTexRegex = /^\s*<\/[^>]+>\s*$/;
-var tagWordRegex = /<[^\s>]+/;
-var whitespaceRegex = /^(\s|&nbsp;)+$/;
-var wordRegex = /[\w#@]+/;
-var tagRegex = /<\/?(?<name>[^\s/>]+)[^>]*>/;
-var SpecialCaseWordTags = ["<img"];
-function isTag(item) {
-  if (SpecialCaseWordTags.some((re) => item?.startsWith(re))) {
-    return false;
-  }
-  return isOpeningTag(item) || isClosingTag(item);
-}
-function isOpeningTag(item) {
-  return openingTagRegex.test(item);
-}
-function isClosingTag(item) {
-  return closingTagTexRegex.test(item);
-}
-function stripTagAttributes(word) {
-  const match = tagWordRegex.exec(word);
-  if (match) {
-    return `${match[0]}${word.endsWith("/>") ? "/>" : ">"}`;
-  }
-  return word;
-}
-function wrapText(text, tagName, cssClass) {
-  return `<${tagName} class='${cssClass}'>${text}</${tagName}>`;
-}
-function isStartOfTag(val) {
-  return val === "<";
-}
-function isEndOfTag(val) {
-  return val === ">";
-}
-function isStartOfEntity(val) {
-  return val === "&";
-}
-function isEndOfEntity(val) {
-  return val === ";";
-}
-function isWhiteSpace(value) {
-  return whitespaceRegex.test(value);
-}
-function stripAnyAttributes(word) {
-  if (isTag(word)) {
-    return stripTagAttributes(word);
-  }
-  return word;
-}
-function isWord(text) {
-  return wordRegex.test(text);
-}
-function getTagName(word) {
-  if (word === null) {
-    return "";
-  }
-  const match = tagRegex.exec(word);
-  if (match) {
-    return match.groups?.name.toLowerCase() ?? match[1].toLowerCase();
-  }
-  return "";
-}
-var Utils_default = {
-  isTag,
-  stripTagAttributes,
-  wrapText,
-  isStartOfTag,
-  isEndOfTag,
-  isStartOfEntity,
-  isEndOfEntity,
-  isWhiteSpace,
-  stripAnyAttributes,
-  isWord,
-  getTagName
-};
-
-// src/MatchFinder.ts
-var MatchFinder = class _MatchFinder {
-  oldWords;
-  newWords;
-  startInOld;
-  endInOld;
-  startInNew;
-  endInNew;
-  wordIndices = {};
-  options;
-  constructor(oldWords, newWords, startInOld, endInOld, startInNew, endInNew, options) {
-    this.oldWords = oldWords;
-    this.newWords = newWords;
-    this.startInOld = startInOld;
-    this.endInOld = endInOld;
-    this.startInNew = startInNew;
-    this.endInNew = endInNew;
-    this.options = options;
-  }
-  indexNewWords() {
-    this.wordIndices = {};
-    const block = [];
-    for (let i = this.startInNew; i < this.endInNew; i++) {
-      const word = this.normalizeForIndex(this.newWords[i]);
-      const key = _MatchFinder.putNewWord(block, word, this.options.blockSize);
-      if (key === null) {
-        continue;
-      }
-      if (!this.wordIndices[key]) {
-        this.wordIndices[key] = [];
-      }
-      this.wordIndices[key].push(i);
-    }
-  }
-  static putNewWord(block, word, blockSize) {
-    block.push(word);
-    if (block.length > blockSize) {
-      block.shift();
-    }
-    if (block.length !== blockSize) {
-      return null;
-    }
-    return block.join("");
-  }
-  normalizeForIndex(word) {
-    const output = Utils_default.stripAnyAttributes(word);
-    if (this.options.ignoreWhitespaceDifferences && Utils_default.isWhiteSpace(output)) {
-      return " ";
-    }
-    return output;
-  }
-  findMatch() {
-    this.indexNewWords();
-    this.removeRepeatingWords();
-    let hasIndices = false;
-    for (const _key in this.wordIndices) {
-      hasIndices = true;
-      break;
-    }
-    if (!hasIndices) {
-      return null;
-    }
-    let bestMatchInOld = this.startInOld;
-    let bestMatchInNew = this.startInNew;
-    let bestMatchSize = 0;
-    let matchLengthAt = /* @__PURE__ */ new Map();
-    const block = [];
-    for (let indexInOld = this.startInOld; indexInOld < this.endInOld; indexInOld++) {
-      const word = this.normalizeForIndex(this.oldWords[indexInOld]);
-      const index = _MatchFinder.putNewWord(block, word, this.options.blockSize);
-      if (index === null) {
-        continue;
-      }
-      const newMatchLengthAt = /* @__PURE__ */ new Map();
-      if (!this.wordIndices[index]) {
-        matchLengthAt = newMatchLengthAt;
-        continue;
-      }
-      for (const indexInNew of this.wordIndices[index]) {
-        const newMatchLength = (matchLengthAt.has(indexInNew - 1) ? matchLengthAt.get(indexInNew - 1) : 0) + 1;
-        newMatchLengthAt.set(indexInNew, newMatchLength);
-        if (newMatchLength > bestMatchSize) {
-          bestMatchInOld = indexInOld - newMatchLength - this.options.blockSize + 2;
-          bestMatchInNew = indexInNew - newMatchLength - this.options.blockSize + 2;
-          bestMatchSize = newMatchLength;
-        }
-      }
-      matchLengthAt = newMatchLengthAt;
-    }
-    return bestMatchSize !== 0 ? new Match(bestMatchInOld, bestMatchInNew, bestMatchSize + this.options.blockSize - 1) : null;
-  }
-  /**
-   * This method removes words that occur too many times. This way it reduces total count of comparison operations
-   * and as result the diff algorithm takes less time. But the side effect is that it may detect false differences of
-   * the repeating words.
-   * @private
-   */
-  removeRepeatingWords() {
-    const threshold = this.newWords.length * this.options.repeatingWordsAccuracy;
-    const repeatingWords = Object.entries(this.wordIndices).filter(([, indices]) => indices.length > threshold).map(([word]) => word);
-    for (const w of repeatingWords) {
-      delete this.wordIndices[w];
-    }
-  }
-};
-
-// src/Operation.ts
-var Operation = class {
-  action;
-  startInOld;
-  endInOld;
-  startInNew;
-  endInNew;
-  constructor(action, startInOld, endInOld, startInNew, endInNew) {
-    this.action = action;
-    this.startInOld = startInOld;
-    this.endInOld = endInOld;
-    this.startInNew = startInNew;
-    this.endInNew = endInNew;
-  }
-};
-
-// src/Mode.ts
-var Mode = /* @__PURE__ */ ((Mode2) => {
-  Mode2[Mode2["Character"] = 0] = "Character";
-  Mode2[Mode2["Tag"] = 1] = "Tag";
-  Mode2[Mode2["Whitespace"] = 2] = "Whitespace";
-  Mode2[Mode2["Entity"] = 3] = "Entity";
-  return Mode2;
-})(Mode || {});
-var Mode_default = Mode;
-
-// src/WordSplitter.ts
-var WordSplitter = class _WordSplitter {
-  text;
-  isBlockCheckRequired;
-  blockLocations;
-  mode;
-  isGrouping = false;
-  globbingUntil;
-  currentWord;
-  words;
-  static NotGlobbing = -1;
-  get currentWordHasChars() {
-    return this.currentWord.length > 0;
-  }
-  constructor(text, blockExpressions) {
-    this.text = text;
-    this.blockLocations = new BlockFinder(text, blockExpressions).findBlocks();
-    this.isBlockCheckRequired = this.blockLocations.hasBlocks;
-    this.mode = Mode_default.Character;
-    this.globbingUntil = _WordSplitter.NotGlobbing;
-    this.currentWord = [];
-    this.words = [];
-  }
-  process() {
-    for (let index = 0; index < this.text.length; index++) {
-      const character = this.text.charAt(index);
-      this.processCharacter(index, character);
-    }
-    this.appendCurrentWordToWords();
-    return this.words;
-  }
-  processCharacter(index, character) {
-    if (this.isGlobbing(index, character)) {
-      return;
-    }
-    switch (this.mode) {
-      case Mode_default.Character:
-        this.processTextCharacter(character);
-        break;
-      case Mode_default.Tag:
-        this.processHtmlTagContinuation(character);
-        break;
-      case Mode_default.Whitespace:
-        this.processWhiteSpaceContinuation(character);
-        break;
-      case Mode_default.Entity:
-        this.processEntityContinuation(character);
-        break;
-    }
-  }
-  processEntityContinuation(character) {
-    if (Utils_default.isStartOfTag(character)) {
-      this.appendCurrentWordToWords();
-      this.currentWord.push(character);
-      this.mode = Mode_default.Tag;
-    } else if (character.trim().length === 0) {
-      this.appendCurrentWordToWords();
-      this.currentWord.push(character);
-      this.mode = Mode_default.Whitespace;
-    } else if (Utils_default.isEndOfEntity(character)) {
-      let switchToNextMode = true;
-      if (this.currentWordHasChars) {
-        this.currentWord.push(character);
-        this.words.push(this.currentWord.join(""));
-        if (this.words.length > 2 && Utils_default.isWhiteSpace(this.words[this.words.length - 2]) && Utils_default.isWhiteSpace(this.words[this.words.length - 1])) {
-          const w1 = this.words[this.words.length - 2];
-          const w2 = this.words[this.words.length - 1];
-          this.words.splice(this.words.length - 2, 2);
-          this.currentWord = `${w1}${w2}`.split("");
-          this.mode = Mode_default.Whitespace;
-          switchToNextMode = false;
-        }
-      }
-      if (switchToNextMode) {
-        this.currentWord = [];
-        this.mode = Mode_default.Character;
-      }
-    } else if (Utils_default.isWord(character)) {
-      this.currentWord.push(character);
-    } else {
-      this.appendCurrentWordToWords();
-      this.currentWord.push(character);
-      this.mode = Mode_default.Character;
-    }
-  }
-  processWhiteSpaceContinuation(character) {
-    if (Utils_default.isStartOfTag(character)) {
-      this.appendCurrentWordToWords();
-      this.currentWord.push(character);
-      this.mode = Mode_default.Tag;
-    } else if (Utils_default.isStartOfEntity(character)) {
-      this.appendCurrentWordToWords();
-      this.currentWord.push(character);
-      this.mode = Mode_default.Entity;
-    } else if (Utils_default.isWhiteSpace(character)) {
-      this.currentWord.push(character);
-    } else {
-      this.appendCurrentWordToWords();
-      this.currentWord.push(character);
-      this.mode = Mode_default.Character;
-    }
-  }
-  processHtmlTagContinuation(character) {
-    if (Utils_default.isEndOfTag(character)) {
-      this.currentWord.push(character);
-      this.appendCurrentWordToWords();
-      this.mode = Utils_default.isWhiteSpace(character) ? Mode_default.Whitespace : Mode_default.Character;
-    } else {
-      this.currentWord.push(character);
-    }
-  }
-  processTextCharacter(character) {
-    if (Utils_default.isStartOfTag(character)) {
-      this.appendCurrentWordToWords();
-      this.currentWord.push("<");
-      this.mode = Mode_default.Tag;
-    } else if (Utils_default.isStartOfEntity(character)) {
-      this.appendCurrentWordToWords();
-      this.currentWord.push(character);
-      this.mode = Mode_default.Entity;
-    } else if (Utils_default.isWhiteSpace(character)) {
-      this.appendCurrentWordToWords();
-      this.currentWord.push(character);
-      this.mode = Mode_default.Whitespace;
-    } else if (Utils_default.isWord(character) && (this.currentWord.length === 0 || Utils_default.isWord(this.currentWord[this.currentWord.length - 1]))) {
-      this.currentWord.push(character);
-    } else {
-      this.appendCurrentWordToWords();
-      this.currentWord.push(character);
-    }
-  }
-  appendCurrentWordToWords() {
-    if (this.currentWordHasChars) {
-      this.words.push(this.currentWord.join(""));
-      this.currentWord = [];
-    }
-  }
-  isGlobbing(index, character) {
-    if (!this.isBlockCheckRequired) {
-      return false;
-    }
-    const isCurrentBlockTerminating = index === this.globbingUntil;
-    if (isCurrentBlockTerminating) {
-      this.globbingUntil = _WordSplitter.NotGlobbing;
-      this.isGrouping = false;
-      this.appendCurrentWordToWords();
-    }
-    const until = this.blockLocations.isInBlock(index);
-    if (until) {
-      this.isGrouping = true;
-      this.globbingUntil = until;
-    }
-    if (this.isGrouping) {
-      this.currentWord.push(character);
-      this.mode = Mode_default.Character;
-    }
-    return this.isGrouping;
-  }
-  static convertHtmlToListOfWords(text, blockExpressions) {
-    return new _WordSplitter(text, blockExpressions).process();
-  }
-};
-var BlockFinderResult = class {
-  blocks = /* @__PURE__ */ new Map();
-  addBlock(from, to) {
-    if (this.blocks.has(from)) {
-      throw new ArgumentError("One or more block expressions result in a text sequence that overlaps.");
-    }
-    this.blocks.set(from, to);
-  }
-  isInBlock(location) {
-    return this.blocks.get(location) ?? null;
-  }
-  get hasBlocks() {
-    return this.blocks.size > 0;
-  }
-};
-var ArgumentError = class extends Error {
-};
-var BlockFinder = class {
-  text;
-  blockExpressions;
-  constructor(text, blockExpressions) {
-    this.text = text;
-    this.blockExpressions = blockExpressions;
-  }
-  findBlocks() {
-    const result = new BlockFinderResult();
-    for (const expression of this.blockExpressions) {
-      this.processBlockMatcher(expression, result);
-    }
-    return result;
-  }
-  processBlockMatcher(exp, result) {
-    let match;
-    while ((match = exp.exec(this.text)) !== null) {
-      this.tryAddBlock(exp, match, result);
-    }
-  }
-  tryAddBlock(exp, match, result) {
-    try {
-      const from = match.index;
-      const to = match.index + match[0].length;
-      result.addBlock(from, to);
-    } catch {
-      throw new ArgumentError(
-        `One or more block expressions result in a text sequence that overlaps. Current expression: ${exp}`
-      );
-    }
-  }
-};
-
-// src/HtmlDiff.ts
-var HtmlDiff = class _HtmlDiff {
-  /**
-   * This value defines balance between speed and memory utilization. The higher it is the faster it works and more memory consumes.
-   * @private
-   */
-  static MatchGranularityMaximum = 4;
-  static DelTag = "del";
-  static InsTag = "ins";
-  // ignore case
-  static SpecialCaseClosingTags = [
-    "</strong>",
-    "</em>",
-    "</b>",
-    "</i>",
-    "</big>",
-    "</small>",
-    "</u>",
-    "</sub>",
-    "</sup>",
-    "</strike>",
-    "</s>",
-    "</span>"
-  ];
-  static SpecialCaseClosingTagsSet = /* @__PURE__ */ new Set([
-    "</strong>",
-    "</em>",
-    "</b>",
-    "</i>",
-    "</big>",
-    "</small>",
-    "</u>",
-    "</sub>",
-    "</sup>",
-    "</strike>",
-    "</s>",
-    "</span>"
-  ]);
-  static SpecialCaseOpeningTagRegex = /<((strong)|(b)|(i)|(em)|(big)|(small)|(u)|(sub)|(sup)|(strike)|(s)|(span))[>\s]+/i;
-  content = [];
-  newText;
-  oldText;
-  specialTagDiffStack = [];
-  newWords = [];
-  oldWords = [];
-  matchGranularity = 0;
-  blockExpressions = [];
-  /**
-   * Defines how to compare repeating words. Valid values are from 0 to 1.
-   * This value allows to exclude some words from comparison that eventually
-   * reduces the total time of the diff algorithm.
-   * 0 means that all words are excluded so the diff will not find any matching words at all.
-   * 1 (default value) means that all words participate in comparison so this is the most accurate case.
-   * 0.5 means that any word that occurs more than 50% times may be excluded from comparison. This doesn't
-   * mean that such words will definitely be excluded but only gives a permission to exclude them if necessary.
-   */
-  repeatingWordsAccuracy = 1;
-  /**
-   * If true all whitespaces are considered as equal
-   */
-  ignoreWhitespaceDifferences = false;
-  /**
-   * If some match is too small and located far from its neighbors then it is considered as orphan
-   * and removed. For example:
-   * <code>
-   * aaaaa bb ccccccccc dddddd ee
-   * 11111 bb 222222222 dddddd ee
-   * </code>
-   * will find two matches <code>bb</code> and <code>dddddd ee</code> but the first will be considered
-   * as orphan and ignored, as result it will consider texts <code>aaaaa bb ccccccccc</code> and
-   * <code>11111 bb 222222222</code> as single replacement:
-   * <code>
-   * &lt;del&gt;aaaaa bb ccccccccc&lt;/del&gt;&lt;ins&gt;11111 bb 222222222&lt;/ins&gt; dddddd ee
-   * </code>
-   * This property defines relative size of the match to be considered as orphan, from 0 to 1.
-   * 1 means that all matches will be considered as orphans.
-   * 0 (default) means that no match will be considered as orphan.
-   * 0.2 means that if match length is less than 20% of distance between its neighbors it is considered as orphan.
-   */
-  orphanMatchThreshold = 0;
-  /**
-   * Initializes a new instance of the class.
-   * @param oldText The old text.
-   * @param newText The new text.
-   */
-  constructor(oldText, newText) {
-    this.oldText = oldText;
-    this.newText = newText;
-  }
-  static execute(oldText, newText) {
-    return new _HtmlDiff(oldText, newText).build();
-  }
-  /**
-   * Builds the HTML diff output
-   * @return HTML diff markup
-   */
-  build() {
-    if (this.oldText === this.newText) {
-      return this.newText;
-    }
-    this.splitInputsToWords();
-    this.matchGranularity = Math.min(
-      _HtmlDiff.MatchGranularityMaximum,
-      Math.min(this.oldWords.length, this.newWords.length)
-    );
-    const operations = this.operations();
-    for (const op of operations) {
-      this.performOperation(op);
-    }
-    return this.content.join("");
-  }
-  /**
-   * Uses {@link expression} to group text together so that any change detected within the group is treated as a single block
-   * @param expression
-   */
-  addBlockExpression(expression) {
-    this.blockExpressions.push(expression);
-  }
-  splitInputsToWords() {
-    this.oldWords = WordSplitter.convertHtmlToListOfWords(this.oldText, this.blockExpressions);
-    this.oldText = "";
-    this.newWords = WordSplitter.convertHtmlToListOfWords(this.newText, this.blockExpressions);
-    this.newText = "";
-  }
-  performOperation(operation) {
-    switch (operation.action) {
-      case Action_default.Equal:
-        this.processEqualOperation(operation);
-        break;
-      case Action_default.Delete:
-        this.processDeleteOperation(operation, "diffdel");
-        break;
-      case Action_default.Insert:
-        this.processInsertOperation(operation, "diffins");
-        break;
-      case Action_default.None:
-        break;
-      case Action_default.Replace:
-        this.processReplaceOperation(operation);
-        break;
-    }
-  }
-  processReplaceOperation(operation) {
-    this.processDeleteOperation(operation, "diffmod");
-    this.processInsertOperation(operation, "diffmod");
-  }
-  processInsertOperation(operation, cssClass) {
-    const text = this.newWords.slice(operation.startInNew, operation.endInNew);
-    this.insertTag(_HtmlDiff.InsTag, cssClass, text);
-  }
-  processDeleteOperation(operation, cssClass) {
-    const text = this.oldWords.slice(operation.startInOld, operation.endInOld);
-    this.insertTag(_HtmlDiff.DelTag, cssClass, text);
-  }
-  processEqualOperation(operation) {
-    const result = this.newWords.slice(operation.startInNew, operation.endInNew);
-    this.content.push(result.join(""));
-  }
-  /**
-   * This method encloses words within a specified tag (ins or del), and adds this into "content",
-   * with a twist: if there are words contain tags, it actually creates multiple ins or del,
-   * so that they don't include any ins or del. This handles cases like
-   * old: '<p>a</p>'
-   * new: '<p>ab</p>
-   * <p>
-   *     c</b>'
-   *     diff result: '<p>a<ins>b</ins></p>
-   *     <p>
-   *         <ins>c</ins>
-   *     </p>
-   *     '
-   *     this still doesn't guarantee valid HTML (hint: think about diffing a text containing ins or
-   *     del tags), but handles correctly more cases than the earlier version.
-   *     P.S.: Spare a thought for people who write HTML browsers. They live in this ... every day.
-   * @param tag
-   * @param cssClass
-   * @param words
-   * @private
-   */
-  insertTag(tag, cssClass, words) {
-    while (true) {
-      if (words.length === 0) {
-        break;
-      }
-      const allWordsUntilFirstTag = this.extractConsecutiveWords(words, (x) => !Utils_default.isTag(x));
-      if (allWordsUntilFirstTag.length > 0) {
-        const text = Utils_default.wrapText(allWordsUntilFirstTag.join(""), tag, cssClass);
-        this.content.push(text);
-      }
-      const isInsertOpCompleted = words.length === 0;
-      if (isInsertOpCompleted) {
-        break;
-      }
-      const indexOfFirstNonTag = words.findIndex((x) => !Utils_default.isTag(x));
-      const indexLastTagInFirstTagBlock = indexOfFirstNonTag === -1 ? words.length - 1 : indexOfFirstNonTag - 1;
-      let specialCaseTagInjection = "";
-      let specialCaseTagInjectionIsBefore = false;
-      if (_HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) {
-        const tagNames = /* @__PURE__ */ new Set();
-        for (const word of words) {
-          if (Utils_default.isTag(word)) {
-            tagNames.add(Utils_default.getTagName(word));
-          }
-        }
-        const styledTagNames = Array.from(tagNames).join(" ");
-        this.specialTagDiffStack.push(words[0]);
-        specialCaseTagInjection = `<ins class='mod ${styledTagNames}'>`;
-        if (tag === _HtmlDiff.DelTag) {
-          words.shift();
-          while (words.length > 0 && _HtmlDiff.SpecialCaseOpeningTagRegex.test(words[0])) {
-            words.shift();
-          }
-        }
-      } else if (_HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) {
-        const openingTag = this.specialTagDiffStack.length === 0 ? null : this.specialTagDiffStack.pop();
-        const openingAndClosingTagsMatch = !!openingTag && Utils_default.getTagName(openingTag) === Utils_default.getTagName(words[indexLastTagInFirstTagBlock]);
-        if (!!openingTag && openingAndClosingTagsMatch) {
-          specialCaseTagInjection = "</ins>";
-          specialCaseTagInjectionIsBefore = true;
-        } else if (openingTag) {
-          this.specialTagDiffStack.push(openingTag);
-        }
-        if (tag === _HtmlDiff.DelTag) {
-          words.shift();
-          while (words.length > 0 && _HtmlDiff.SpecialCaseClosingTagsSet.has(words[0].toLowerCase())) {
-            words.shift();
-          }
-        }
-      }
-      if (words.length === 0 && specialCaseTagInjection.length === 0) {
-        break;
-      }
-      if (specialCaseTagInjectionIsBefore) {
-        this.content.push(specialCaseTagInjection + this.extractConsecutiveWords(words, Utils_default.isTag).join(""));
-      } else {
-        this.content.push(this.extractConsecutiveWords(words, Utils_default.isTag).join("") + specialCaseTagInjection);
-      }
-      if (words.length === 0) continue;
-      this.insertTag(tag, cssClass, words);
-      break;
-    }
-  }
-  extractConsecutiveWords(words, condition) {
-    let indexOfFirstTag = null;
-    for (let i = 0; i < words.length; i++) {
-      const word = words[i];
-      if (i === 0 && word === " ") {
-        words[i] = "&nbsp;";
-      }
-      if (!condition(word)) {
-        indexOfFirstTag = i;
-        break;
-      }
-    }
-    if (indexOfFirstTag !== null) {
-      const items2 = words.slice(0, indexOfFirstTag);
-      if (indexOfFirstTag > 0) {
-        words.splice(0, indexOfFirstTag);
-      }
-      return items2;
-    }
-    const items = words.slice(0);
-    words.splice(0, words.length);
-    return items;
-  }
-  operations() {
-    let positionInOld = 0;
-    let positionInNew = 0;
-    const operations = [];
-    const matches = this.matchingBlocks();
-    matches.push(new Match(this.oldWords.length, this.newWords.length, 0));
-    const matchesWithoutOrphans = this.removeOrphans(matches);
-    for (const match of matchesWithoutOrphans) {
-      const matchStartsAtCurrentPositionInOld = positionInOld === match.startInOld;
-      const matchStartsAtCurrentPositionInNew = positionInNew === match.startInNew;
-      let action;
-      if (!matchStartsAtCurrentPositionInOld && !matchStartsAtCurrentPositionInNew) {
-        action = Action_default.Replace;
-      } else if (matchStartsAtCurrentPositionInOld && !matchStartsAtCurrentPositionInNew) {
-        action = Action_default.Insert;
-      } else if (!matchStartsAtCurrentPositionInOld) {
-        action = Action_default.Delete;
-      } else {
-        action = Action_default.None;
-      }
-      if (action !== Action_default.None) {
-        operations.push(new Operation(action, positionInOld, match.startInOld, positionInNew, match.startInNew));
-      }
-      if (match.size !== 0) {
-        operations.push(new Operation(Action_default.Equal, match.startInOld, match.endInOld, match.startInNew, match.endInNew));
-      }
-      positionInOld = match.endInOld;
-      positionInNew = match.endInNew;
-    }
-    return operations;
-  }
-  *removeOrphans(matches) {
-    let prev = new Match(0, 0, 0);
-    let curr = null;
-    for (const next of matches) {
-      if (curr === null) {
-        curr = next;
-        continue;
-      }
-      if (prev.endInOld === curr.startInOld && prev.endInNew === curr.startInNew || curr.endInOld === next.startInOld && curr.endInNew === next.startInNew) {
-        yield curr;
-        prev = curr;
-        curr = next;
-        continue;
-      }
-      let oldDistanceInChars = 0;
-      for (let i = prev.endInOld; i < next.startInOld; i++) {
-        oldDistanceInChars += this.oldWords[i].length;
-      }
-      let newDistanceInChars = 0;
-      for (let i = prev.endInNew; i < next.startInNew; i++) {
-        newDistanceInChars += this.newWords[i].length;
-      }
-      let currMatchLengthInChars = 0;
-      for (let i = curr.startInNew; i < curr.endInNew; i++) {
-        currMatchLengthInChars += this.newWords[i].length;
-      }
-      if (currMatchLengthInChars > Math.max(oldDistanceInChars, newDistanceInChars) * this.orphanMatchThreshold) {
-        yield curr;
-      }
-      prev = curr;
-      curr = next;
-    }
-    if (curr !== null) {
-      yield curr;
-    }
-  }
-  matchingBlocks() {
-    const matchingBlocks = [];
-    this.findMatchingBlocks(0, this.oldWords.length, 0, this.newWords.length, matchingBlocks);
-    return matchingBlocks;
-  }
-  findMatchingBlocks(startInOld, endInOld, startInNew, endInNew, matchingBlocks) {
-    const match = this.findMatch(startInOld, endInOld, startInNew, endInNew);
-    if (match !== null) {
-      if (startInOld < match.startInOld && startInNew < match.startInNew) {
-        this.findMatchingBlocks(startInOld, match.startInOld, startInNew, match.startInNew, matchingBlocks);
-      }
-      matchingBlocks.push(match);
-      if (match.endInOld < endInOld && match.endInNew < endInNew) {
-        this.findMatchingBlocks(match.endInOld, endInOld, match.endInNew, endInNew, matchingBlocks);
-      }
-    }
-  }
-  findMatch(startInOld, endInOld, startInNew, endInNew) {
-    for (let i = this.matchGranularity; i > 0; i--) {
-      const options = {
-        blockSize: i,
-        repeatingWordsAccuracy: this.repeatingWordsAccuracy,
-        ignoreWhitespaceDifferences: this.ignoreWhitespaceDifferences
-      };
-      const finder = new MatchFinder(this.oldWords, this.newWords, startInOld, endInOld, startInNew, endInNew, options);
-      const match = finder.findMatch();
-      if (match !== null) return match;
-    }
-    return null;
-  }
-};
-export {
-  HtmlDiff as default
-};
-//# sourceMappingURL=HtmlDiff.js.map