tiddlywiki 5.3.8 → 5.4.0

package/plugins/tiddlywiki/filesystem/filesystemadaptor.js

@@ -10,11 +10,9 @@ A sync adaptor module for synchronising with the local filesystem via node.js AP
 "use strict";
 
 // Get a reference to the file system
-var fs = $tw.node ? require("fs") : null,
-	path = $tw.node ? require("path") : null;
+var fs = $tw.node ? require("fs") : null;
 
 function FileSystemAdaptor(options) {
-	var self = this;
 	this.wiki = options.wiki;
 	this.boot = options.boot || $tw.boot;
 	this.logger = new $tw.utils.Logger("filesystem",{colour: "blue"});

package/plugins/tiddlywiki/filesystem/plugin.info

@@ -3,5 +3,6 @@
 	"name": "Filesystem",
 	"description": "Synchronize changes from the node.js server to the local filesystem",
 	"list": "readme",
+	"platform": "server",
 	"stability": "STABILITY_2_STABLE"
 }

package/plugins/tiddlywiki/freelinks/aho-corasick.js

@@ -0,0 +1,190 @@
+/*\
+
+title: $:/core/modules/utils/aho-corasick.js
+type: application/javascript
+module-type: utils
+
+Optimized Aho-Corasick string matching algorithm implementation with enhanced performance
+and error handling for TiddlyWiki freelinking functionality.
+
+- Uses WeakMap for failure links (required; plain object keys would collide).
+- search() converts case per character to avoid Unicode index desync.
+- Optional word boundary filtering: CJK always allowed; Latin requires non-word chars around.
+
+\*/
+
+"use strict";
+
+function AhoCorasick() {
+	this.trie = {};
+	this.failure = new WeakMap();
+	this.maxFailureDepth = 100;
+	this.patternCount = 0;
+}
+
+AhoCorasick.prototype.addPattern = function(pattern, index) {
+	if(!pattern || typeof pattern !== "string" || pattern.length === 0) {
+		return;
+	}
+	var node = this.trie;
+	for(var i = 0; i < pattern.length; i++) {
+		var ch = pattern[i];
+		if(!node[ch]) {
+			node[ch] = {};
+		}
+		node = node[ch];
+	}
+	if(!node.$) {
+		node.$ = [];
+	}
+	node.$.push({
+		pattern: pattern,
+		index: index,
+		length: pattern.length
+	});
+	this.patternCount++;
+};
+
+AhoCorasick.prototype.buildFailureLinks = function() {
+	var queue = [];
+	var root = this.trie;
+	var self = this;
+
+	this.failure = new WeakMap();
+	this.failure.set(root, root);
+
+	for(var ch in root) {
+		if(ch === "$") continue;
+		if(root[ch] && typeof root[ch] === "object") {
+			this.failure.set(root[ch], root);
+			queue.push(root[ch]);
+		}
+	}
+
+	var processedNodes = 0;
+	var maxNodes = Math.max(100000, this.patternCount * 15);
+
+	while(queue.length > 0) {
+		if(processedNodes++ >= maxNodes) {
+			throw new Error("Aho-Corasick: buildFailureLinks exceeded maximum nodes (" + maxNodes + ")");
+		}
+		var node = queue.shift();
+
+		for(var edge in node) {
+			if(edge === "$") continue;
+			var child = node[edge];
+			if(!child || typeof child !== "object") continue;
+
+			var fail = self.failure.get(node) || root;
+			var depth = 0;
+
+			while(fail !== root && !fail[edge] && depth < self.maxFailureDepth) {
+				fail = self.failure.get(fail) || root;
+				depth++;
+			}
+
+			var nextFail = (fail[edge] && fail[edge] !== child) ? fail[edge] : root;
+			self.failure.set(child, nextFail);
+
+			if(nextFail.$) {
+				if(!child.$) child.$ = [];
+				child.$ = child.$.concat(nextFail.$);
+			}
+
+			queue.push(child);
+		}
+	}
+};
+
+AhoCorasick.prototype.search = function(text, useWordBoundary, ignoreCase) {
+	if(!text || typeof text !== "string" || text.length === 0) {
+		return [];
+	}
+
+	var matches = [];
+	var node = this.trie;
+	var root = this.trie;
+	var textLength = text.length;
+
+	var maxMatches = Math.min(textLength * 2, 10000);
+
+	for(var i = 0; i < textLength; i++) {
+		var ch = ignoreCase ? text[i].toLowerCase() : text[i];
+
+		while(node !== root && !node[ch]) {
+			node = this.failure.get(node) || root;
+		}
+		if(node[ch]) {
+			node = node[ch];
+		}
+
+		if(node.$) {
+			var outputs = node.$;
+			for(var j = 0; j < outputs.length && matches.length < maxMatches; j++) {
+				var out = outputs[j];
+				var matchStart = i - out.length + 1;
+				var matchEnd = i + 1;
+				if(matchStart < 0) continue;
+
+				if(useWordBoundary && !this.isWordBoundaryMatch(text, matchStart, matchEnd)) {
+					continue;
+				}
+
+				matches.push({
+					pattern: out.pattern,
+					index: matchStart,
+					length: out.length,
+					titleIndex: out.index
+				});
+			}
+		}
+	}
+
+	return matches;
+};
+
+AhoCorasick.prototype.isWordBoundaryMatch = function(text, start, end) {
+	var matchedText = text.substring(start, end);
+
+	if(/[\u3400-\u9FFF\uF900-\uFAFF]/.test(matchedText)) {
+		return true;
+	}
+
+	var beforeChar = start > 0 ? text[start - 1] : "";
+	var afterChar = end < text.length ? text[end] : "";
+
+	var isLatinWordChar = function(char) {
+		return /[a-zA-Z0-9_\u00C0-\u00FF]/.test(char);
+	};
+
+	return !isLatinWordChar(beforeChar) && !isLatinWordChar(afterChar);
+};
+
+AhoCorasick.prototype.clear = function() {
+	this.trie = {};
+	this.failure = new WeakMap();
+	this.patternCount = 0;
+};
+
+AhoCorasick.prototype.getStats = function() {
+	var nodeCount = 0;
+	function countNodes(node) {
+		if(!node) return;
+		nodeCount++;
+		for(var key in node) {
+			if(key === "$") continue;
+			if(node[key] && typeof node[key] === "object") {
+				countNodes(node[key]);
+			}
+		}
+	}
+	countNodes(this.trie);
+
+	return {
+		nodeCount: nodeCount,
+		patternCount: this.patternCount,
+		failureLinks: this.patternCount
+	};
+};
+
+exports.AhoCorasick = AhoCorasick;

package/plugins/tiddlywiki/freelinks/config-Freelinks-WordBoundary.tid

@@ -0,0 +1,2 @@
+title: $:/config/Freelinks/WordBoundary
+text: yes

package/plugins/tiddlywiki/freelinks/readme.tid

@@ -2,26 +2,36 @@ title: $:/plugins/tiddlywiki/freelinks/readme
 
 This plugin adds automatic generation of links to tiddler titles.
 
-''Note that automatic link generation can be very slow when there are a large number of tiddlers''.
+The plugin uses the Aho-Corasick algorithm for efficient pattern matching with large numbers of tiddlers.
+
+!! Configuration
 
 Freelinking is activated for runs of text that have the following variables set:
 
 * `tv-wikilinks` is NOT equal to `no`
 * `tv-freelinks` is set to `yes`
 
-Freelinks are case sensitive by default but can be configured to ignore case in the settings tab.
+Freelinks are case sensitive by default but can be configured to ignore case in the settings panel.
+
+Word boundary checking can be configured in the settings panel. When enabled (default for Western languages), links are created only for complete words. When disabled, partial matches within words are also linked.
+
+When multiple tiddler titles match the same text, longer titles take precedence over shorter ones.
+
+Tiddlers do not create links to themselves.
+
+Use `$:/config/Freelinks/TargetFilter` to define which tiddlers are eligible for auto-linking.
 
-Within view templates, the variable `tv-freelinks` is automatically set to the content of $:/config/Freelinks/Enable, which can be set via the settings panel of this plugin.
+Within view templates, the variable `tv-freelinks` is automatically set to the content of `$:/config/Freelinks/Enable`, which can be set via the settings panel of this plugin.
 
 !! Notes
 
-To change within which tiddlers freelinking occurs requires customising the shadow tiddler [[$:/plugins/tiddlywiki/freelinks/macros/view]]. This tiddler is tagged $:/tags/Macro/View  which means that it will be included as a local macro in each view template. By default, its content is:
+To change within which tiddlers freelinking occurs requires customising the shadow tiddler [[$:/plugins/tiddlywiki/freelinks/macros/view]]. This tiddler is tagged `$:/tags/Macro/View` which means that it will be included as a local macro in each view template. By default, its content is:
 
 ```
 <$set name="tv-freelinks" value={{$:/config/Freelinks/Enable}}/>
 ```
 
-That means that for each tiddler the variable tv-freelinks will be set to the tiddler $:/config/Freelinks/Enable, which is set to "yes" or "no" by the settings in control panel.
+That means that for each tiddler the variable `tv-freelinks` will be set to the tiddler `$:/config/Freelinks/Enable`, which is set to "yes" or "no" by the settings in control panel.
 
 Instead, we can use a filter expression to, say, only freelink within the tiddler with the title "HelloThere":
 
@@ -40,3 +50,14 @@ Or we can combine both approaches:
 ```
 <$set name="tv-freelinks" value={{{ [<currentTiddler>match[HelloThere]] ~[<currentTiddler>tag[MyTag]] +[then[yes]else[no]] }}}/>
 ```
+
+!! Implementation Details
+
+The Aho-Corasick algorithm implementation includes:
+
+* Unicode character support for international text
+* Prevention of self-referential links within the current tiddler
+* Performance safeguards including depth protection and result limiting
+* Graceful fallback handling for invalid patterns
+
+Longer tiddler titles take precedence over shorter ones when multiple matches are possible.

package/plugins/tiddlywiki/freelinks/settings.tid

@@ -6,4 +6,6 @@ Filter defining tiddlers to which freelinks are made: <$edit-text tiddler="$:/co
 
 <$checkbox tiddler="$:/config/Freelinks/Enable" field="text" checked="yes" unchecked="no" default="no"> <$link to="$:/config/Freelinks/Enable">Enable freelinking within tiddler view templates</$link> </$checkbox>
 
+<$checkbox tiddler="$:/config/Freelinks/WordBoundary" field="text" checked="yes" unchecked="no" default="yes"> <$link to="$:/config/Freelinks/WordBoundary">Word Boundary Check</$link> </$checkbox>
+
 <$checkbox tiddler="$:/config/Freelinks/IgnoreCase" field="text" checked="yes" unchecked="no" default="no"> <$link to="$:/config/Freelinks/IgnoreCase">Ignore case</$link> </$checkbox>

package/plugins/tiddlywiki/freelinks/text.js

@@ -1,33 +1,34 @@
 /*\
+
 title: $:/core/modules/widgets/text.js
 type: application/javascript
 module-type: widget
 
-An override of the core text widget that automatically linkifies the text
+Optimized override of the core text widget that automatically linkifies text.
+- Supports non-Latin languages like Chinese.
+- Global longest-match priority, then removes overlaps.
+- Excludes current tiddler title from linking.
+- Uses Aho-Corasick for performance.
 
 \*/
 
 "use strict";
 
 var TITLE_TARGET_FILTER = "$:/config/Freelinks/TargetFilter";
+var WORD_BOUNDARY_TIDDLER = "$:/config/Freelinks/WordBoundary";
 
 var Widget = require("$:/core/modules/widgets/widget.js").widget,
 	LinkWidget = require("$:/core/modules/widgets/link.js").link,
 	ButtonWidget = require("$:/core/modules/widgets/button.js").button,
-	ElementWidget = require("$:/core/modules/widgets/element.js").element;
+	ElementWidget = require("$:/core/modules/widgets/element.js").element,
+	AhoCorasick = require("$:/core/modules/utils/aho-corasick.js").AhoCorasick;
 
 var TextNodeWidget = function(parseTreeNode,options) {
 	this.initialise(parseTreeNode,options);
 };
 
-/*
-Inherit from the base widget class
-*/
 TextNodeWidget.prototype = new Widget();
 
-/*
-Render this widget into the DOM
-*/
 TextNodeWidget.prototype.render = function(parent,nextSibling) {
 	this.parentDomNode = parent;
 	this.computeAttributes();
@@ -35,129 +36,244 @@ TextNodeWidget.prototype.render = function(parent,nextSibling) {
 	this.renderChildren(parent,nextSibling);
 };
 
-/*
-Compute the internal state of the widget
-*/
 TextNodeWidget.prototype.execute = function() {
-	var self = this,
-		ignoreCase = self.getVariable("tv-freelinks-ignore-case",{defaultValue:"no"}).trim() === "yes";
-	// Get our parameters
+	var self = this;
+	var ignoreCase = self.getVariable("tv-freelinks-ignore-case",{defaultValue:"no"}).trim() === "yes";
+
 	var childParseTree = [{
-			type: "plain-text",
-			text: this.getAttribute("text",this.parseTreeNode.text || "")
-		}];
-	// Only process links if not disabled and we're not within a button or link widget
-	if(this.getVariable("tv-wikilinks",{defaultValue:"yes"}).trim() !== "no" && this.getVariable("tv-freelinks",{defaultValue:"no"}).trim() === "yes" && !this.isWithinButtonOrLink()) {
-		// Get the information about the current tiddler titles, and construct a regexp
-		this.tiddlerTitleInfo = this.wiki.getGlobalCache("tiddler-title-info-" + (ignoreCase ? "insensitive" : "sensitive"),function() {
-			var targetFilterText = self.wiki.getTiddlerText(TITLE_TARGET_FILTER),
-				titles = !!targetFilterText ? self.wiki.filterTiddlers(targetFilterText,$tw.rootWidget) : self.wiki.allTitles(),
-				sortedTitles = titles.sort(function(a,b) {
-					var lenA = a.length,
-						lenB = b.length;
-					// First sort by length, so longer titles are first
-					if(lenA !== lenB) {
-						if(lenA < lenB) {
-							return +1;
-						} else {
-							return -1;
-						}
-					} else {
-					// Then sort alphabetically within titles of the same length
-						if(a < b) {
-							return -1;
-						} else if(a > b) {
-							return +1;
-						} else {
-							return 0;
-						}
-					}
-				}),
-				titles = [],
-				reparts = [];
-			$tw.utils.each(sortedTitles,function(title) {
-				if(title.substring(0,3) !== "$:/") {
-					titles.push(title);
-					reparts.push("(" + $tw.utils.escapeRegExp(title) + ")");
-				}
-			});
-			var regexpStr = "\\b(?:" + reparts.join("|") + ")\\b";
-			return {
-				titles: titles,
-				regexp: new RegExp(regexpStr,ignoreCase ? "i" : "")
-			};
+		type: "plain-text",
+		text: this.getAttribute("text",this.parseTreeNode.text || "")
+	}];
+
+	var text = childParseTree[0].text;
+	if(!text || text.length < 2) {
+		this.makeChildWidgets(childParseTree);
+		return;
+	}
+
+	if(this.getVariable("tv-wikilinks",{defaultValue:"yes"}) !== "no" &&
+		this.getVariable("tv-freelinks",{defaultValue:"no"}) === "yes" &&
+		!this.isWithinButtonOrLink()) {
+
+		var currentTiddlerTitle = this.getVariable("currentTiddler") || "";
+		var useWordBoundary = self.wiki.getTiddlerText(WORD_BOUNDARY_TIDDLER,"no") === "yes";
+
+		var cacheKey = "tiddler-title-info-" + (ignoreCase ? "insensitive" : "sensitive");
+		this.tiddlerTitleInfo = this.wiki.getGlobalCache(cacheKey,function() {
+			return computeTiddlerTitleInfo(self,ignoreCase);
 		});
-		// Repeatedly linkify
-		if(this.tiddlerTitleInfo.titles.length > 0) {
-			var index,text,match,matchEnd;
-			do {
-				index = childParseTree.length - 1;
-				text = childParseTree[index].text;
-				match = this.tiddlerTitleInfo.regexp.exec(text);
-				if(match) {
-					// Make a text node for any text before the match
-					if(match.index > 0) {
-						childParseTree[index].text = text.substring(0,match.index);
-						index += 1;
-					}
-					// Make a link node for the match
-					childParseTree[index] = {
-						type: "link",
-						attributes: {
-							to: {type: "string", value: ignoreCase ? this.tiddlerTitleInfo.titles[match.indexOf(match[0],1) - 1] : match[0]},
-							"class": {type: "string", value: "tc-freelink"}
-						},
-						children: [{
-							type: "plain-text", text: match[0]
-						}]
-					};
-					index += 1;
-					// Make a text node for any text after the match
-					matchEnd = match.index + match[0].length;
-					if(matchEnd < text.length) {
-						childParseTree[index] = {
-							type: "plain-text",
-							text: text.substring(matchEnd)
-						};					
-					}
-				}
-			} while(match && childParseTree[childParseTree.length - 1].type === "plain-text");			
+
+		if(this.tiddlerTitleInfo && this.tiddlerTitleInfo.titles && this.tiddlerTitleInfo.titles.length > 0 && this.tiddlerTitleInfo.ac) {
+			var newParseTree = this.processTextWithMatches(text,currentTiddlerTitle,ignoreCase,useWordBoundary);
+			if(newParseTree && newParseTree.length > 0 &&
+				(newParseTree.length > 1 || newParseTree[0].type !== "plain-text")) {
+				childParseTree = newParseTree;
+			}
 		}
 	}
-	// Make the child widgets
+
 	this.makeChildWidgets(childParseTree);
 };
 
+TextNodeWidget.prototype.processTextWithMatches = function(text,currentTiddlerTitle,ignoreCase,useWordBoundary) {
+	if(!text || text.length === 0) {
+		return [{type: "plain-text", text: text}];
+	}
+
+	var matches;
+	try {
+		matches = this.tiddlerTitleInfo.ac.search(text, useWordBoundary, ignoreCase);
+	} catch(e) {
+		return [{type: "plain-text", text: text}];
+	}
+
+	if(!matches || matches.length === 0) {
+		return [{type: "plain-text", text: text}];
+	}
+
+	var titleToCompare = ignoreCase ?
+		(currentTiddlerTitle ? currentTiddlerTitle.toLowerCase() : "") :
+		currentTiddlerTitle;
+
+	matches.sort(function(a,b) {
+		if(b.length !== a.length) return b.length - a.length;
+		return a.index - b.index;
+	});
+
+	var occupied = new Uint8Array(text.length);
+	var validMatches = [];
+
+	for(var i = 0; i < matches.length; i++) {
+		var m = matches[i];
+		var start = m.index;
+		var end = start + m.length;
+		if(start < 0 || end > text.length) continue;
+
+		var matchedTitle = this.tiddlerTitleInfo.titles[m.titleIndex];
+		if(!matchedTitle) continue;
+
+		var matchedTitleToCompare = ignoreCase ? matchedTitle.toLowerCase() : matchedTitle;
+		if(titleToCompare && matchedTitleToCompare === titleToCompare) continue;
+
+		var overlapping = false;
+		for(var j = start; j < end; j++) {
+			if(occupied[j]) { overlapping = true; break; }
+		}
+		if(overlapping) continue;
+
+		validMatches.push(m);
+		for(var k = start; k < end; k++) {
+			occupied[k] = 1;
+		}
+	}
+
+	if(validMatches.length === 0) {
+		return [{type: "plain-text", text: text}];
+	}
+
+	validMatches.sort(function(a,b){ return a.index - b.index; });
+
+	var newParseTree = [];
+	var curPos = 0;
+
+	for(var x = 0; x < validMatches.length; x++) {
+		var mm = validMatches[x];
+		var s = mm.index;
+		var e = s + mm.length;
+
+		if(s > curPos) {
+			newParseTree.push({ type: "plain-text", text: text.substring(curPos,s) });
+		}
+
+		var toTitle = this.tiddlerTitleInfo.titles[mm.titleIndex];
+		var matchedText = text.substring(s,e);
+
+		newParseTree.push({
+			type: "link",
+			attributes: {
+				to: {type: "string", value: toTitle},
+				"class": {type: "string", value: "tc-freelink"}
+			},
+			children: [{
+				type: "plain-text",
+				text: matchedText
+			}]
+		});
+
+		curPos = e;
+	}
+
+	if(curPos < text.length) {
+		newParseTree.push({ type: "plain-text", text: text.substring(curPos) });
+	}
+
+	return newParseTree;
+};
+
+function computeTiddlerTitleInfo(self,ignoreCase) {
+	var targetFilterText = self.wiki.getTiddlerText(TITLE_TARGET_FILTER),
+		titles = targetFilterText ?
+			self.wiki.filterTiddlers(targetFilterText,$tw.rootWidget) :
+			self.wiki.allTitles();
+
+	if(!titles || titles.length === 0) {
+		return { titles: [], ac: new AhoCorasick() };
+	}
+
+	var validTitles = [];
+	for(var i = 0; i < titles.length; i++) {
+		var t = titles[i];
+		if(t && t.length > 0 && t.substring(0,3) !== "$:/") {
+			validTitles.push(t);
+		}
+	}
+
+	validTitles.sort(function(a,b) {
+		var d = b.length - a.length;
+		if(d !== 0) return d;
+		return a < b ? -1 : a > b ? 1 : 0;
+	});
+
+	var ac = new AhoCorasick();
+	for(var j = 0; j < validTitles.length; j++) {
+		var title = validTitles[j];
+		var pattern = ignoreCase ? title.toLowerCase() : title;
+		ac.addPattern(pattern,j);
+	}
+
+	try {
+		ac.buildFailureLinks();
+	} catch(e) {
+		return { titles: [], ac: new AhoCorasick() };
+	}
+
+	return { titles: validTitles, ac: ac };
+}
+
 TextNodeWidget.prototype.isWithinButtonOrLink = function() {
-	var withinButtonOrLink = false,
-		widget = this.parentWidget;
-	while(!withinButtonOrLink && widget) {
-		withinButtonOrLink = widget instanceof ButtonWidget || widget instanceof LinkWidget || ((widget instanceof ElementWidget) && widget.parseTreeNode.tag === "a");
+	var widget = this.parentWidget;
+	while(widget) {
+		if(widget instanceof ButtonWidget ||
+			widget instanceof LinkWidget ||
+			((widget instanceof ElementWidget) && widget.parseTreeNode.tag === "a")) {
+			return true;
+		}
 		widget = widget.parentWidget;
 	}
-	return withinButtonOrLink;
+	return false;
 };
 
-/*
-Selectively refreshes the widget if needed. Returns true if the widget or any of its children needed re-rendering
-*/
 TextNodeWidget.prototype.refresh = function(changedTiddlers) {
-	var self = this,
-		changedAttributes = this.computeAttributes(),
-		titlesHaveChanged = false;
-	$tw.utils.each(changedTiddlers,function(change,title) {
-		if(change.isDeleted) {
-			titlesHaveChanged = true;
-		} else {
-			titlesHaveChanged = titlesHaveChanged || !self.tiddlerTitleInfo || self.tiddlerTitleInfo.titles.indexOf(title) === -1;
+	var self = this;
+	var changedAttributes = this.computeAttributes();
+	var titlesHaveChanged = false;
+
+	if(changedTiddlers) {
+		$tw.utils.each(changedTiddlers,function(change,title) {
+			if(titlesHaveChanged) return;
+
+			if(title === WORD_BOUNDARY_TIDDLER || title === TITLE_TARGET_FILTER) {
+				titlesHaveChanged = true;
+				return;
+			}
+
+			if(title.substring(0,3) === "$:/") {
+				return;
+			}
+
+			if(change && change.isDeleted) {
+				if(self.tiddlerTitleInfo && self.tiddlerTitleInfo.titles && self.tiddlerTitleInfo.titles.indexOf(title) !== -1) {
+					titlesHaveChanged = true;
+				}
+				return;
+			}
+
+			var tiddler = self.wiki.getTiddler(title);
+			if(tiddler && tiddler.hasField("draft.of")) {
+				return;
+			}
+
+			if(!self.tiddlerTitleInfo || !self.tiddlerTitleInfo.titles || self.tiddlerTitleInfo.titles.indexOf(title) === -1) {
+				titlesHaveChanged = true;
+			}
+		});
+	}
+
+	var wordBoundaryChanged = !!(changedTiddlers && changedTiddlers[WORD_BOUNDARY_TIDDLER]);
+
+	if(changedAttributes.text || titlesHaveChanged || wordBoundaryChanged) {
+		if(titlesHaveChanged) {
+			self.wiki.clearCache("tiddler-title-info-insensitive");
+			self.wiki.clearCache("tiddler-title-info-sensitive");
 		}
-	});
-	if(changedAttributes.text || titlesHaveChanged) {
 		this.refreshSelf();
 		return true;
-	} else {
-		return false;	
 	}
+
+	if(changedTiddlers) {
+		return this.refreshChildren(changedTiddlers);
+	}
+	return false;
 };
 
 exports.text = TextNodeWidget;

package/plugins/tiddlywiki/geospatial/geotools.js

@@ -17,7 +17,7 @@ Parse a string as a GeoJSON Point
 exports.parsePoint = function(str) {
 	var defaultResult = function() {
 		return turf.point([0,0,0]);
-	}
+	};
 	// If the string is missing then return 0,0,0
 	if(!str) {
 		return defaultResult();
@@ -33,4 +33,4 @@ exports.parsePoint = function(str) {
 	}
 	// Return the string now we know it is a valid GeoJSON Point
 	return json;
-}
+};