@createiq/htmldiff 1.0.3 → 1.0.4-beta.1

package/dist/HtmlDiff.cjs

@@ -1,850 +1,852 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/HtmlDiff.ts
-var HtmlDiff_exports = {};
-__export(HtmlDiff_exports, {
-  default: () => HtmlDiff
-});
-module.exports = __toCommonJS(HtmlDiff_exports);
-
-// 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
+//#region 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;
-  }
+	_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"];
+//#endregion
+//#region src/Utils.ts
+const openingTagRegex = /^\s*<[^>]+>\s*$/;
+const closingTagTexRegex = /^\s*<\/[^>]+>\s*$/;
+const tagWordRegex = /<[^\s>]+/;
+const whitespaceRegex = /^(\s|&nbsp;)+$/;
+const wordRegex = /[\w#@]+/;
+const tagRegex = /<\/?(?<name>[^\s/>]+)[^>]*>/;
+const SpecialCaseWordTags = ["<img"];
 function isTag(item) {
-  if (SpecialCaseWordTags.some((re) => item?.startsWith(re))) {
-    return false;
-  }
-  return isOpeningTag(item) || isClosingTag(item);
+	if (SpecialCaseWordTags.some((re) => item?.startsWith(re))) return false;
+	return isOpeningTag(item) || isClosingTag(item);
 }
 function isOpeningTag(item) {
-  return openingTagRegex.test(item);
+	return openingTagRegex.test(item);
 }
 function isClosingTag(item) {
-  return closingTagTexRegex.test(item);
+	return closingTagTexRegex.test(item);
 }
 function stripTagAttributes(word) {
-  const match = tagWordRegex.exec(word);
-  if (match) {
-    return `${match[0]}${word.endsWith("/>") ? "/>" : ">"}`;
-  }
-  return 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}>`;
+	return `<${tagName} class='${cssClass}'>${text}</${tagName}>`;
 }
 function isStartOfTag(val) {
-  return val === "<";
+	return val === "<";
 }
 function isEndOfTag(val) {
-  return val === ">";
+	return val === ">";
 }
 function isStartOfEntity(val) {
-  return val === "&";
+	return val === "&";
 }
 function isEndOfEntity(val) {
-  return val === ";";
+	return val === ";";
 }
 function isWhiteSpace(value) {
-  return whitespaceRegex.test(value);
+	return whitespaceRegex.test(value);
 }
 function stripAnyAttributes(word) {
-  if (isTag(word)) {
-    return stripTagAttributes(word);
-  }
-  return word;
+	if (isTag(word)) return stripTagAttributes(word);
+	return word;
 }
 function isWord(text) {
-  return wordRegex.test(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 "";
+	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
+	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];
-    }
-  }
+//#endregion
+//#region src/MatchFinder.ts
+/**
+* Finds the longest match in given texts. It uses indexing with fixed granularity that is used to compare blocks of text.
+*/
+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
+//#endregion
+//#region 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;
-  }
+	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();
-  }
+//#endregion
+//#region 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 = 0;
+		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 0:
+				this.processTextCharacter(character);
+				break;
+			case 1:
+				this.processHtmlTagContinuation(character);
+				break;
+			case 2:
+				this.processWhiteSpaceContinuation(character);
+				break;
+			case 3:
+				this.processEntityContinuation(character);
+				break;
+		}
+	}
+	processEntityContinuation(character) {
+		if (Utils_default.isStartOfTag(character)) {
+			this.appendCurrentWordToWords();
+			this.currentWord.push(character);
+			this.mode = 1;
+		} else if (character.trim().length === 0) {
+			this.appendCurrentWordToWords();
+			this.currentWord.push(character);
+			this.mode = 2;
+		} 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 = 2;
+					switchToNextMode = false;
+				}
+			}
+			if (switchToNextMode) {
+				this.currentWord = [];
+				this.mode = 0;
+			}
+		} else if (Utils_default.isWord(character)) this.currentWord.push(character);
+		else {
+			this.appendCurrentWordToWords();
+			this.currentWord.push(character);
+			this.mode = 0;
+		}
+	}
+	processWhiteSpaceContinuation(character) {
+		if (Utils_default.isStartOfTag(character)) {
+			this.appendCurrentWordToWords();
+			this.currentWord.push(character);
+			this.mode = 1;
+		} else if (Utils_default.isStartOfEntity(character)) {
+			this.appendCurrentWordToWords();
+			this.currentWord.push(character);
+			this.mode = 3;
+		} else if (Utils_default.isWhiteSpace(character)) this.currentWord.push(character);
+		else {
+			this.appendCurrentWordToWords();
+			this.currentWord.push(character);
+			this.mode = 0;
+		}
+	}
+	processHtmlTagContinuation(character) {
+		if (Utils_default.isEndOfTag(character)) {
+			this.currentWord.push(character);
+			this.appendCurrentWordToWords();
+			this.mode = Utils_default.isWhiteSpace(character) ? 2 : 0;
+		} else this.currentWord.push(character);
+	}
+	processTextCharacter(character) {
+		if (Utils_default.isStartOfTag(character)) {
+			this.appendCurrentWordToWords();
+			this.currentWord.push("<");
+			this.mode = 1;
+		} else if (Utils_default.isStartOfEntity(character)) {
+			this.appendCurrentWordToWords();
+			this.currentWord.push(character);
+			this.mode = 3;
+		} else if (Utils_default.isWhiteSpace(character)) {
+			this.appendCurrentWordToWords();
+			this.currentWord.push(character);
+			this.mode = 2;
+		} 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;
+		if (index === this.globbingUntil) {
+			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 = 0;
+		}
+		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 {
+	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}`
-      );
-    }
-  }
+	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;
-  }
+//#endregion
+//#region 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";
+	static SpecialCaseClosingTags = [
+		"</strong>",
+		"</em>",
+		"</b>",
+		"</i>",
+		"</big>",
+		"</small>",
+		"</u>",
+		"</sub>",
+		"</sup>",
+		"</strike>",
+		"</s>",
+		"</span>"
+	];
+	static SpecialCaseClosingTagsSet = 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;
+	static FormattingTags = new Set([
+		"strong",
+		"em",
+		"b",
+		"i",
+		"big",
+		"small",
+		"u",
+		"sub",
+		"sup",
+		"strike",
+		"s",
+		"span"
+	]);
+	content = [];
+	newText;
+	oldText;
+	specialTagDiffStack = [];
+	newWords = [];
+	oldWords = [];
+	/**
+	* Content-only projections of oldWords/newWords (structural tags and adjacent whitespace removed).
+	* When null, no structural normalization is applied (the word arrays are identical for diffing).
+	*/
+	oldContentWords = null;
+	newContentWords = null;
+	/** Maps content-word index → original word index */
+	oldContentToOriginal = null;
+	newContentToOriginal = null;
+	/** Tracks the last original old word index output, so equal operations can include leading structural tags */
+	lastOriginalOldOutputIndex = 0;
+	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.buildContentProjections();
+		const wordsForDiffOld = this.oldContentWords ?? this.oldWords;
+		const wordsForDiffNew = this.newContentWords ?? this.newWords;
+		this.matchGranularity = Math.min(HtmlDiff.MatchGranularityMaximum, Math.min(wordsForDiffOld.length, wordsForDiffNew.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 = "";
+	}
+	/**
+	* Checks whether the two word arrays have structural HTML differences (different non-formatting tags
+	* or different whitespace between structural tags). When they do, builds "content projections" that
+	* strip structural noise so the diff algorithm only sees meaningful content and formatting changes.
+	*/
+	buildContentProjections() {
+		const oldProjection = HtmlDiff.createContentProjection(this.oldWords);
+		const newProjection = HtmlDiff.createContentProjection(this.newWords);
+		if (!HtmlDiff.hasStructuralDifferences(this.oldWords, this.newWords)) return;
+		if (oldProjection.contentWords.length === 0 || newProjection.contentWords.length === 0) return;
+		this.oldContentWords = oldProjection.contentWords;
+		this.oldContentToOriginal = oldProjection.contentToOriginal;
+		this.newContentWords = newProjection.contentWords;
+		this.newContentToOriginal = newProjection.contentToOriginal;
+	}
+	/**
+	* Tags that commonly serve as content wrappers and may change structurally
+	* without affecting the actual content. Only these tags are stripped during
+	* structural normalization.
+	*/
+	static WrapperTags = new Set([
+		"div",
+		"p",
+		"section",
+		"article",
+		"main",
+		"header",
+		"footer",
+		"aside",
+		"nav"
+	]);
+	static isStructuralTag(word) {
+		if (!Utils_default.isTag(word)) return false;
+		const tagName = Utils_default.getTagName(word);
+		return HtmlDiff.WrapperTags.has(tagName);
+	}
+	/**
+	* Returns true if words between structural tags are just whitespace (indentation).
+	*/
+	static isStructuralWhitespace(words, index) {
+		if (!Utils_default.isWhiteSpace(words[index])) return false;
+		const prevIsStructural = index === 0 || HtmlDiff.isStructuralTag(words[index - 1]);
+		const nextIsStructural = index === words.length - 1 || HtmlDiff.isStructuralTag(words[index + 1]);
+		return prevIsStructural || nextIsStructural;
+	}
+	static createContentProjection(words) {
+		const contentWords = [];
+		const contentToOriginal = [];
+		for (let i = 0; i < words.length; i++) {
+			if (HtmlDiff.isStructuralTag(words[i])) continue;
+			if (HtmlDiff.isStructuralWhitespace(words, i)) continue;
+			contentWords.push(words[i]);
+			contentToOriginal.push(i);
+		}
+		return {
+			contentWords,
+			contentToOriginal
+		};
+	}
+	static hasStructuralDifferences(oldWords, newWords) {
+		const oldStructural = [];
+		const newStructural = [];
+		for (const w of oldWords) if (HtmlDiff.isStructuralTag(w)) oldStructural.push(Utils_default.stripTagAttributes(w));
+		for (const w of newWords) if (HtmlDiff.isStructuralTag(w)) newStructural.push(Utils_default.stripTagAttributes(w));
+		if (oldStructural.length !== newStructural.length) return true;
+		for (let i = 0; i < oldStructural.length; i++) if (oldStructural[i] !== newStructural[i]) return true;
+		return false;
+	}
+	performOperation(operation) {
+		switch (operation.action) {
+			case 0:
+				this.processEqualOperation(operation);
+				break;
+			case 1:
+				this.processDeleteOperation(operation, "diffdel");
+				break;
+			case 2:
+				this.processInsertOperation(operation, "diffins");
+				break;
+			case 3: break;
+			case 4:
+				this.processReplaceOperation(operation);
+				break;
+		}
+	}
+	processReplaceOperation(operation) {
+		this.processDeleteOperation(operation, "diffmod");
+		this.processInsertOperation(operation, "diffmod");
+	}
+	processInsertOperation(operation, cssClass) {
+		const words = this.oldContentWords ? this.getOriginalNewWords(operation.startInNew, operation.endInNew) : this.newWords.slice(operation.startInNew, operation.endInNew);
+		this.insertTag(HtmlDiff.InsTag, cssClass, words);
+	}
+	processDeleteOperation(operation, cssClass) {
+		const words = this.oldContentWords ? this.getOriginalOldWords(operation.startInOld, operation.endInOld) : this.oldWords.slice(operation.startInOld, operation.endInOld);
+		this.insertTag(HtmlDiff.DelTag, cssClass, words);
+		if (this.oldContentToOriginal && operation.endInOld > 0) {
+			const lastDeletedOrigIdx = this.oldContentToOriginal[operation.endInOld - 1];
+			this.lastOriginalOldOutputIndex = Math.max(this.lastOriginalOldOutputIndex, lastDeletedOrigIdx + 1);
+		}
+	}
+	processEqualOperation(operation) {
+		if (this.oldContentWords) {
+			const result = this.getOriginalOldWordsWithStructure(operation.startInOld, operation.endInOld);
+			this.content.push(result.join(""));
+		} else {
+			const result = this.newWords.slice(operation.startInNew, operation.endInNew);
+			this.content.push(result.join(""));
+		}
+	}
+	/**
+	* Gets original old words for a content-index range, including only content and formatting tags
+	* (used for delete/replace operations where we don't want structural tags).
+	*/
+	getOriginalOldWords(contentStart, contentEnd) {
+		if (!this.oldContentToOriginal) return this.oldWords.slice(contentStart, contentEnd);
+		const result = [];
+		for (let i = contentStart; i < contentEnd; i++) result.push(this.oldWords[this.oldContentToOriginal[i]]);
+		return result;
+	}
+	/**
+	* Gets original new words for a content-index range, including only content and formatting tags
+	* (used for insert/replace operations where we don't want structural tags).
+	*/
+	getOriginalNewWords(contentStart, contentEnd) {
+		if (!this.newContentToOriginal) return this.newWords.slice(contentStart, contentEnd);
+		const result = [];
+		for (let i = contentStart; i < contentEnd; i++) result.push(this.newWords[this.newContentToOriginal[i]]);
+		return result;
+	}
+	/**
+	* Gets original old words for a content-index range, INCLUDING structural tags and whitespace
+	* between the content words (used for equal operations to preserve old HTML structure).
+	*/
+	getOriginalOldWordsWithStructure(contentStart, contentEnd) {
+		if (!this.oldContentToOriginal) return this.oldWords.slice(contentStart, contentEnd);
+		if (contentStart >= contentEnd) return [];
+		const firstContentOrigIdx = this.oldContentToOriginal[contentStart];
+		const origStart = Math.min(this.lastOriginalOldOutputIndex, firstContentOrigIdx);
+		const origEnd = contentEnd < this.oldContentToOriginal.length ? this.oldContentToOriginal[contentEnd] : this.oldWords.length;
+		this.lastOriginalOldOutputIndex = origEnd;
+		return this.oldWords.slice(origStart, origEnd);
+	}
+	/**
+	* 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);
+			}
+			if (words.length === 0) 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 items = words.slice(0, indexOfFirstTag);
+			if (indexOfFirstTag > 0) words.splice(0, indexOfFirstTag);
+			return items;
+		}
+		const items = words.slice(0);
+		words.splice(0, words.length);
+		return items;
+	}
+	operations() {
+		let positionInOld = 0;
+		let positionInNew = 0;
+		const operations = [];
+		const wordsForDiffOld = this.oldContentWords ?? this.oldWords;
+		const wordsForDiffNew = this.newContentWords ?? this.newWords;
+		const matches = this.matchingBlocks();
+		matches.push(new Match(wordsForDiffOld.length, wordsForDiffNew.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 = 4;
+			else if (matchStartsAtCurrentPositionInOld && !matchStartsAtCurrentPositionInNew) action = 2;
+			else if (!matchStartsAtCurrentPositionInOld) action = 1;
+			else action = 3;
+			if (action !== 3) operations.push(new Operation(action, positionInOld, match.startInOld, positionInNew, match.startInNew));
+			if (match.size !== 0) operations.push(new Operation(0, match.startInOld, match.endInOld, match.startInNew, match.endInNew));
+			positionInOld = match.endInOld;
+			positionInNew = match.endInNew;
+		}
+		return operations;
+	}
+	*removeOrphans(matches) {
+		const wordsForDiffOld = this.oldContentWords ?? this.oldWords;
+		const wordsForDiffNew = this.newContentWords ?? this.newWords;
+		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 += wordsForDiffOld[i].length;
+			let newDistanceInChars = 0;
+			for (let i = prev.endInNew; i < next.startInNew; i++) newDistanceInChars += wordsForDiffNew[i].length;
+			let currMatchLengthInChars = 0;
+			for (let i = curr.startInNew; i < curr.endInNew; i++) currMatchLengthInChars += wordsForDiffNew[i].length;
+			if (currMatchLengthInChars > Math.max(oldDistanceInChars, newDistanceInChars) * this.orphanMatchThreshold) yield curr;
+			prev = curr;
+			curr = next;
+		}
+		if (curr !== null) yield curr;
+	}
+	matchingBlocks() {
+		const wordsForDiffOld = this.oldContentWords ?? this.oldWords;
+		const wordsForDiffNew = this.newContentWords ?? this.newWords;
+		const matchingBlocks = [];
+		this.findMatchingBlocks(0, wordsForDiffOld.length, 0, wordsForDiffNew.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) {
+		const wordsForDiffOld = this.oldContentWords ?? this.oldWords;
+		const wordsForDiffNew = this.newContentWords ?? this.newWords;
+		for (let i = this.matchGranularity; i > 0; i--) {
+			const match = new MatchFinder(wordsForDiffOld, wordsForDiffNew, startInOld, endInOld, startInNew, endInNew, {
+				blockSize: i,
+				repeatingWordsAccuracy: this.repeatingWordsAccuracy,
+				ignoreWhitespaceDifferences: this.ignoreWhitespaceDifferences
+			}).findMatch();
+			if (match !== null) return match;
+		}
+		return null;
+	}
 };
+//#endregion
+module.exports = HtmlDiff;
+
 //# sourceMappingURL=HtmlDiff.cjs.map