☰

IPFS Hash Linker

Link IPFS hashes to the IPFS gateway

目前为 2015-12-14 提交的版本。查看 最新版本。

  1. // ==UserScript==
  2. // @name           IPFS Hash Linker
  3. // @namespace      IPFS Hash Linker
  4. // @description    Link IPFS hashes to the IPFS gateway
  5. // @version        2.1
  6. // @include        *
  7. // ==/UserScript==
  8.  
  9. // Tips: 1NT9pxhDcPfsFhnrVoehxiUZ7HCC3gnsn3
  10.  
  11. // Partially based on the "Bitcoin Tool" userscript:
  12. // http://userscripts.org/scripts/show/104381
  13.  
  14. // This is public domain code, free for commercial and non-commercial use.
  15. // License: http://unlicense.org/UNLICENSE
  16.  
  17.  
  18. // We depend on this massive library.
  19. /**
  20.  * findAndReplaceDOMText v 0.4.3
  21.  * @author James Padolsey http://james.padolsey.com
  22.  * @license http://unlicense.org/UNLICENSE
  23.  *
  24.  * Matches the text of a DOM node against a regular expression
  25.  * and replaces each match (or node-separated portions of the match)
  26.  * in the specified element.
  27.  */
  28.  (function (root, factory) {
  29.      if (typeof module === 'object' && module.exports) {
  30.          // Node/CommonJS
  31.          module.exports = factory();
  32.      } else if (typeof define === 'function' && define.amd) {
  33.          // AMD. Register as an anonymous module.
  34.          define(factory);
  35.      } else {
  36.          // Browser globals
  37.          root.findAndReplaceDOMText = factory();
  38.      }
  39.  }(this, function factory() {
  40.  
  41. 	var PORTION_MODE_RETAIN = 'retain';
  42. 	var PORTION_MODE_FIRST = 'first';
  43.  
  44. 	var doc = document;
  45. 	var toString = {}.toString;
  46. 	var hasOwn = {}.hasOwnProperty;
  47.  
  48. 	function isArray(a) {
  49. 		return toString.call(a) == '[object Array]';
  50. 	}
  51.  
  52. 	function escapeRegExp(s) {
  53. 		return String(s).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
  54. 	}
  55.  
  56. 	function exposed() {
  57. 		// Try deprecated arg signature first:
  58. 		return deprecated.apply(null, arguments) || findAndReplaceDOMText.apply(null, arguments);
  59. 	}
  60.  
  61. 	function deprecated(regex, node, replacement, captureGroup, elFilter) {
  62. 		if ((node && !node.nodeType) && arguments.length <= 2) {
  63. 			return false;
  64. 		}
  65. 		var isReplacementFunction = typeof replacement == 'function';
  66.  
  67. 		if (isReplacementFunction) {
  68. 			replacement = (function(original) {
  69. 				return function(portion, match) {
  70. 					return original(portion.text, match.startIndex);
  71. 				};
  72. 			}(replacement));
  73. 		}
  74.  
  75. 		// Awkward support for deprecated argument signature (<0.4.0)
  76. 		var instance = findAndReplaceDOMText(node, {
  77.  
  78. 			find: regex,
  79.  
  80. 			wrap: isReplacementFunction ? null : replacement,
  81. 			replace: isReplacementFunction ? replacement : '$' + (captureGroup || '&'),
  82.  
  83. 			prepMatch: function(m, mi) {
  84.  
  85. 				// Support captureGroup (a deprecated feature)
  86.  
  87. 				if (!m[0]) throw 'findAndReplaceDOMText cannot handle zero-length matches';
  88.  
  89. 				if (captureGroup > 0) {
  90. 					var cg = m[captureGroup];
  91. 					m.index += m[0].indexOf(cg);
  92. 					m[0] = cg;
  93. 				}
  94. 		 
  95. 				m.endIndex = m.index + m[0].length;
  96. 				m.startIndex = m.index;
  97. 				m.index = mi;
  98.  
  99. 				return m;
  100. 			},
  101. 			filterElements: elFilter
  102. 		});
  103.  
  104. 		exposed.revert = function() {
  105. 			return instance.revert();
  106. 		};
  107.  
  108. 		return true;
  109. 	}
  110.  
  111. 	/** 
  112. 	 * findAndReplaceDOMText
  113. 	 * 
  114. 	 * Locates matches and replaces with replacementNode
  115. 	 *
  116. 	 * @param {Node} node Element or Text node to search within
  117. 	 * @param {RegExp} options.find The regular expression to match
  118. 	 * @param {String|Element} [options.wrap] A NodeName, or a Node to clone
  119. 	 * @param {String|Function} [options.replace='$&'] What to replace each match with
  120. 	 * @param {Function} [options.filterElements] A Function to be called to check whether to
  121. 	 *	process an element. (returning true = process element,
  122. 	 *	returning false = avoid element)
  123. 	 */
  124. 	function findAndReplaceDOMText(node, options) {
  125. 		return new Finder(node, options);
  126. 	}
  127.  
  128. 	exposed.NON_PROSE_ELEMENTS = {
  129. 		br:1, hr:1,
  130. 		// Media / Source elements:
  131. 		script:1, style:1, img:1, video:1, audio:1, canvas:1, svg:1, map:1, object:1,
  132. 		// Input elements
  133. 		input:1, textarea:1, select:1, option:1, optgroup: 1, button:1
  134. 	};
  135.  
  136. 	exposed.NON_CONTIGUOUS_PROSE_ELEMENTS = {
  137.  
  138. 		// Elements that will not contain prose or block elements where we don't
  139. 		// want prose to be matches across element borders:
  140.  
  141. 		// Block Elements
  142. 		address:1, article:1, aside:1, blockquote:1, dd:1, div:1,
  143. 		dl:1, fieldset:1, figcaption:1, figure:1, footer:1, form:1, h1:1, h2:1, h3:1,
  144. 		h4:1, h5:1, h6:1, header:1, hgroup:1, hr:1, main:1, nav:1, noscript:1, ol:1,
  145. 		output:1, p:1, pre:1, section:1, ul:1,
  146. 		// Other misc. elements that are not part of continuous inline prose:
  147. 		br:1, li: 1, summary: 1, dt:1, details:1, rp:1, rt:1, rtc:1,
  148. 		// Media / Source elements:
  149. 		script:1, style:1, img:1, video:1, audio:1, canvas:1, svg:1, map:1, object:1,
  150. 		// Input elements
  151. 		input:1, textarea:1, select:1, option:1, optgroup: 1, button:1,
  152. 		// Table related elements:
  153. 		table:1, tbody:1, thead:1, th:1, tr:1, td:1, caption:1, col:1, tfoot:1, colgroup:1
  154.  
  155. 	};
  156.  
  157. 	exposed.NON_INLINE_PROSE = function(el) {
  158. 		return hasOwn.call(exposed.NON_CONTIGUOUS_PROSE_ELEMENTS, el.nodeName.toLowerCase());
  159. 	};
  160.  
  161. 	// Presets accessed via `options.preset` when calling findAndReplaceDOMText():
  162. 	exposed.PRESETS = {
  163. 		prose: {
  164. 			forceContext: exposed.NON_INLINE_PROSE,
  165. 			filterElements: function(el) {
  166. 				return !hasOwn.call(exposed.NON_PROSE_ELEMENTS, el.nodeName.toLowerCase());
  167. 			}
  168. 		}
  169. 	};
  170.  
  171. 	exposed.Finder = Finder;
  172.  
  173. 	/**
  174. 	 * Finder -- encapsulates logic to find and replace.
  175. 	 */
  176. 	function Finder(node, options) {
  177.  
  178. 		var preset = options.preset && exposed.PRESETS[options.preset];
  179.  
  180. 		options.portionMode = options.portionMode || PORTION_MODE_RETAIN;
  181.  
  182. 		if (preset) {
  183. 			for (var i in preset) {
  184. 				if (hasOwn.call(preset, i) && !hasOwn.call(options, i)) {
  185. 					options[i] = preset[i];
  186. 				}
  187. 			}
  188. 		}
  189.  
  190. 		this.node = node;
  191. 		this.options = options;
  192.  
  193. 		// ENable match-preparation method to be passed as option:
  194. 		this.prepMatch = options.prepMatch || this.prepMatch;
  195.  
  196. 		this.reverts = [];
  197.  
  198. 		this.matches = this.search();
  199.  
  200. 		if (this.matches.length) {
  201. 			this.processMatches();
  202. 		}
  203.  
  204. 	}
  205.  
  206. 	Finder.prototype = {
  207.  
  208. 		/**
  209. 		 * Searches for all matches that comply with the instance's 'match' option
  210. 		 */
  211. 		search: function() {
  212.  
  213. 			var match;
  214. 			var matchIndex = 0;
  215. 			var offset = 0;
  216. 			var regex = this.options.find;
  217. 			var textAggregation = this.getAggregateText();
  218. 			var matches = [];
  219. 			var self = this;
  220.  
  221. 			regex = typeof regex === 'string' ? RegExp(escapeRegExp(regex), 'g') : regex;
  222.  
  223. 			matchAggregation(textAggregation);
  224.  
  225. 			function matchAggregation(textAggregation) {
  226. 				for (var i = 0, l = textAggregation.length; i < l; ++i) {
  227.  
  228. 					var text = textAggregation[i];
  229.  
  230. 					if (typeof text !== 'string') {
  231. 						// Deal with nested contexts: (recursive)
  232. 						matchAggregation(text);
  233. 						continue;
  234. 					}
  235.  
  236. 					if (regex.global) {
  237. 						while (match = regex.exec(text)) {
  238. 							matches.push(self.prepMatch(match, matchIndex++, offset));
  239. 						}
  240. 					} else {
  241. 						if (match = text.match(regex)) {
  242. 							matches.push(self.prepMatch(match, 0, offset));
  243. 						}
  244. 					}
  245.  
  246. 					offset += text.length;
  247. 				}
  248. 			}
  249.  
  250. 			return matches;
  251.  
  252. 		},
  253.  
  254. 		/**
  255. 		 * Prepares a single match with useful meta info:
  256. 		 */
  257. 		prepMatch: function(match, matchIndex, characterOffset) {
  258.  
  259. 			if (!match[0]) {
  260. 				throw new Error('findAndReplaceDOMText cannot handle zero-length matches');
  261. 			}
  262. 	 
  263. 			match.endIndex = characterOffset + match.index + match[0].length;
  264. 			match.startIndex = characterOffset + match.index;
  265. 			match.index = matchIndex;
  266.  
  267. 			return match;
  268. 		},
  269.  
  270. 		/**
  271. 		 * Gets aggregate text within subject node
  272. 		 */
  273. 		getAggregateText: function() {
  274.  
  275. 			var elementFilter = this.options.filterElements;
  276. 			var forceContext = this.options.forceContext;
  277.  
  278. 			return getText(this.node);
  279.  
  280. 			/**
  281. 			 * Gets aggregate text of a node without resorting
  282. 			 * to broken innerText/textContent
  283. 			 */
  284. 			function getText(node, txt) {
  285.  
  286. 				if (node.nodeType === 3) {
  287. 					return [node.data];
  288. 				}
  289.  
  290. 				if (elementFilter && !elementFilter(node)) {
  291. 					return [];
  292. 				}
  293.  
  294. 				var txt = [''];
  295. 				var i = 0;
  296.  
  297. 				if (node = node.firstChild) do {
  298.  
  299. 					if (node.nodeType === 3) {
  300. 						txt[i] += node.data;
  301. 						continue;
  302. 					}
  303.  
  304. 					var innerText = getText(node);
  305.  
  306. 					if (
  307. 						forceContext &&
  308. 						node.nodeType === 1 &&
  309. 						(forceContext === true || forceContext(node))
  310. 					) {
  311. 						txt[++i] = innerText;
  312. 						txt[++i] = '';
  313. 					} else {
  314. 						if (typeof innerText[0] === 'string') {
  315. 							// Bridge nested text-node data so that they're
  316. 							// not considered their own contexts:
  317. 							// I.e. ['some', ['thing']] -> ['something']
  318. 							txt[i] += innerText.shift();
  319. 						}
  320. 						if (innerText.length) {
  321. 							txt[++i] = innerText;
  322. 							txt[++i] = '';
  323. 						}
  324. 					}
  325. 				} while (node = node.nextSibling);
  326.  
  327. 				return txt;
  328.  
  329. 			}
  330. 			
  331. 		},
  332.  
  333. 		/** 
  334. 		 * Steps through the target node, looking for matches, and
  335. 		 * calling replaceFn when a match is found.
  336. 		 */
  337. 		processMatches: function() {
  338.  
  339. 			var matches = this.matches;
  340. 			var node = this.node;
  341. 			var elementFilter = this.options.filterElements;
  342.  
  343. 			var startPortion,
  344. 				endPortion,
  345. 				innerPortions = [],
  346. 				curNode = node,
  347. 				match = matches.shift(),
  348. 				atIndex = 0, // i.e. nodeAtIndex
  349. 				matchIndex = 0,
  350. 				portionIndex = 0,
  351. 				doAvoidNode,
  352. 				nodeStack = [node];
  353.  
  354. 			out: while (true) {
  355.  
  356. 				if (curNode.nodeType === 3) {
  357.  
  358. 					if (!endPortion && curNode.length + atIndex >= match.endIndex) {
  359.  
  360. 						// We've found the ending
  361. 						endPortion = {
  362. 							node: curNode,
  363. 							index: portionIndex++,
  364. 							text: curNode.data.substring(match.startIndex - atIndex, match.endIndex - atIndex),
  365. 							indexInMatch: atIndex - match.startIndex,
  366. 							indexInNode: match.startIndex - atIndex, // always zero for end-portions
  367. 							endIndexInNode: match.endIndex - atIndex,
  368. 							isEnd: true
  369. 						};
  370.  
  371. 					} else if (startPortion) {
  372. 						// Intersecting node
  373. 						innerPortions.push({
  374. 							node: curNode,
  375. 							index: portionIndex++,
  376. 							text: curNode.data,
  377. 							indexInMatch: atIndex - match.startIndex,
  378. 							indexInNode: 0 // always zero for inner-portions
  379. 						});
  380. 					}
  381.  
  382. 					if (!startPortion && curNode.length + atIndex > match.startIndex) {
  383. 						// We've found the match start
  384. 						startPortion = {
  385. 							node: curNode,
  386. 							index: portionIndex++,
  387. 							indexInMatch: 0,
  388. 							indexInNode: match.startIndex - atIndex,
  389. 							endIndexInNode: match.endIndex - atIndex,
  390. 							text: curNode.data.substring(match.startIndex - atIndex, match.endIndex - atIndex)
  391. 						};
  392. 					}
  393.  
  394. 					atIndex += curNode.data.length;
  395.  
  396. 				}
  397.  
  398. 				doAvoidNode = curNode.nodeType === 1 && elementFilter && !elementFilter(curNode);
  399.  
  400. 				if (startPortion && endPortion) {
  401.  
  402. 					curNode = this.replaceMatch(match, startPortion, innerPortions, endPortion);
  403.  
  404. 					// processMatches has to return the node that replaced the endNode
  405. 					// and then we step back so we can continue from the end of the 
  406. 					// match:
  407.  
  408. 					atIndex -= (endPortion.node.data.length - endPortion.endIndexInNode);
  409.  
  410. 					startPortion = null;
  411. 					endPortion = null;
  412. 					innerPortions = [];
  413. 					match = matches.shift();
  414. 					portionIndex = 0;
  415. 					matchIndex++;
  416.  
  417. 					if (!match) {
  418. 						break; // no more matches
  419. 					}
  420.  
  421. 				} else if (
  422. 					!doAvoidNode &&
  423. 					(curNode.firstChild || curNode.nextSibling)
  424. 				) {
  425. 					// Move down or forward:
  426. 					if (curNode.firstChild) {
  427. 						nodeStack.push(curNode);
  428. 						curNode = curNode.firstChild;
  429. 					} else {
  430. 						curNode = curNode.nextSibling;
  431. 					}
  432. 					continue;
  433. 				}
  434.  
  435. 				// Move forward or up:
  436. 				while (true) {
  437. 					if (curNode.nextSibling) {
  438. 						curNode = curNode.nextSibling;
  439. 						break;
  440. 					}
  441. 					curNode = nodeStack.pop();
  442. 					if (curNode === node) {
  443. 						break out;
  444. 					}
  445. 				}
  446.  
  447. 			}
  448.  
  449. 		},
  450.  
  451. 		/**
  452. 		 * Reverts ... TODO
  453. 		 */
  454. 		revert: function() {
  455. 			// Reversion occurs backwards so as to avoid nodes subsequently
  456. 			// replaced during the matching phase (a forward process):
  457. 			for (var l = this.reverts.length; l--;) {
  458. 				this.reverts[l]();
  459. 			}
  460. 			this.reverts = [];
  461. 		},
  462.  
  463. 		prepareReplacementString: function(string, portion, match, matchIndex) {
  464. 			var portionMode = this.options.portionMode;
  465. 			if (
  466. 				portionMode === PORTION_MODE_FIRST &&
  467. 				portion.indexInMatch > 0
  468. 			) {
  469. 				return '';
  470. 			}
  471. 			string = string.replace(/\$(\d+|&|`|')/g, function($0, t) {
  472. 				var replacement;
  473. 				switch(t) {
  474. 					case '&':
  475. 						replacement = match[0];
  476. 						break;
  477. 					case '`':
  478. 						replacement = match.input.substring(0, match.startIndex);
  479. 						break;
  480. 					case '\'':
  481. 						replacement = match.input.substring(match.endIndex);
  482. 						break;
  483. 					default:
  484. 						replacement = match[+t];
  485. 				}
  486. 				return replacement;
  487. 			});
  488.  
  489. 			if (portionMode === PORTION_MODE_FIRST) {
  490. 				return string;
  491. 			}
  492.  
  493. 			if (portion.isEnd) {
  494. 				return string.substring(portion.indexInMatch);
  495. 			}
  496.  
  497. 			return string.substring(portion.indexInMatch, portion.indexInMatch + portion.text.length);
  498. 		},
  499.  
  500. 		getPortionReplacementNode: function(portion, match, matchIndex) {
  501.  
  502. 			var replacement = this.options.replace || '$&';
  503. 			var wrapper = this.options.wrap;
  504.  
  505. 			if (wrapper && wrapper.nodeType) {
  506. 				// Wrapper has been provided as a stencil-node for us to clone:
  507. 				var clone = doc.createElement('div');
  508. 				clone.innerHTML = wrapper.outerHTML || new XMLSerializer().serializeToString(wrapper);
  509. 				wrapper = clone.firstChild;
  510. 			}
  511.  
  512. 			if (typeof replacement == 'function') {
  513. 				replacement = replacement(portion, match, matchIndex);
  514. 				if (replacement && replacement.nodeType) {
  515. 					return replacement;
  516. 				}
  517. 				return doc.createTextNode(String(replacement));
  518. 			}
  519.  
  520. 			var el = typeof wrapper == 'string' ? doc.createElement(wrapper) : wrapper;
  521.  
  522. 			replacement = doc.createTextNode(
  523. 				this.prepareReplacementString(
  524. 					replacement, portion, match, matchIndex
  525. 				)
  526. 			);
  527.  
  528. 			if (!replacement.data) {
  529. 				return replacement;
  530. 			}
  531.  
  532. 			if (!el) {
  533. 				return replacement;
  534. 			}
  535.  
  536. 			el.appendChild(replacement);
  537.  
  538. 			return el;
  539. 		},
  540.  
  541. 		replaceMatch: function(match, startPortion, innerPortions, endPortion) {
  542.  
  543. 			var matchStartNode = startPortion.node;
  544. 			var matchEndNode = endPortion.node;
  545.  
  546. 			var preceedingTextNode;
  547. 			var followingTextNode;
  548.  
  549. 			if (matchStartNode === matchEndNode) {
  550.  
  551. 				var node = matchStartNode;
  552.  
  553. 				if (startPortion.indexInNode > 0) {
  554. 					// Add `before` text node (before the match)
  555. 					preceedingTextNode = doc.createTextNode(node.data.substring(0, startPortion.indexInNode));
  556. 					node.parentNode.insertBefore(preceedingTextNode, node);
  557. 				}
  558.  
  559. 				// Create the replacement node:
  560. 				var newNode = this.getPortionReplacementNode(
  561. 					endPortion,
  562. 					match
  563. 				);
  564.  
  565. 				node.parentNode.insertBefore(newNode, node);
  566.  
  567. 				if (endPortion.endIndexInNode < node.length) { // ?????
  568. 					// Add `after` text node (after the match)
  569. 					followingTextNode = doc.createTextNode(node.data.substring(endPortion.endIndexInNode));
  570. 					node.parentNode.insertBefore(followingTextNode, node);
  571. 				}
  572.  
  573. 				node.parentNode.removeChild(node);
  574.  
  575. 				this.reverts.push(function() {
  576. 					if (preceedingTextNode === newNode.previousSibling) {
  577. 						preceedingTextNode.parentNode.removeChild(preceedingTextNode);
  578. 					}
  579. 					if (followingTextNode === newNode.nextSibling) {
  580. 						followingTextNode.parentNode.removeChild(followingTextNode);
  581. 					}
  582. 					newNode.parentNode.replaceChild(node, newNode);
  583. 				});
  584.  
  585. 				return newNode;
  586.  
  587. 			} else {
  588. 				// Replace matchStartNode -> [innerMatchNodes...] -> matchEndNode (in that order)
  589.  
  590.  
  591. 				preceedingTextNode = doc.createTextNode(
  592. 					matchStartNode.data.substring(0, startPortion.indexInNode)
  593. 				);
  594.  
  595. 				followingTextNode = doc.createTextNode(
  596. 					matchEndNode.data.substring(endPortion.endIndexInNode)
  597. 				);
  598.  
  599. 				var firstNode = this.getPortionReplacementNode(
  600. 					startPortion,
  601. 					match
  602. 				);
  603.  
  604. 				var innerNodes = [];
  605.  
  606. 				for (var i = 0, l = innerPortions.length; i < l; ++i) {
  607. 					var portion = innerPortions[i];
  608. 					var innerNode = this.getPortionReplacementNode(
  609. 						portion,
  610. 						match
  611. 					);
  612. 					portion.node.parentNode.replaceChild(innerNode, portion.node);
  613. 					this.reverts.push((function(portion, innerNode) {
  614. 						return function() {
  615. 							innerNode.parentNode.replaceChild(portion.node, innerNode);
  616. 						};
  617. 					}(portion, innerNode)));
  618. 					innerNodes.push(innerNode);
  619. 				}
  620.  
  621. 				var lastNode = this.getPortionReplacementNode(
  622. 					endPortion,
  623. 					match
  624. 				);
  625.  
  626. 				matchStartNode.parentNode.insertBefore(preceedingTextNode, matchStartNode);
  627. 				matchStartNode.parentNode.insertBefore(firstNode, matchStartNode);
  628. 				matchStartNode.parentNode.removeChild(matchStartNode);
  629.  
  630. 				matchEndNode.parentNode.insertBefore(lastNode, matchEndNode);
  631. 				matchEndNode.parentNode.insertBefore(followingTextNode, matchEndNode);
  632. 				matchEndNode.parentNode.removeChild(matchEndNode);
  633.  
  634. 				this.reverts.push(function() {
  635. 					preceedingTextNode.parentNode.removeChild(preceedingTextNode);
  636. 					firstNode.parentNode.replaceChild(matchStartNode, firstNode);
  637. 					followingTextNode.parentNode.removeChild(followingTextNode);
  638. 					lastNode.parentNode.replaceChild(matchEndNode, lastNode);
  639. 				});
  640.  
  641. 				return lastNode;
  642. 			}
  643. 		}
  644.  
  645. 	};
  646.  
  647. 	return exposed;
  648.  
  649. }));
  650.  
  651. // Actual userscript code
  652.  
  653. var bad_elements = {
  654.  
  655.     // Elements we shouldn't try to link hashes in
  656.     // Preformatted/already linked elements
  657.     a: 1, pre:1, code:1,
  658.     // Media / Source elements:
  659.     script:1, style:1, img:1, video:1, audio:1, canvas:1, svg:1, map:1, object:1,
  660.     // Input elements
  661.     input:1, textarea:1, select:1, option:1, optgroup: 1, button:1
  662. };
  663.  
  664. findAndReplaceDOMText(document.documentElement, {
  665.     find: /(\/?ipfs\/|\/?ipns\/)?(Qm[A-HJ-NP-Za-km-z1-9]{44,45})/g,
  666.     replace: function(portion, match) {
  667.         var path = match[1];
  668.         var hash = match[2];
  669.  
  670.         if(typeof path == "undefined") {
  671.             // Sometimes there's no leading /ipfs/
  672.             path = "/ipfs/";
  673.         }
  674.         
  675.         var link = document.createElement('a');
  676.         link.setAttribute("href", "https://gateway.ipfs.io" + path + hash);
  677.         // Don't just set inner text; it may not work if there's no text node alreay.
  678.         var content = document.createTextNode(path + hash);
  679.         link.appendChild(content);
  680.         return link;
  681.     },
  682.     forceContext: function(el) {
  683.         return true;
  684.     },
  685.     filterElements: function(el) {
  686.         return !bad_elements.hasOwnProperty(el.nodeName.toLowerCase());
  687.     }
  688. });