From a25d90335ad3738b6831288190132c2f7498465c Mon Sep 17 00:00:00 2001
From: erdgeist <erdgeist@erdgeist.org>
Date: Fri, 10 Jul 2026 00:35:24 +0200
Subject: Retire vendored cacycle_diff.js for a diff-lcs-based diff view

Revisions#diff now computes an inline or side-by-side word diff
server-side (Page#diff_against, lib/html_word_diff.rb) instead of
shipping raw/escaped content to the browser for a 2008-era vendored
JS differ to mangle. View mode is picked via a `view` param, settable
either on the diff page itself or directly from the revisions#index
sticky bar next to "Diff revisions".

Also fixes a pre-existing bug in RevisionsController#diff's single-
revision branch, which set params[:start]/params[:end] instead of
params[:start_revision]/params[:end_revision].
---
 public/javascripts/cacycle_diff.js | 1112 ------------------------------------
 1 file changed, 1112 deletions(-)
 delete mode 100644 public/javascripts/cacycle_diff.js

(limited to 'public/javascripts')

diff --git a/public/javascripts/cacycle_diff.js b/public/javascripts/cacycle_diff.js
deleted file mode 100644
index 24f9d0b..0000000
--- a/public/javascripts/cacycle_diff.js
+++ /dev/null
@@ -1,1112 +0,0 @@
-// <pre><nowiki>
- 
-/*
- 
-Name:    diff.js
-Version: 0.9.5a (April 6, 2008)
-Info:    http://en.wikipedia.org/wiki/User:Cacycle/diff
-Code:    http://en.wikipedia.org/wiki/User:Cacycle/diff.js
- 
-JavaScript diff algorithm by [[en:User:Cacycle]] (http://en.wikipedia.org/wiki/User_talk:Cacycle).
-Outputs html/css-formatted new text with highlighted deletions, inserts, and block moves.
- 
-The program uses cross-browser code and should work with all modern browsers. It has been tested with:
-* Mozilla Firefox 1.5.0.1
-* Mozilla SeaMonkey 1.0
-* Opera 8.53
-* Internet Explorer 6.0.2900.2180
-* Internet Explorer 7.0.5730.11
-This program is also compatibel with Greasemonkey
- 
-An implementation of the word-based algorithm from:
- 
-Communications of the ACM 21(4):264 (1978)
-http://doi.acm.org/10.1145/359460.359467
- 
-With the following additional feature:
- 
-* Word types have been optimized for MediaWiki source texts
-* Additional post-pass 5 code for resolving islands caused by adding
-  two common words at the end of sequences of common words
-* Additional detection of block borders and color coding of moved blocks and their original position
-* Optional "intelligent" omission of unchanged parts from the output
- 
-This code is used by the MediaWiki in-browser text editors [[en:User:Cacycle/editor]] and [[en:User:Cacycle/wikEd]]
-and the enhanced diff view tool wikEdDiff [[en:User:Cacycle/wikEd]].
- 
-Usage: var htmlText = WDiffString(oldText, newText);
- 
-This code has been released into the public domain.
- 
-Datastructures:
- 
-text: an object that holds all text related datastructures
-  .newWords: consecutive words of the new text (N)
-  .oldWords: consecutive words of the old text (O)
-  .newToOld: array of corresponding word number in old text (NA)
-  .oldToNew: array of corresponding word number in new text (OA)
-  .message:  output message for testing purposes
- 
-symbol['word']: symbol table for passes 1 - 3, holds words as a hash
-  .newCtr:  new word occurences counter (NC)
-  .oldCtr:  old word occurences counter (OC)
-  .toNew:   table last old word number
-  .toOld:   last new word number (OLNA)
- 
-block: an object that holds block move information
-  blocks indexed after new text:
-  .newStart:  new text word number of start of this block
-  .newLength: element number of this block including non-words
-  .newWords:  true word number of this block
-  .newNumber: corresponding block index in old text
-  .newBlock:  moved-block-number of a block that has been moved here
-  .newLeft:   moved-block-number of a block that has been moved from this border leftwards
-  .newRight:  moved-block-number of a block that has been moved from this border rightwards
-  .newLeftIndex:  index number of a block that has been moved from this border leftwards
-  .newRightIndex: index number of a block that has been moved from this border rightwards
-  blocks indexed after old text:
-  .oldStart:  word number of start of this block
-  .oldToNew:  corresponding new text word number of start
-  .oldLength: element number of this block including non-words
-  .oldWords:  true word number of this block
- 
-*/
- 
- 
-// css for change indicators
-if (typeof(wDiffStyleDelete) == 'undefined') { window.wDiffStyleDelete = 'font-weight: normal; text-decoration: none; color: #fff; background-color: #990033;'; }
-if (typeof(wDiffStyleInsert) == 'undefined') { window.wDiffStyleInsert = 'font-weight: normal; text-decoration: none; color: #fff; background-color: #009933;'; }
-if (typeof(wDiffStyleMoved)  == 'undefined') { window.wDiffStyleMoved  = 'font-weight: bold;  color: #000; vertical-align: text-bottom; font-size: xx-small; padding: 0; border: solid 1px;'; }
-if (typeof(wDiffStyleBlock)  == 'undefined') { window.wDiffStyleBlock  = [
-  'color: #000; background-color: #ffff80;',
-  'color: #000; background-color: #c0ffff;',
-  'color: #000; background-color: #ffd0f0;',
-  'color: #000; background-color: #ffe080;',
-  'color: #000; background-color: #aaddff;',
-  'color: #000; background-color: #ddaaff;',
-  'color: #000; background-color: #ffbbbb;',
-  'color: #000; background-color: #d8ffa0;',
-  'color: #000; background-color: #d0d0d0;'
-]; }
- 
-// html for change indicators, {number} is replaced by the block number
-// {block} is replaced by the block style, class and html comments are important for shortening the output
-if (typeof(wDiffHtmlMovedRight)  == 'undefined') { window.wDiffHtmlMovedRight  = '<input class="wDiffHtmlMovedRight" type="button" value="&gt;" style="' + wDiffStyleMoved + ' {block}"><!--wDiffHtmlMovedRight-->'; }
-if (typeof(wDiffHtmlMovedLeft)   == 'undefined') { window.wDiffHtmlMovedLeft   = '<input class="wDiffHtmlMovedLeft" type="button" value="&lt;" style="' + wDiffStyleMoved + ' {block}"><!--wDiffHtmlMovedLeft-->'; }
- 
-if (typeof(wDiffHtmlBlockStart)  == 'undefined') { window.wDiffHtmlBlockStart  = '<span class="wDiffHtmlBlock" style="{block}">'; }
-if (typeof(wDiffHtmlBlockEnd)    == 'undefined') { window.wDiffHtmlBlockEnd    = '</span><!--wDiffHtmlBlock-->'; }
- 
-if (typeof(wDiffHtmlDeleteStart) == 'undefined') { window.wDiffHtmlDeleteStart = '<span class="wDiffHtmlDelete" style="' + wDiffStyleDelete + '">'; }
-if (typeof(wDiffHtmlDeleteEnd)   == 'undefined') { window.wDiffHtmlDeleteEnd   = '</span><!--wDiffHtmlDelete-->'; }
- 
-if (typeof(wDiffHtmlInsertStart) == 'undefined') { window.wDiffHtmlInsertStart = '<span class="wDiffHtmlInsert" style="' + wDiffStyleInsert + '">'; }
-if (typeof(wDiffHtmlInsertEnd)   == 'undefined') { window.wDiffHtmlInsertEnd   = '</span><!--wDiffHtmlInsert-->'; }
- 
-// minimal number of real words for a moved block (0 for always displaying block move indicators)
-if (typeof(wDiffBlockMinLength) == 'undefined') { window.wDiffBlockMinLength = 3; }
- 
-// exclude identical sequence starts and endings from change marking
-if (typeof(wDiffWordDiff) == 'undefined') { window.wDiffWordDiff = true; }
- 
-// enable recursive diff to resolve problematic sequences
-if (typeof(wDiffRecursiveDiff) == 'undefined') { window.wDiffRecursiveDiff = true; }
- 
-// enable block move display
-if (typeof(wDiffShowBlockMoves) == 'undefined') { window.wDiffShowBlockMoves = true; }
- 
-// remove unchanged parts from final output
- 
-// characters before diff tag to search for previous heading, paragraph, line break, cut characters
-if (typeof(wDiffHeadingBefore)   == 'undefined') { window.wDiffHeadingBefore   = 1500; }
-if (typeof(wDiffParagraphBefore) == 'undefined') { window.wDiffParagraphBefore = 1500; }
-if (typeof(wDiffLineBeforeMax)   == 'undefined') { window.wDiffLineBeforeMax   = 1000; }
-if (typeof(wDiffLineBeforeMin)   == 'undefined') { window.wDiffLineBeforeMin   =  500; }
-if (typeof(wDiffBlankBeforeMax)  == 'undefined') { window.wDiffBlankBeforeMax  = 1000; }
-if (typeof(wDiffBlankBeforeMin)  == 'undefined') { window.wDiffBlankBeforeMin  =  500; }
-if (typeof(wDiffCharsBefore)     == 'undefined') { window.wDiffCharsBefore     =  500; }
- 
-// characters after diff tag to search for next heading, paragraph, line break, or characters
-if (typeof(wDiffHeadingAfter)   == 'undefined') { window.wDiffHeadingAfter   = 1500; }
-if (typeof(wDiffParagraphAfter) == 'undefined') { window.wDiffParagraphAfter = 1500; }
-if (typeof(wDiffLineAfterMax)   == 'undefined') { window.wDiffLineAfterMax   = 1000; }
-if (typeof(wDiffLineAfterMin)   == 'undefined') { window.wDiffLineAfterMin   =  500; }
-if (typeof(wDiffBlankAfterMax)  == 'undefined') { window.wDiffBlankAfterMax  = 1000; }
-if (typeof(wDiffBlankAfterMin)  == 'undefined') { window.wDiffBlankAfterMin  =  500; }
-if (typeof(wDiffCharsAfter)     == 'undefined') { window.wDiffCharsAfter     =  500; }
- 
-// maximal fragment distance to join close fragments
-if (typeof(wDiffFragmentJoin)  == 'undefined') { window.wDiffFragmentJoin = 1000; }
-if (typeof(wDiffOmittedChars)  == 'undefined') { window.wDiffOmittedChars = '…'; }
-if (typeof(wDiffOmittedLines)  == 'undefined') { window.wDiffOmittedLines = '<hr style="height: 2px; margin: 1em 10%;">'; }
-if (typeof(wDiffNoChange)      == 'undefined') { window.wDiffNoChange     = '<hr style="height: 2px; margin: 1em 20%;">'; }
- 
-// compatibility fix for old name of main function
-window.StringDiff = window.WDiffString;
- 
- 
-// WDiffString: main program
-// input: oldText, newText, strings containing the texts
-// returns: html diff
- 
-window.WDiffString = function(oldText, newText) {
- 
-// IE / Mac fix
-  oldText = oldText.replace(/(\r\n)/g, '\n');
-  newText = newText.replace(/(\r\n)/g, '\n');
- 
-  var text = {};
-  text.newWords = [];
-  text.oldWords = [];
-  text.newToOld = [];
-  text.oldToNew = [];
-  text.message = '';
-  var block = {};
-  var outText = '';
- 
-// trap trivial changes: no change
-  if (oldText == newText) {
-    outText = newText;
-    outText = WDiffEscape(outText);
-    outText = WDiffHtmlFormat(outText);
-    return(outText);
-  }
- 
-// trap trivial changes: old text deleted
-  if ( (oldText == null) || (oldText.length == 0) ) {
-    outText = newText;
-    outText = WDiffEscape(outText);
-    outText = WDiffHtmlFormat(outText);
-    outText = wDiffHtmlInsertStart + outText + wDiffHtmlInsertEnd;
-    return(outText);
-  }
- 
-// trap trivial changes: new text deleted
-  if ( (newText == null) || (newText.length == 0) ) {
-    outText = oldText;
-    outText = WDiffEscape(outText);
-    outText = WDiffHtmlFormat(outText);
-    outText = wDiffHtmlDeleteStart + outText + wDiffHtmlDeleteEnd;
-    return(outText);
-  }
- 
-// split new and old text into words
-  WDiffSplitText(oldText, newText, text);
- 
-// calculate diff information
-  WDiffText(text);
- 
-//detect block borders and moved blocks
-  WDiffDetectBlocks(text, block);
- 
-// process diff data into formatted html text
-  outText = WDiffToHtml(text, block);
- 
-// IE fix
-  outText = outText.replace(/> ( *)</g, '>&nbsp;$1<');
- 
-  return(outText);
-}
- 
- 
-// WDiffSplitText: split new and old text into words
-// input: oldText, newText, strings containing the texts
-// changes: text.newWords and text.oldWords, arrays containing the texts in arrays of words
- 
-window.WDiffSplitText = function(oldText, newText, text) {
- 
-// convert strange spaces
-  oldText = oldText.replace(/[\t\u000b\u00a0\u2028\u2029]+/g, ' ');
-  newText = newText.replace(/[\t\u000b\u00a0\u2028\u2029]+/g, ' ');
- 
-// split old text into words
- 
-//              /     |    |    |    |    |   |  |     |   |  |  |    |    |    | /
-  var pattern = /[\w]+|\[\[|\]\]|\{\{|\}\}|\n+| +|&\w+;|'''|''|=+|\{\||\|\}|\|\-|./g;
-  var result;
-  do {
-    result = pattern.exec(oldText);
-    if (result != null) {
-      text.oldWords.push(result[0]);
-    }
-  } while (result != null);
- 
-// split new text into words
-  do {
-    result = pattern.exec(newText);
-    if (result != null) {
-      text.newWords.push(result[0]);
-    }
-  } while (result != null);
- 
-  return;
-}
- 
- 
-// WDiffText: calculate diff information
-// input: text.newWords and text.oldWords, arrays containing the texts in arrays of words
-// optionally for recursive calls: newStart, newEnd, oldStart, oldEnd, recursionLevel
-// changes: text.newToOld and text.oldToNew, containing the line numbers in the other version
- 
-window.WDiffText = function(text, newStart, newEnd, oldStart, oldEnd, recursionLevel) {
- 
-  symbol = new Object();
-  symbol.newCtr = [];
-  symbol.oldCtr = [];
-  symbol.toNew = [];
-  symbol.toOld = [];
- 
-// set defaults
-  newStart = newStart || 0;
-  newEnd = newEnd || text.newWords.length;
-  oldStart = oldStart || 0;
-  oldEnd = oldEnd || text.oldWords.length;
-  recursionLevel = recursionLevel || 0;
- 
-// limit recursion depth
-  if (recursionLevel > 10) {
-    return;
-  }
- 
-// pass 1: parse new text into symbol table s
- 
-  var word;
-  for (var i = newStart; i < newEnd; i ++) {
-    word = text.newWords[i];
- 
-// add new entry to symbol table
-    if ( symbol[word] == null) {
-      symbol[word] = { newCtr: 0, oldCtr: 0, toNew: null, toOld: null };
-    }
- 
-// increment symbol table word counter for new text
-    symbol[word].newCtr ++;
- 
-// add last word number in new text
-    symbol[word].toNew = i;
-  }
- 
-// pass 2: parse old text into symbol table
- 
-  for (var j = oldStart; j < oldEnd; j ++) {
-    word = text.oldWords[j];
- 
-// add new entry to symbol table
-    if ( symbol[word] == null) {
-      symbol[word] = { newCtr: 0, oldCtr: 0, toNew: null, toOld: null };
-    }
- 
-// increment symbol table word counter for old text
-    symbol[word].oldCtr ++;
- 
-// add last word number in old text
-    symbol[word].toOld = j;
-  }
- 
-// pass 3: connect unique words
- 
-  for (var i in symbol) {
- 
-// find words in the symbol table that occur only once in both versions
-    if ( (symbol[i].newCtr == 1) && (symbol[i].oldCtr == 1) ) {
-      var toNew = symbol[i].toNew;
-      var toOld = symbol[i].toOld;
- 
-// do not use spaces as unique markers
-      if ( ! /\s/.test( text.newWords[toNew] ) ) {
- 
-// connect from new to old and from old to new
-        text.newToOld[toNew] = toOld;
-        text.oldToNew[toOld] = toNew;
-      }
-    }
-  }
- 
-// pass 4: connect adjacent identical words downwards
- 
-  for (var i = newStart; i < newEnd - 1; i ++) {
- 
-// find already connected pairs
-    if (text.newToOld[i] != null) {
-      j = text.newToOld[i];
- 
-// check if the following words are not yet connected
-      if ( (text.newToOld[i + 1] == null) && (text.oldToNew[j + 1] == null) ) {
- 
-// if the following words are the same connect them
-        if ( text.newWords[i + 1] == text.oldWords[j + 1] ) {
-          text.newToOld[i + 1] = j + 1;
-          text.oldToNew[j + 1] = i + 1;
-        }
-      }
-    }
-  }
- 
-// pass 5: connect adjacent identical words upwards
- 
-  for (var i = newEnd - 1; i > newStart; i --) {
- 
-// find already connected pairs
-    if (text.newToOld[i] != null) {
-      j = text.newToOld[i];
- 
-// check if the preceeding words are not yet connected
-      if ( (text.newToOld[i - 1] == null) && (text.oldToNew[j - 1] == null) ) {
- 
-// if the preceeding words are the same connect them
-        if ( text.newWords[i - 1] == text.oldWords[j - 1] ) {
-          text.newToOld[i - 1] = j - 1;
-          text.oldToNew[j - 1] = i - 1;
-        }
-      }
-    }
-  }
- 
-// recursively diff still unresolved regions downwards
- 
-  if (wDiffRecursiveDiff) {
-    i = newStart;
-    j = oldStart;
-    while (i < newEnd) {
-      if (text.newToOld[i - 1] != null) {
-        j = text.newToOld[i - 1] + 1;
-      }
- 
-// check for the start of an unresolved sequence
-      if ( (text.newToOld[i] == null) && (text.oldToNew[j] == null) ) {
- 
-// determine the ends of the sequences
-        var iStart = i;
-        var iEnd = i;
-        while ( (text.newToOld[iEnd] == null) && (iEnd < newEnd) ) {
-          iEnd ++;
-        }
-        var iLength = iEnd - iStart;
- 
-        var jStart = j;
-        var jEnd = j;
-        while ( (text.oldToNew[jEnd] == null) && (jEnd < oldEnd) ) {
-          jEnd ++;
-        }
-        var jLength = jEnd - jStart;
- 
-// recursively diff the unresolved sequence
-        if ( (iLength > 0) && (jLength > 0) ) {
-          if ( (iLength > 1) || (jLength > 1) ) {
-            if ( (iStart != newStart) || (iEnd != newEnd) || (jStart != oldStart) || (jEnd != oldEnd) ) {
-              WDiffText(text, iStart, iEnd, jStart, jEnd, recursionLevel + 1);
-            }
-          }
-        }
-        i = iEnd;
-      }
-      else {
-        i ++;
-      }
-    }
-  }
- 
-// recursively diff still unresolved regions upwards
- 
-  if (wDiffRecursiveDiff) {
-    i = newEnd - 1;
-    j = oldEnd - 1;
-    while (i >= newStart) {
-      if (text.newToOld[i + 1] != null) {
-        j = text.newToOld[i + 1] - 1;
-      }
- 
-// check for the start of an unresolved sequence
-      if ( (text.newToOld[i] == null) && (text.oldToNew[j] == null) ) {
- 
-// determine the ends of the sequences
-        var iStart = i;
-        var iEnd = i + 1;
-        while ( (text.newToOld[iStart - 1] == null) && (iStart >= newStart) ) {
-          iStart --;
-        }
-        var iLength = iEnd - iStart;
- 
-        var jStart = j;
-        var jEnd = j + 1;
-        while ( (text.oldToNew[jStart - 1] == null) && (jStart >= oldStart) ) {
-          jStart --;
-        }
-        var jLength = jEnd - jStart;
- 
-// recursively diff the unresolved sequence
-        if ( (iLength > 0) && (jLength > 0) ) {
-          if ( (iLength > 1) || (jLength > 1) ) {
-            if ( (iStart != newStart) || (iEnd != newEnd) || (jStart != oldStart) || (jEnd != oldEnd) ) {
-              WDiffText(text, iStart, iEnd, jStart, jEnd, recursionLevel + 1);
-            }
-          }
-        }
-        i = iStart - 1;
-      }
-      else {
-        i --;
-      }
-    }
-  }
-  return;
-}
- 
- 
-// WDiffToHtml: process diff data into formatted html text
-// input: text.newWords and text.oldWords, arrays containing the texts in arrays of words
-//   text.newToOld and text.oldToNew, containing the line numbers in the other version
-//   block data structure
-// returns: outText, a html string
- 
-window.WDiffToHtml = function(text, block) {
- 
-  var outText = text.message;
- 
-  var blockNumber = 0;
-  var i = 0;
-  var j = 0;
-  var movedAsInsertion;
- 
-// cycle through the new text
-  do {
-    var movedIndex = [];
-    var movedBlock = [];
-    var movedLeft = [];
-    var blockText = '';
-    var identText = '';
-    var delText = '';
-    var insText = '';
-    var identStart = '';
- 
-// check if a block ends here and finish previous block
-    if (movedAsInsertion != null) {
-      if (movedAsInsertion == false) {
-        identStart += wDiffHtmlBlockEnd;
-      }
-      else {
-        identStart += wDiffHtmlInsertEnd;
-      }
-      movedAsInsertion = null;
-    }
- 
-// detect block boundary
-    if ( (text.newToOld[i] != j) || (blockNumber == 0 ) ) {
-      if ( ( (text.newToOld[i] != null) || (i >= text.newWords.length) ) && ( (text.oldToNew[j] != null) || (j >= text.oldWords.length) ) ) {
- 
-// block moved right
-        var moved = block.newRight[blockNumber];
-        if (moved > 0) {
-          var index = block.newRightIndex[blockNumber];
-          movedIndex.push(index);
-          movedBlock.push(moved);
-          movedLeft.push(false);
-        }
- 
-// block moved left
-        moved = block.newLeft[blockNumber];
-        if (moved > 0) {
-          var index = block.newLeftIndex[blockNumber];
-          movedIndex.push(index);
-          movedBlock.push(moved);
-          movedLeft.push(true);
-        }
- 
-// check if a block starts here
-        moved = block.newBlock[blockNumber];
-        if (moved > 0) {
- 
-// mark block as inserted text
-          if (block.newWords[blockNumber] < wDiffBlockMinLength) {
-            identStart += wDiffHtmlInsertStart;
-            movedAsInsertion = true;
-          }
- 
-// mark block by color
-          else {
-            if (moved > wDiffStyleBlock.length) {
-              moved = wDiffStyleBlock.length;
-            }
-            identStart += WDiffHtmlCustomize(wDiffHtmlBlockStart, moved - 1);
-            movedAsInsertion = false;
-          }
-        }
- 
-        if (i >= text.newWords.length) {
-          i ++;
-        }
-        else {
-          j = text.newToOld[i];
-          blockNumber ++;
-        }
-      }
-    }
- 
-// get the correct order if moved to the left as well as to the right from here
-    if (movedIndex.length == 2) {
-      if (movedIndex[0] > movedIndex[1]) {
-        movedIndex.reverse();
-        movedBlock.reverse();
-        movedLeft.reverse();
-      }
-    }
- 
-// handle left and right block moves from this position
-    for (var m = 0; m < movedIndex.length; m ++) {
- 
-// insert the block as deleted text
-      if (block.newWords[ movedIndex[m] ] < wDiffBlockMinLength) {
-        var movedStart = block.newStart[ movedIndex[m] ];
-        var movedLength = block.newLength[ movedIndex[m] ];
-        var str = '';
-        for (var n = movedStart; n < movedStart + movedLength; n ++) {
-          str += text.newWords[n];
-        }
-        str = WDiffEscape(str);
-        str = str.replace(/\n/g, '&para;<br>');
-        blockText += wDiffHtmlDeleteStart + str + wDiffHtmlDeleteEnd;
-      }
- 
-// add a placeholder / move direction indicator
-      else {
-        if (movedBlock[m] > wDiffStyleBlock.length) {
-          movedBlock[m] = wDiffStyleBlock.length;
-        }
-        if (movedLeft[m]) {
-          blockText += WDiffHtmlCustomize(wDiffHtmlMovedLeft, movedBlock[m] - 1);
-        }
-        else {
-          blockText += WDiffHtmlCustomize(wDiffHtmlMovedRight, movedBlock[m] - 1);
-        }
-      }
-    }
- 
-// collect consecutive identical text
-    while ( (i < text.newWords.length) && (j < text.oldWords.length) ) {
-      if ( (text.newToOld[i] == null) || (text.oldToNew[j] == null) ) {
-        break;
-      }
-      if (text.newToOld[i] != j) {
-        break;
-      }
-      identText += text.newWords[i];
-      i ++;
-      j ++;
-    }
- 
-// collect consecutive deletions
-    while ( (text.oldToNew[j] == null) && (j < text.oldWords.length) ) {
-      delText += text.oldWords[j];
-      j ++;
-    }
- 
-// collect consecutive inserts
-    while ( (text.newToOld[i] == null) && (i < text.newWords.length) ) {
-      insText += text.newWords[i];
-      i ++;
-    }
- 
-// remove leading and trailing similarities betweein delText and ins from highlighting
-    var preText = '';
-    var postText = '';
-    if (wDiffWordDiff) {
-      if ( (delText != '') && (insText != '') ) {
- 
-// remove leading similarities
-        while ( delText.charAt(0) == insText.charAt(0) && (delText != '') && (insText != '') ) {
-          preText = preText + delText.charAt(0);
-          delText = delText.substr(1);
-          insText = insText.substr(1);
-        }
- 
-// remove trailing similarities
-        while ( delText.charAt(delText.length - 1) == insText.charAt(insText.length - 1) && (delText != '') && (insText != '') ) {
-          postText = delText.charAt(delText.length - 1) + postText;
-          delText = delText.substr(0, delText.length - 1);
-          insText = insText.substr(0, insText.length - 1);
-        }
-      }
-    }
- 
-// output the identical text, deletions and inserts
- 
-// moved from here indicator
-    if (blockText != '') {
-      outText += blockText;
-    }
- 
-// identical text
-    if (identText != '') {
-      outText += identStart + WDiffEscape(identText);
-    }
-    outText += preText;
- 
-// deleted text
-    if (delText != '') {
-      delText = wDiffHtmlDeleteStart + WDiffEscape(delText) + wDiffHtmlDeleteEnd;
-      delText = delText.replace(/\n/g, '&para;<br>');
-      outText += delText;
-    }
- 
-// inserted text
-    if (insText != '') {
-      insText = wDiffHtmlInsertStart + WDiffEscape(insText) + wDiffHtmlInsertEnd;
-      insText = insText.replace(/\n/g, '&para;<br>');
-      outText += insText;
-    }
-    outText += postText;
-  } while (i <= text.newWords.length);
- 
-  outText += '\n';
-  outText = WDiffHtmlFormat(outText);
- 
-  return(outText);
-}
- 
- 
-// WDiffEscape: replaces html-sensitive characters in output text with character entities
- 
-window.WDiffEscape = function(text) {
- 
-  text = text.replace(/&/g, '&amp;');
-  text = text.replace(/</g, '&lt;');
-  text = text.replace(/>/g, '&gt;');
-  text = text.replace(/\"/g, '&quot;');
- 
-  return(text);
-}
- 
- 
-// HtmlCustomize: customize indicator html: replace {number} with the block number, {block} with the block style
- 
-window.WDiffHtmlCustomize = function(text, block) {
- 
-  text = text.replace(/\{number\}/, block);
-  text = text.replace(/\{block\}/, wDiffStyleBlock[block]);
- 
-  return(text);
-}
- 
- 
-// HtmlFormat: replaces newlines and multiple spaces in text with html code
- 
-window.WDiffHtmlFormat = function(text) {
- 
-  text = text.replace(/  /g, ' &nbsp;');
-  text = text.replace(/\n/g, '<br>');
- 
-  return(text);
-}
- 
- 
-// WDiffDetectBlocks: detect block borders and moved blocks
-// input: text object, block object
- 
-window.WDiffDetectBlocks = function(text, block) {
- 
-  block.oldStart  = [];
-  block.oldToNew  = [];
-  block.oldLength = [];
-  block.oldWords  = [];
-  block.newStart  = [];
-  block.newLength = [];
-  block.newWords  = [];
-  block.newNumber = [];
-  block.newBlock  = [];
-  block.newLeft   = [];
-  block.newRight  = [];
-  block.newLeftIndex  = [];
-  block.newRightIndex = [];
- 
-  var blockNumber = 0;
-  var wordCounter = 0;
-  var realWordCounter = 0;
- 
-// get old text block order
-  if (wDiffShowBlockMoves) {
-    var j = 0;
-    var i = 0;
-    do {
- 
-// detect block boundaries on old text
-      if ( (text.oldToNew[j] != i) || (blockNumber == 0 ) ) {
-        if ( ( (text.oldToNew[j] != null) || (j >= text.oldWords.length) ) && ( (text.newToOld[i] != null) || (i >= text.newWords.length) ) ) {
-          if (blockNumber > 0) {
-            block.oldLength[blockNumber - 1] = wordCounter;
-            block.oldWords[blockNumber - 1] = realWordCounter;
-            wordCounter = 0;
-            realWordCounter = 0;
-          }
- 
-          if (j >= text.oldWords.length) {
-            j ++;
-          }
-          else {
-            i = text.oldToNew[j];
-            block.oldStart[blockNumber] = j;
-            block.oldToNew[blockNumber] = text.oldToNew[j];
-            blockNumber ++;
-          }
-        }
-      }
- 
-// jump over identical pairs
-      while ( (i < text.newWords.length) && (j < text.oldWords.length) ) {
-        if ( (text.newToOld[i] == null) || (text.oldToNew[j] == null) ) {
-          break;
-        }
-        if (text.oldToNew[j] != i) {
-          break;
-        }
-        i ++;
-        j ++;
-        wordCounter ++;
-        if ( /\w/.test( text.newWords[i] ) ) {
-          realWordCounter ++;
-        }
-      }
- 
-// jump over consecutive deletions
-      while ( (text.oldToNew[j] == null) && (j < text.oldWords.length) ) {
-        j ++;
-      }
- 
-// jump over consecutive inserts
-      while ( (text.newToOld[i] == null) && (i < text.newWords.length) ) {
-        i ++;
-      }
-    } while (j <= text.oldWords.length);
- 
-// get the block order in the new text
-    var lastMin;
-    var currMinIndex;
-    lastMin = null;
- 
-// sort the data by increasing start numbers into new text block info
-    for (var i = 0; i < blockNumber; i ++) {
-      currMin = null;
-      for (var j = 0; j < blockNumber; j ++) {
-        curr = block.oldToNew[j];
-        if ( (curr > lastMin) || (lastMin == null) ) {
-          if ( (curr < currMin) || (currMin == null) ) {
-            currMin = curr;
-            currMinIndex = j;
-          }
-        }
-      }
-      block.newStart[i] = block.oldToNew[currMinIndex];
-      block.newLength[i] = block.oldLength[currMinIndex];
-      block.newWords[i] = block.oldWords[currMinIndex];
-      block.newNumber[i] = currMinIndex;
-      lastMin = currMin;
-    }
- 
-// detect not moved blocks
-    for (var i = 0; i < blockNumber; i ++) {
-      if (block.newBlock[i] == null) {
-        if (block.newNumber[i] == i) {
-          block.newBlock[i] = 0;
-        }
-      }
-    }
- 
-// detect switches of neighbouring blocks
-    for (var i = 0; i < blockNumber - 1; i ++) {
-      if ( (block.newBlock[i] == null) && (block.newBlock[i + 1] == null) ) {
-        if (block.newNumber[i] - block.newNumber[i + 1] == 1) {
-          if ( (block.newNumber[i + 1] - block.newNumber[i + 2] != 1) || (i + 2 >= blockNumber) ) {
- 
-// the shorter one is declared the moved one
-            if (block.newLength[i] < block.newLength[i + 1]) {
-              block.newBlock[i] = 1;
-              block.newBlock[i + 1] = 0;
-            }
-            else {
-              block.newBlock[i] = 0;
-              block.newBlock[i + 1] = 1;
-            }
-          }
-        }
-      }
-    }
- 
-// mark all others as moved and number the moved blocks
-    j = 1;
-    for (var i = 0; i < blockNumber; i ++) {
-      if ( (block.newBlock[i] == null) || (block.newBlock[i] == 1) ) {
-        block.newBlock[i] = j++;
-      }
-    }
- 
-// check if a block has been moved from this block border
-    for (var i = 0; i < blockNumber; i ++) {
-      for (var j = 0; j < blockNumber; j ++) {
- 
-        if (block.newNumber[j] == i) {
-          if (block.newBlock[j] > 0) {
- 
-// block moved right
-            if (block.newNumber[j] < j) {
-              block.newRight[i] = block.newBlock[j];
-              block.newRightIndex[i] = j;
-            }
- 
-// block moved left
-            else {
-              block.newLeft[i + 1] = block.newBlock[j];
-              block.newLeftIndex[i + 1] = j;
-            }
-          }
-        }
-      }
-    }
-  }
-  return;
-}
- 
- 
-// WDiffShortenOutput: remove unchanged parts from final output
-// input: the output of WDiffString
-// returns: the text with removed unchanged passages indicated by (...)
- 
-window.WDiffShortenOutput = function(diffText) {
- 
-// html <br/> to newlines
-  diffText = diffText.replace(/<br[^>]*>/g, '\n');
- 
-// scan for diff html tags
-  var regExpDiff = new RegExp('<\\w+ class=\\"(\\w+)\\"[^>]*>(.|\\n)*?<!--\\1-->', 'g');
-  var tagStart = [];
-  var tagEnd = [];
-  var i = 0;
-  var found;
-  while ( (found = regExpDiff.exec(diffText)) != null ) {
- 
-// combine consecutive diff tags
-    if ( (i > 0) && (tagEnd[i - 1] == found.index) ) {
-      tagEnd[i - 1] = found.index + found[0].length;
-    }
-    else {
-      tagStart[i] = found.index;
-      tagEnd[i] = found.index + found[0].length;
-      i ++;
-    }
-  }
- 
-// no diff tags detected
-  if (tagStart.length == 0) {
-    return(wDiffNoChange);
-  }
- 
-// define regexps
-  var regExpHeading = new RegExp('\\n=+.+?=+ *\\n|\\n\\{\\||\\n\\|\\}', 'g');
-  var regExpParagraph = new RegExp('\\n\\n+', 'g');
-  var regExpLine = new RegExp('\\n+', 'g');
-  var regExpBlank = new RegExp('(<[^>]+>)*\\s+', 'g');
- 
-// determine fragment border positions around diff tags
-  var rangeStart = [];
-  var rangeEnd = [];
-  var rangeStartType = [];
-  var rangeEndType = [];
-  for (var i = 0; i < tagStart.length; i ++) {
-    var found;
- 
-// find last heading before diff tag
-    var lastPos = tagStart[i] - wDiffHeadingBefore;
-    if (lastPos < 0) {
-      lastPos = 0;
-    }
-    regExpHeading.lastIndex = lastPos;
-    while ( (found = regExpHeading.exec(diffText)) != null ) {
-      if (found.index > tagStart[i]) {
-        break;
-      }
-      rangeStart[i] = found.index;
-      rangeStartType[i] = 'heading';
-    }
- 
-// find last paragraph before diff tag
-    if (rangeStart[i] == null) {
-      lastPos = tagStart[i] - wDiffParagraphBefore;
-      if (lastPos < 0) {
-        lastPos = 0;
-      }
-      regExpParagraph.lastIndex = lastPos;
-      while ( (found = regExpParagraph.exec(diffText)) != null ) {
-        if (found.index > tagStart[i]) {
-          break;
-        }
-        rangeStart[i] = found.index;
-        rangeStartType[i] = 'paragraph';
-      }
-    }
- 
-// find line break before diff tag
-    if (rangeStart[i] == null) {
-      lastPos = tagStart[i] - wDiffLineBeforeMax;
-      if (lastPos < 0) {
-        lastPos = 0;
-      }
-      regExpLine.lastIndex = lastPos;
-      while ( (found = regExpLine.exec(diffText)) != null ) {
-        if (found.index > tagStart[i] - wDiffLineBeforeMin) {
-          break;
-        }
-        rangeStart[i] = found.index;
-        rangeStartType[i] = 'line';
-      }
-    }
- 
-// find blank before diff tag
-    if (rangeStart[i] == null) {
-      lastPos = tagStart[i] - wDiffBlankBeforeMax;
-      if (lastPos < 0) {
-        lastPos = 0;
-      }
-      regExpBlank.lastIndex = lastPos;
-      while ( (found = regExpBlank.exec(diffText)) != null ) {
-        if (found.index > tagStart[i] - wDiffBlankBeforeMin) {
-          break;
-        }
-        rangeStart[i] = found.index;
-        rangeStartType[i] = 'blank';
-      }
-    }
- 
-// fixed number of chars before diff tag
-    if (rangeStart[i] == null) {
-      rangeStart[i] = tagStart[i] - wDiffCharsBefore;
-      rangeStartType[i] = 'chars';
-      if (rangeStart[i] < 0) {
-        rangeStart[i] = 0;
-      }
-    }
- 
-// find first heading after diff tag
-    regExpHeading.lastIndex = tagEnd[i];
-    if ( (found = regExpHeading.exec(diffText)) != null ) {
-      if (found.index < tagEnd[i] + wDiffHeadingAfter) {
-        rangeEnd[i] = found.index + found[0].length;
-        rangeEndType[i] = 'heading';
-      }
-    }
- 
-// find first paragraph after diff tag
-    if (rangeEnd[i] == null) {
-      regExpParagraph.lastIndex = tagEnd[i];
-      if ( (found = regExpParagraph.exec(diffText)) != null ) {
-        if (found.index < tagEnd[i] + wDiffParagraphAfter) {
-          rangeEnd[i] = found.index;
-          rangeEndType[i] = 'paragraph';
-        }
-      }
-    }
- 
-// find first line break after diff tag
-    if (rangeEnd[i] == null) {
-      regExpLine.lastIndex = tagEnd[i] + wDiffLineAfterMin;
-      if ( (found = regExpLine.exec(diffText)) != null ) {
-        if (found.index < tagEnd[i] + wDiffLineAfterMax) {
-          rangeEnd[i] = found.index;
-          rangeEndType[i] = 'break';
-        }
-      }
-    }
- 
-// find blank after diff tag
-    if (rangeEnd[i] == null) {
-      regExpBlank.lastIndex = tagEnd[i] + wDiffBlankAfterMin;
-      if ( (found = regExpBlank.exec(diffText)) != null ) {
-        if (found.index < tagEnd[i] + wDiffBlankAfterMax) {
-          rangeEnd[i] = found.index;
-          rangeEndType[i] = 'blank';
-        }
-      }
-    }
- 
-// fixed number of chars after diff tag
-    if (rangeEnd[i] == null) {
-      rangeEnd[i] = tagEnd[i] + wDiffCharsAfter;
-      if (rangeEnd[i] > diffText.length) {
-        rangeEnd[i] = diffText.length;
-        rangeEndType[i] = 'chars';
-      }
-    }
-  }
- 
-// remove overlaps, join close fragments
-  var fragmentStart = [];
-  var fragmentEnd = [];
-  var fragmentStartType = [];
-  var fragmentEndType = [];
-  fragmentStart[0] = rangeStart[0];
-  fragmentEnd[0] = rangeEnd[0];
-  fragmentStartType[0] = rangeStartType[0];
-  fragmentEndType[0] = rangeEndType[0];
-  var j = 1;
-  for (var i = 1; i < rangeStart.length; i ++) {
-    if (rangeStart[i] > fragmentEnd[j - 1] + wDiffFragmentJoin) {
-      fragmentStart[j] = rangeStart[i];
-      fragmentEnd[j] = rangeEnd[i];
-      fragmentStartType[j] = rangeStartType[i];
-      fragmentEndType[j] = rangeEndType[i];
-      j ++;
-    }
-    else {
-      fragmentEnd[j - 1] = rangeEnd[i];
-      fragmentEndType[j - 1] = rangeEndType[i];
-    }
-  }
- 
-// assemble the fragments
-  var outText = '';
-  for (var i = 0; i < fragmentStart.length; i ++) {
- 
-// get text fragment
-    var fragment = diffText.substring(fragmentStart[i], fragmentEnd[i]);
-    var fragment = fragment.replace(/^\n+|\n+$/g, '');
- 
-// add inline marks for omitted chars and words
-    if (fragmentStart[i] > 0) {
-      if (fragmentStartType[i] == 'chars') {
-        fragment = wDiffOmittedChars + fragment;
-      }
-      else if (fragmentStartType[i] == 'blank') {
-        fragment = wDiffOmittedChars + ' ' + fragment;
-      }
-    }
-    if (fragmentEnd[i] < diffText.length) {
-      if (fragmentStartType[i] == 'chars') {
-        fragment = fragment + wDiffOmittedChars;
-      }
-      else if (fragmentStartType[i] == 'blank') {
-        fragment = fragment + ' ' + wDiffOmittedChars;
-      }
-    }
- 
-// add omitted line separator
-    if (fragmentStart[i] > 0) {
-      outText += wDiffOmittedLines;
-    }
- 
-// encapsulate span errors
-    outText += '<div>' + fragment + '</div>';
-  }
- 
-// add trailing omitted line separator
-  if (fragmentEnd[i - 1] < diffText.length) {
-    outText = outText + wDiffOmittedLines;
-  }
- 
-// remove leading and trailing empty lines
-  outText = outText.replace(/^(<div>)\n+|\n+(<\/div>)$/g, '$1$2');
- 
-// convert to html linebreaks
-  outText = outText.replace(/\n/g, '<br />');
- 
-  return(outText);
-}
- 
- 
-// <pre><nowiki>
\ No newline at end of file
-- 
cgit v1.3