@createiq/htmldiff 1.0.2 → 1.0.4-beta.0

package/dist/HtmlDiff.mjs

@@ -0,0 +1,843 @@
+//#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;
+	}
+};
+//#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);
+}
+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
+};
+//#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];
+	}
+};
+//#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;
+	}
+};
+//#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 {};
+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}`);
+		}
+	}
+};
+//#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;
+	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;
+		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);
+	}
+	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 origStart = this.oldContentToOriginal[contentStart];
+		const origEnd = contentEnd < this.oldContentToOriginal.length ? this.oldContentToOriginal[contentEnd] : this.oldWords.length;
+		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
+export { HtmlDiff as default };
+
+//# sourceMappingURL=HtmlDiff.mjs.map