☰

findAndReplaceDOMText v 0.4.0

Matches the text of a DOM node against a regular expression and replaces each match (or node-separated portions of the match) in the specified element.

当前为 2021-03-16 提交的版本，查看 最新版本。

此脚本不应直接安装，它是供其他脚本使用的外部库。如果您需要使用该库，请在脚本元属性加入：// @require https://update.cn-greasyfork.org/scripts/423347/911450/findAndReplaceDOMText%20v%20040.js 

  1. /**
  2.  * findAndReplaceDOMText v 0.4.0
  3.  * @author James Padolsey http://james.padolsey.com
  4.  * @license http://unlicense.org/UNLICENSE
  5.  *
  6.  * Matches the text of a DOM node against a regular expression
  7.  * and replaces each match (or node-separated portions of the match)
  8.  * in the specified element.
  9.  */
  10. window.findAndReplaceDOMText = (function() {
  11.  
  12. 	var PORTION_MODE_RETAIN = 'retain';
  13. 	var PORTION_MODE_FIRST = 'first';
  14.  
  15. 	var doc = document;
  16. 	var toString = {}.toString;
  17.  
  18. 	function isArray(a) {
  19. 		return toString.call(a) == '[object Array]';
  20. 	}
  21.  
  22. 	function escapeRegExp(s) {
  23. 		return String(s).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
  24. 	}
  25.  
  26. 	function exposed() {
  27. 		// Try deprecated arg signature first:
  28. 		return deprecated.apply(null, arguments) || findAndReplaceDOMText.apply(null, arguments);
  29. 	}
  30.  
  31. 	function deprecated(regex, node, replacement, captureGroup, elFilter) {
  32. 		if ((node && !node.nodeType) && arguments.length <= 2) {
  33. 			return false;
  34. 		}
  35. 		var isReplacementFunction = typeof replacement == 'function';
  36.  
  37. 		if (isReplacementFunction) {
  38. 			replacement = (function(original) {
  39. 				return function(portion, match) {
  40. 					return original(portion.text, match.startIndex);
  41. 				};
  42. 			}(replacement));
  43. 		}
  44.  
  45. 		// Awkward support for deprecated argument signature (<0.4.0)
  46. 		var instance = findAndReplaceDOMText(node, {
  47.  
  48. 			find: regex,
  49.  
  50. 			wrap: isReplacementFunction ? null : replacement,
  51. 			replace: isReplacementFunction ? replacement : '$' + (captureGroup || '&'),
  52.  
  53. 			prepMatch: function(m, mi) {
  54.  
  55. 				// Support captureGroup (a deprecated feature)
  56.  
  57. 				if (!m[0]) throw 'findAndReplaceDOMText cannot handle zero-length matches';
  58.  
  59. 				if (captureGroup > 0) {
  60. 					var cg = m[captureGroup];
  61. 					m.index += m[0].indexOf(cg);
  62. 					m[0] = cg;
  63. 				}
  64. 		 
  65. 				m.endIndex = m.index + m[0].length;
  66. 				m.startIndex = m.index;
  67. 				m.index = mi;
  68.  
  69. 				return m;
  70. 			},
  71. 			filterElements: elFilter
  72. 		});
  73.  
  74. 		exposed.revert = function() {
  75. 			return instance.revert();
  76. 		};
  77.  
  78. 		return true;
  79. 	}
  80.  
  81. 	/** 
  82. 	 * findAndReplaceDOMText
  83. 	 * 
  84. 	 * Locates matches and replaces with replacementNode
  85. 	 *
  86. 	 * @param {Node} node Element or Text node to search within
  87. 	 * @param {RegExp} options.find The regular expression to match
  88. 	 * @param {String|Element} [options.wrap] A NodeName, or a Node to clone
  89. 	 * @param {String|Function} [options.replace='$&'] What to replace each match with
  90. 	 * @param {Function} [options.filterElements] A Function to be called to check whether to
  91. 	 *	process an element. (returning true = process element,
  92. 	 *	returning false = avoid element)
  93. 	 */
  94. 	function findAndReplaceDOMText(node, options) {
  95. 		return new Finder(node, options);
  96. 	}
  97.  
  98. 	exposed.Finder = Finder;
  99.  
  100. 	/**
  101. 	 * Finder -- encapsulates logic to find and replace.
  102. 	 */
  103. 	function Finder(node, options) {
  104.  
  105. 		options.portionMode = options.portionMode || PORTION_MODE_RETAIN;
  106.  
  107. 		this.node = node;
  108. 		this.options = options;
  109.  
  110. 		// ENable match-preparation method to be passed as option:
  111. 		this.prepMatch = options.prepMatch || this.prepMatch;
  112.  
  113. 		this.reverts = [];
  114.  
  115. 		this.matches = this.search();
  116.  
  117. 		if (this.matches.length) {
  118. 			this.processMatches();
  119. 		}
  120.  
  121. 	}
  122.  
  123. 	Finder.prototype = {
  124.  
  125. 		/**
  126. 		 * Searches for all matches that comply with the instance's 'match' option
  127. 		 */
  128. 		search: function() {
  129.  
  130. 			var match;
  131. 			var matchIndex = 0;
  132. 			var regex = this.options.find;
  133. 			var text = this.getAggregateText();
  134. 			var matches = [];
  135.  
  136. 			regex = typeof regex === 'string' ? RegExp(escapeRegExp(regex), 'g') : regex;
  137.  
  138. 			if (regex.global) {
  139. 				while (match = regex.exec(text)) {
  140. 					matches.push(this.prepMatch(match, matchIndex++));
  141. 				}
  142. 			} else {
  143. 				if (match = text.match(regex)) {
  144. 					matches.push(this.prepMatch(match, 0));
  145. 				}
  146. 			}
  147.  
  148. 			return matches;
  149.  
  150. 		},
  151.  
  152. 		/**
  153. 		 * Prepares a single match with useful meta info:
  154. 		 */
  155. 		prepMatch: function(match, matchIndex) {
  156.  
  157. 			if (!match[0]) {
  158. 				throw new Error('findAndReplaceDOMText cannot handle zero-length matches');
  159. 			}
  160. 	 
  161. 			match.endIndex = match.index + match[0].length;
  162. 			match.startIndex = match.index;
  163. 			match.index = matchIndex;
  164.  
  165. 			return match;
  166. 		},
  167.  
  168. 		/**
  169. 		 * Gets aggregate text within subject node
  170. 		 */
  171. 		getAggregateText: function() {
  172.  
  173. 			var elementFilter = this.options.filterElements;
  174.  
  175. 			return getText(this.node);
  176.  
  177. 			/**
  178. 			 * Gets aggregate text of a node without resorting
  179. 			 * to broken innerText/textContent
  180. 			 */
  181. 			function getText(node) {
  182.  
  183. 				if (node.nodeType === 3) {
  184. 					return node.data;
  185. 				}
  186.  
  187. 				if (elementFilter && !elementFilter(node)) {
  188. 					return '';
  189. 				}
  190.  
  191. 				var txt = '';
  192.  
  193. 				if (node = node.firstChild) do {
  194. 					txt += getText(node);
  195. 				} while (node = node.nextSibling);
  196.  
  197. 				return txt;
  198.  
  199. 			}
  200.  
  201. 		},
  202.  
  203. 		/** 
  204. 		 * Steps through the target node, looking for matches, and
  205. 		 * calling replaceFn when a match is found.
  206. 		 */
  207. 		processMatches: function() {
  208.  
  209. 			var matches = this.matches;
  210. 			var node = this.node;
  211. 			var elementFilter = this.options.filterElements;
  212.  
  213. 			var startPortion,
  214. 				endPortion,
  215. 				innerPortions = [],
  216. 				curNode = node,
  217. 				match = matches.shift(),
  218. 				atIndex = 0, // i.e. nodeAtIndex
  219. 				matchIndex = 0,
  220. 				portionIndex = 0,
  221. 				doAvoidNode;
  222.  
  223. 			out: while (true) {
  224.  
  225. 				if (curNode.nodeType === 3) {
  226.  
  227. 					if (!endPortion && curNode.length + atIndex >= match.endIndex) {
  228.  
  229. 						// We've found the ending
  230. 						endPortion = {
  231. 							node: curNode,
  232. 							index: portionIndex++,
  233. 							text: curNode.data.substring(match.startIndex - atIndex, match.endIndex - atIndex),
  234. 							indexInMatch: atIndex - match.startIndex,
  235. 							indexInNode: match.startIndex - atIndex, // always zero for end-portions
  236. 							endIndexInNode: match.endIndex - atIndex,
  237. 							isEnd: true
  238. 						};
  239.  
  240. 					} else if (startPortion) {
  241. 						// Intersecting node
  242. 						innerPortions.push({
  243. 							node: curNode,
  244. 							index: portionIndex++,
  245. 							text: curNode.data,
  246. 							indexInMatch: atIndex - match.startIndex,
  247. 							indexInNode: 0 // always zero for inner-portions
  248. 						});
  249. 					}
  250.  
  251. 					if (!startPortion && curNode.length + atIndex > match.startIndex) {
  252. 						// We've found the match start
  253. 						startPortion = {
  254. 							node: curNode,
  255. 							index: portionIndex++,
  256. 							indexInMatch: 0,
  257. 							indexInNode: match.startIndex - atIndex,
  258. 							endIndexInNode: match.endIndex - atIndex,
  259. 							text: curNode.data.substring(match.startIndex - atIndex, match.endIndex - atIndex)
  260. 						};
  261. 					}
  262.  
  263. 					atIndex += curNode.data.length;
  264.  
  265. 				}
  266.  
  267. 				doAvoidNode = curNode.nodeType === 1 && elementFilter && !elementFilter(curNode);
  268.  
  269. 				if (startPortion && endPortion) {
  270.  
  271. 					curNode = this.replaceMatch(match, startPortion, innerPortions, endPortion);
  272.  
  273. 					// processMatches has to return the node that replaced the endNode
  274. 					// and then we step back so we can continue from the end of the 
  275. 					// match:
  276.  
  277. 					atIndex -= (endPortion.node.data.length - endPortion.endIndexInNode);
  278.  
  279. 					startPortion = null;
  280. 					endPortion = null;
  281. 					innerPortions = [];
  282. 					match = matches.shift();
  283. 					portionIndex = 0;
  284. 					matchIndex++;
  285.  
  286. 					if (!match) {
  287. 						break; // no more matches
  288. 					}
  289.  
  290. 				} else if (
  291. 					!doAvoidNode &&
  292. 					(curNode.firstChild || curNode.nextSibling)
  293. 				) {
  294. 					// Move down or forward:
  295. 					curNode = curNode.firstChild || curNode.nextSibling;
  296. 					continue;
  297. 				}
  298.  
  299. 				// Move forward or up:
  300. 				while (true) {
  301. 					if (curNode.nextSibling) {
  302. 						curNode = curNode.nextSibling;
  303. 						break;
  304. 					} else if (curNode.parentNode !== node) {
  305. 						curNode = curNode.parentNode;
  306. 					} else {
  307. 						break out;
  308. 					}
  309. 				}
  310.  
  311. 			}
  312.  
  313. 		},
  314.  
  315. 		/**
  316. 		 * Reverts ... TODO
  317. 		 */
  318. 		revert: function() {
  319. 			// Reversion occurs backwards so as to avoid nodes subsequently
  320. 			// replaced during the matching phase (a forward process):
  321. 			for (var l = this.reverts.length; l--;) {
  322. 				this.reverts[l]();
  323. 			}
  324. 			this.reverts = [];
  325. 		},
  326.  
  327. 		prepareReplacementString: function(string, portion, match, matchIndex) {
  328. 			var portionMode = this.options.portionMode;
  329. 			if (
  330. 				portionMode === PORTION_MODE_FIRST &&
  331. 				portion.indexInMatch > 0
  332. 			) {
  333. 				return '';
  334. 			}
  335. 			string = string.replace(/\$(\d+|&|`|')/g, function($0, t) {
  336. 				var replacement;
  337. 				switch(t) {
  338. 					case '&':
  339. 						replacement = match[0];
  340. 						break;
  341. 					case '`':
  342. 						replacement = match.input.substring(0, match.startIndex);
  343. 						break;
  344. 					case '\'':
  345. 						replacement = match.input.substring(match.endIndex);
  346. 						break;
  347. 					default:
  348. 						replacement = match[+t];
  349. 				}
  350. 				return replacement;
  351. 			});
  352.  
  353. 			if (portionMode === PORTION_MODE_FIRST) {
  354. 				return string;
  355. 			}
  356.  
  357. 			if (portion.isEnd) {
  358. 				return string.substring(portion.indexInMatch);
  359. 			}
  360.  
  361. 			return string.substring(portion.indexInMatch, portion.indexInMatch + portion.text.length);
  362. 		},
  363.  
  364. 		getPortionReplacementNode: function(portion, match, matchIndex) {
  365.  
  366. 			var replacement = this.options.replace || '$&';
  367. 			var wrapper = this.options.wrap;
  368.  
  369. 			if (wrapper && wrapper.nodeType) {
  370. 				// Wrapper has been provided as a stencil-node for us to clone:
  371. 				var clone = doc.createElement('div');
  372. 				clone.innerHTML = wrapper.outerHTML || new XMLSerializer().serializeToString(wrapper);
  373. 				wrapper = clone.firstChild;
  374. 			}
  375.  
  376. 			if (typeof replacement == 'function') {
  377. 				replacement = replacement(portion, match, matchIndex);
  378. 				if (replacement && replacement.nodeType) {
  379. 					return replacement;
  380. 				}
  381. 				return doc.createTextNode(String(replacement));
  382. 			}
  383.  
  384. 			var el = typeof wrapper == 'string' ? doc.createElement(wrapper) : wrapper;
  385.  
  386. 			replacement = doc.createTextNode(
  387. 				this.prepareReplacementString(
  388. 					replacement, portion, match, matchIndex
  389. 				)
  390. 			);
  391.  
  392. 			if (!el) {
  393. 				return replacement;
  394. 			}
  395.  
  396. 			el.appendChild(replacement);
  397.  
  398. 			return el;
  399. 		},
  400.  
  401. 		replaceMatch: function(match, startPortion, innerPortions, endPortion) {
  402.  
  403. 			var matchStartNode = startPortion.node;
  404. 			var matchEndNode = endPortion.node;
  405.  
  406. 			var preceedingTextNode;
  407. 			var followingTextNode;
  408.  
  409. 			if (matchStartNode === matchEndNode) {
  410.  
  411. 				var node = matchStartNode;
  412.  
  413. 				if (startPortion.indexInNode > 0) {
  414. 					// Add `before` text node (before the match)
  415. 					preceedingTextNode = doc.createTextNode(node.data.substring(0, startPortion.indexInNode));
  416. 					node.parentNode.insertBefore(preceedingTextNode, node);
  417. 				}
  418.  
  419. 				// Create the replacement node:
  420. 				var newNode = this.getPortionReplacementNode(
  421. 					endPortion,
  422. 					match
  423. 				);
  424.  
  425. 				node.parentNode.insertBefore(newNode, node);
  426.  
  427. 				if (endPortion.endIndexInNode < node.length) { // ?????
  428. 					// Add `after` text node (after the match)
  429. 					followingTextNode = doc.createTextNode(node.data.substring(endPortion.endIndexInNode));
  430. 					node.parentNode.insertBefore(followingTextNode, node);
  431. 				}
  432.  
  433. 				node.parentNode.removeChild(node);
  434.  
  435. 				this.reverts.push(function() {
  436. 					if (preceedingTextNode === newNode.previousSibling) {
  437. 						preceedingTextNode.parentNode.removeChild(preceedingTextNode);
  438. 					}
  439. 					if (followingTextNode === newNode.nextSibling) {
  440. 						followingTextNode.parentNode.removeChild(followingTextNode);
  441. 					}
  442. 					newNode.parentNode.replaceChild(node, newNode);
  443. 				});
  444.  
  445. 				return newNode;
  446.  
  447. 			} else {
  448. 				// Replace matchStartNode -> [innerMatchNodes...] -> matchEndNode (in that order)
  449.  
  450.  
  451. 				preceedingTextNode = doc.createTextNode(
  452. 					matchStartNode.data.substring(0, startPortion.indexInNode)
  453. 				);
  454.  
  455. 				followingTextNode = doc.createTextNode(
  456. 					matchEndNode.data.substring(endPortion.endIndexInNode)
  457. 				);
  458.  
  459. 				var firstNode = this.getPortionReplacementNode(
  460. 					startPortion,
  461. 					match
  462. 				);
  463.  
  464. 				var innerNodes = [];
  465.  
  466. 				for (var i = 0, l = innerPortions.length; i < l; ++i) {
  467. 					var portion = innerPortions[i];
  468. 					var innerNode = this.getPortionReplacementNode(
  469. 						portion,
  470. 						match
  471. 					);
  472. 					portion.node.parentNode.replaceChild(innerNode, portion.node);
  473. 					this.reverts.push((function(portion, innerNode) {
  474. 						return function() {
  475. 							innerNode.parentNode.replaceChild(portion.node, innerNode);
  476. 						};
  477. 					}(portion, innerNode)));
  478. 					innerNodes.push(innerNode);
  479. 				}
  480.  
  481. 				var lastNode = this.getPortionReplacementNode(
  482. 					endPortion,
  483. 					match
  484. 				);
  485.  
  486. 				matchStartNode.parentNode.insertBefore(preceedingTextNode, matchStartNode);
  487. 				matchStartNode.parentNode.insertBefore(firstNode, matchStartNode);
  488. 				matchStartNode.parentNode.removeChild(matchStartNode);
  489.  
  490. 				matchEndNode.parentNode.insertBefore(lastNode, matchEndNode);
  491. 				matchEndNode.parentNode.insertBefore(followingTextNode, matchEndNode);
  492. 				matchEndNode.parentNode.removeChild(matchEndNode);
  493.  
  494. 				this.reverts.push(function() {
  495. 					preceedingTextNode.parentNode.removeChild(preceedingTextNode);
  496. 					firstNode.parentNode.replaceChild(matchStartNode, firstNode);
  497. 					followingTextNode.parentNode.removeChild(followingTextNode);
  498. 					lastNode.parentNode.replaceChild(matchEndNode, lastNode);
  499. 				});
  500.  
  501. 				return lastNode;
  502. 			}
  503. 		}
  504.  
  505. 	};
  506.  
  507. 	return exposed;
  508.  
  509. }());