tiddlywiki 5.3.8 → 5.4.0

package/editions/test/tiddlers/tests/test-compare-filter.js

@@ -7,16 +7,13 @@ Tests the compare filter.
 
 \*/
 
-
-/* jslint node: true, browser: true */
 /* eslint-env node, browser, jasmine */
 /* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
-/* global $tw, require */
 "use strict";
 
 describe("'compare' filter tests", function() {
 
-	var wiki = new $tw.Wiki();
+	var wiki = $tw.test.wiki();
 
 	it("should compare numerical equality", function() {
 		expect(wiki.filterTiddlers("[[2]compare:number:eq[0003]]").join(",")).toBe("");

package/editions/test/tiddlers/tests/test-deserialize-operator.js

@@ -7,34 +7,31 @@ Tests deserialize[] filter operator with various core deserializers
 
 \*/
 
-
-	/* jslint node: true, browser: true */
-	/* eslint-env node, browser, jasmine */
-	/* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
-	/* global $tw, require */
-	"use strict";
+/* eslint-env node, browser, jasmine */
+/* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
+"use strict";
 
 	
-	describe("deserialize operator tests", function() {
+describe("deserialize operator tests", function() {
 
-		it("should support the deserialize[] operator", function() {
-			//Unknown deserializer as operand
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[unknown/deserializer]]")).toEqual([$tw.language.getString("Error/DeserializeOperator/UnknownDeserializer")]);
+	it("should support the deserialize[] operator", function() {
+		//Unknown deserializer as operand
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[unknown/deserializer]]")).toEqual([$tw.language.getString("Error/DeserializeOperator/UnknownDeserializer")]);
 
-			//Missing operand
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[]]")).toEqual([$tw.language.getString("Error/DeserializeOperator/MissingOperand")]);
+		//Missing operand
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[]]")).toEqual([$tw.language.getString("Error/DeserializeOperator/MissingOperand")]);
 
-			//Deserialize TiddlyWiki file
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[text/html]]")).toEqual(['[{"type":"text/vnd.tiddlywiki","text":"Abacus","title":"Hello \\"There\\""},{"title":"Hello \\"There\\"","text":"Calculator"}]']);
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 5}deserialize[text/html]]")).toEqual(['[{"type":"text/vnd.tiddlywiki","text":"Abacus","title":"Hello \\"There\\""},{"title":"Hello \\"There\\"","text":"Calculator"},{"title":"Hello \\"There\\"","text":"Protractor"}]']);
+		//Deserialize TiddlyWiki file
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 4}deserialize[text/html]]")).toEqual(['[{"type":"text/vnd.tiddlywiki","text":"Abacus","title":"Hello \\"There\\""},{"title":"Hello \\"There\\"","text":"Calculator"}]']);
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 5}deserialize[text/html]]")).toEqual(['[{"type":"text/vnd.tiddlywiki","text":"Abacus","title":"Hello \\"There\\""},{"title":"Hello \\"There\\"","text":"Calculator"},{"title":"Hello \\"There\\"","text":"Protractor"}]']);
 
-			// Deserialize JSON payload containing tiddlers
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 6}deserialize[application/json]]")).toEqual( [ `[{"created":"20230601125557184","text":"Before you start storing important information in ~TiddlyWiki it is vital to make sure that you can reliably save changes. See https://tiddlywiki.com/#GettingStarted for details\\n\\n","title":"GettingStarted","modified":"20230601125601619"},{"created":"20230601125507054","text":"Welcome to \\"TiddlyWiki\\".\\n\\nThis is a test tiddler.","tags":"","title":"Hello There \\"Welcome\\"","modified":"20230601125551144"},{"title":"TiddlyWiki","created":"20130822170700000","modified":"20170127221451610","tags":"Concepts","type":"text/vnd.tiddlywiki","text":"~TiddlyWiki is a rich, interactive tool for manipulating complex data with structure that doesn't easily fit into conventional tools like spreadsheets or wordprocessors.\\n\\n~TiddlyWiki is designed to fit around your brain, helping you deal with the things that won't fit."}]` ]);
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 6}deserialize[application/json]jsonindexes[]] :map[{dezerializer test data case 6}jsonget<currentTiddler>,[title]]")).toEqual([ 'GettingStarted', 'Hello There "Welcome"', 'TiddlyWiki' ]);
+		// Deserialize JSON payload containing tiddlers
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 6}deserialize[application/json]]")).toEqual( [ "[{\"created\":\"20230601125557184\",\"text\":\"Before you start storing important information in ~TiddlyWiki it is vital to make sure that you can reliably save changes. See https://tiddlywiki.com/#GettingStarted for details\\n\\n\",\"title\":\"GettingStarted\",\"modified\":\"20230601125601619\"},{\"created\":\"20230601125507054\",\"text\":\"Welcome to \\\"TiddlyWiki\\\".\\n\\nThis is a test tiddler.\",\"tags\":\"\",\"title\":\"Hello There \\\"Welcome\\\"\",\"modified\":\"20230601125551144\"},{\"title\":\"TiddlyWiki\",\"created\":\"20130822170700000\",\"modified\":\"20170127221451610\",\"tags\":\"Concepts\",\"type\":\"text/vnd.tiddlywiki\",\"text\":\"~TiddlyWiki is a rich, interactive tool for manipulating complex data with structure that doesn't easily fit into conventional tools like spreadsheets or wordprocessors.\\n\\n~TiddlyWiki is designed to fit around your brain, helping you deal with the things that won't fit.\"}]" ]);
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 6}deserialize[application/json]jsonindexes[]] :map[{dezerializer test data case 6}jsonget<currentTiddler>,[title]]")).toEqual([ "GettingStarted", 'Hello There "Welcome"', "TiddlyWiki" ]);
 
-			//Deserialize TiddlyWiki file with an mismatched deserializer
-			expect($tw.wiki.filterTiddlers("[{dezerializer test data case 5}deserialize[application/json]]")).toEqual([jasmine.stringMatching('JSON error')]);
-		});
+		//Deserialize TiddlyWiki file with an mismatched deserializer
+		expect($tw.wiki.filterTiddlers("[{dezerializer test data case 5}deserialize[application/json]]")).toEqual([jasmine.stringMatching("JSON error")]);
 	});
+});
 	
 

package/editions/test/tiddlers/tests/test-deserializers.js

@@ -7,29 +7,27 @@ Tests various core deserializers
 
 \*/
 
-	/* jslint node: true, browser: true */
-	/* eslint-env node, browser, jasmine */
-	/* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
-	/* global $tw, require */
-	"use strict";
+/* eslint-env node, browser, jasmine */
+/* eslint no-mixed-spaces-and-tabs: ["error", "smart-tabs"]*/
+"use strict";
 	
-	describe("deserializer tests", function() {
-
-		function executeTestCase(title,expectedOutput) {
-			it("test case " + title, function() {
-				var tiddler = $tw.wiki.getTiddler(title);
-				expect($tw.wiki.deserializeTiddlers(tiddler.fields.type,tiddler.fields.text)).toEqual(expectedOutput);
-			});
-		}
+describe("deserializer tests", function() {
+
+	function executeTestCase(title,expectedOutput) {
+		it("test case " + title, function() {
+			var tiddler = $tw.wiki.getTiddler(title);
+			expect($tw.wiki.deserializeTiddlers(tiddler.fields.type,tiddler.fields.text)).toEqual(expectedOutput);
+		});
+	}
 	
-		executeTestCase("dezerializer test data case 1",[ { text: '<!doctype html>\n', type: 'text/html' } ]);
+	executeTestCase("dezerializer test data case 1",[ { text: "<!doctype html>\n", type: "text/html" } ]);
 
-		executeTestCase("dezerializer test data case 2",[ { text: '<!doctype html>\n<html lang="en">\n<head>\n\t<meta charset="utf-8">\n\t<title>Test Data</title>\n</head>\n<body>\n</body>\n</html>\n', type: 'text/html' } ]);
+	executeTestCase("dezerializer test data case 2",[ { text: '<!doctype html>\n<html lang="en">\n<head>\n\t<meta charset="utf-8">\n\t<title>Test Data</title>\n</head>\n<body>\n</body>\n</html>\n', type: "text/html" } ]);
 
-		executeTestCase("dezerializer test data case 3",[ { title: 'Hello "There"', text: 'Abacus', type: 'text/vnd.tiddlywiki' } ]);
+	executeTestCase("dezerializer test data case 3",[ { title: 'Hello "There"', text: "Abacus", type: "text/vnd.tiddlywiki" } ]);
 
-		executeTestCase("dezerializer test data case 4",[ { title: 'Hello "There"', text: 'Abacus', type: 'text/vnd.tiddlywiki' }, { title: 'Hello "There"', text: 'Calculator'}  ]);
+	executeTestCase("dezerializer test data case 4",[ { title: 'Hello "There"', text: "Abacus", type: "text/vnd.tiddlywiki" }, { title: 'Hello "There"', text: "Calculator"}  ]);
 
-		executeTestCase("dezerializer test data case 5",[ { title: 'Hello "There"', text: 'Abacus', type: 'text/vnd.tiddlywiki' }, { title: 'Hello "There"', text: 'Calculator'} , { title: 'Hello "There"', text: 'Protractor'}  ]);
+	executeTestCase("dezerializer test data case 5",[ { title: 'Hello "There"', text: "Abacus", type: "text/vnd.tiddlywiki" }, { title: 'Hello "There"', text: "Calculator"} , { title: 'Hello "There"', text: "Protractor"}  ]);
 		
-	});
+});

package/editions/test/tiddlers/tests/test-filters.js

@@ -7,60 +7,60 @@ Tests the filtering mechanism.
 
 \*/
 
-	"use strict";
-	
-	describe("Filter tests", function() {
-	
-		// Test filter parsing
-		it("should parse new-style rich operator suffixes", function() {
-			expect($tw.wiki.parseFilter("[search:: four, , five,, six [operand]]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'search', suffix : ': four, , five,, six ', suffixes : [ [  ], [ 'four', 'five', 'six' ] ], operands: [ { text:'operand' } ] } ] } ]
-			);
-			expect($tw.wiki.parseFilter("[search: one, two ,three :[operand]]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'search', suffix : ' one, two ,three :', suffixes : [ [ 'one', 'two', 'three' ], [  ] ], operands: [ { text:'operand' } ] } ] } ]
-			);
-			expect($tw.wiki.parseFilter("[search: one, two ,three :[operand]]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'search', suffix : ' one, two ,three :', suffixes : [ [ 'one', 'two', 'three' ], [  ] ], operands: [ { text:'operand' } ] } ] } ]
-			);
-			expect($tw.wiki.parseFilter("[search: one, two ,three : four, , five,, six [operand]]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'search', suffix : ' one, two ,three : four, , five,, six ', suffixes : [ [ 'one', 'two', 'three' ], [ 'four', 'five', 'six' ] ], operands: [ { text:'operand' } ] } ] } ]
-			);
-			expect($tw.wiki.parseFilter("[search: , : [operand]]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'search', suffix : ' , : ', suffixes : [ [  ], [  ] ], operands: [ { text:'operand' } ] } ] } ]
-			);
-		});
+"use strict";
+	
+describe("Filter tests", function() {
+	
+	// Test filter parsing
+	it("should parse new-style rich operator suffixes", function() {
+		expect($tw.wiki.parseFilter("[search:: four, , five,, six [operand]]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "search", suffix : ": four, , five,, six ", suffixes : [ [  ], [ "four", "five", "six" ] ], operands: [ { text:"operand" } ] } ] } ]
+		);
+		expect($tw.wiki.parseFilter("[search: one, two ,three :[operand]]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "search", suffix : " one, two ,three :", suffixes : [ [ "one", "two", "three" ], [  ] ], operands: [ { text:"operand" } ] } ] } ]
+		);
+		expect($tw.wiki.parseFilter("[search: one, two ,three :[operand]]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "search", suffix : " one, two ,three :", suffixes : [ [ "one", "two", "three" ], [  ] ], operands: [ { text:"operand" } ] } ] } ]
+		);
+		expect($tw.wiki.parseFilter("[search: one, two ,three : four, , five,, six [operand]]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "search", suffix : " one, two ,three : four, , five,, six ", suffixes : [ [ "one", "two", "three" ], [ "four", "five", "six" ] ], operands: [ { text:"operand" } ] } ] } ]
+		);
+		expect($tw.wiki.parseFilter("[search: , : [operand]]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "search", suffix : " , : ", suffixes : [ [  ], [  ] ], operands: [ { text:"operand" } ] } ] } ]
+		);
+	});
 		
 		
-		it("should parse multiple operands for operators", function() {
-			expect($tw.wiki.parseFilter("[search: , : [operand],[operand2]]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'search', suffix : ' , : ', suffixes : [ [  ], [  ] ], operands: [ { text:'operand' }, { text:'operand2' } ] } ] } ]
-			);
-			expect($tw.wiki.parseFilter("[search: , : [oper,and],[operand2]]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'search', suffix : ' , : ', suffixes : [ [  ], [  ] ], operands: [ { text:'oper,and' }, { text:'operand2' } ] } ] } ]
-			);
-			expect($tw.wiki.parseFilter("[[GettingStarted]replace:[operand],[operand2]]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'title', operands: [ { text:'GettingStarted' } ] },  { operator : 'replace', suffix : '', suffixes : [[]], operands: [ { text:'operand' }, { text:'operand2' }  ] } ] } ]
-			);
-			expect($tw.wiki.parseFilter("[[GettingStarted]replace[operand],[operand2]split[-]]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'title', operands: [{ text:'GettingStarted' }] },  { operator : 'replace', operands: [{ text:'operand' }, { text:'operand2' }] }, { operator : 'split', operands: [ { text:'-' } ] } ] } ]
-			);
-			expect($tw.wiki.parseFilter("[[GettingStarted]replace[operand],[operand2]split[-]split2[a],[b]]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'title', operands: [{ text:'GettingStarted' }] },  { operator : 'replace',  operands: [ { text:'operand' }, { text:'operand2' } ] }, { operator : 'split', operands: [ {text:'-'} ] }, { operator : 'split2', operands: [ { text:'a' }, { text: 'b' }] } ] } ]
-			);
-			expect($tw.wiki.parseFilter("[[GettingStarted]replace[operand],[operand2]split[-]split2[a],<b>,{c}]")).toEqual(
-				[ { prefix : '', operators : [ { operator : 'title', operands: [{ text:'GettingStarted' }] },  { operator : 'replace',  operands: [ { text:'operand' }, { text:'operand2' } ] }, { operator : 'split', operands: [ {text:'-'} ] }, { operator : 'split2', operands: [ { text:'a' }, { variable: true, text: 'b' }, { indirect: true, text: 'c' }] } ] } ]
-			);
-		});
+	it("should parse multiple operands for operators", function() {
+		expect($tw.wiki.parseFilter("[search: , : [operand],[operand2]]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "search", suffix : " , : ", suffixes : [ [  ], [  ] ], operands: [ { text:"operand" }, { text:"operand2" } ] } ] } ]
+		);
+		expect($tw.wiki.parseFilter("[search: , : [oper,and],[operand2]]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "search", suffix : " , : ", suffixes : [ [  ], [  ] ], operands: [ { text:"oper,and" }, { text:"operand2" } ] } ] } ]
+		);
+		expect($tw.wiki.parseFilter("[[GettingStarted]replace:[operand],[operand2]]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "title", operands: [ { text:"GettingStarted" } ] },  { operator : "replace", suffix : "", suffixes : [[]], operands: [ { text:"operand" }, { text:"operand2" }  ] } ] } ]
+		);
+		expect($tw.wiki.parseFilter("[[GettingStarted]replace[operand],[operand2]split[-]]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "title", operands: [{ text:"GettingStarted" }] },  { operator : "replace", operands: [{ text:"operand" }, { text:"operand2" }] }, { operator : "split", operands: [ { text:"-" } ] } ] } ]
+		);
+		expect($tw.wiki.parseFilter("[[GettingStarted]replace[operand],[operand2]split[-]split2[a],[b]]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "title", operands: [{ text:"GettingStarted" }] },  { operator : "replace",  operands: [ { text:"operand" }, { text:"operand2" } ] }, { operator : "split", operands: [ {text:"-"} ] }, { operator : "split2", operands: [ { text:"a" }, { text: "b" }] } ] } ]
+		);
+		expect($tw.wiki.parseFilter("[[GettingStarted]replace[operand],[operand2]split[-]split2[a],<b>,{c}]")).toEqual(
+			[ { prefix : "", operators : [ { operator : "title", operands: [{ text:"GettingStarted" }] },  { operator : "replace",  operands: [ { text:"operand" }, { text:"operand2" } ] }, { operator : "split", operands: [ {text:"-"} ] }, { operator : "split2", operands: [ { text:"a" }, { variable: true, text: "b" }, { indirect: true, text: "c" }] } ] } ]
+		);
+	});
 	
-		describe("With tiddlers in the store unsorted",function() {
-			testWithAndWithoutIndexers();
-		});
-		describe("With tiddlers in the store sorted ascending",function() {
-			testWithAndWithoutIndexers({sort: "ascending"});
-		});
-		describe("With tiddlers in the store sorted descending",function() {
-			testWithAndWithoutIndexers({sort: "descending"});
-		});
+	describe("With tiddlers in the store unsorted",function() {
+		testWithAndWithoutIndexers();
+	});
+	describe("With tiddlers in the store sorted ascending",function() {
+		testWithAndWithoutIndexers({sort: "ascending"});
+	});
+	describe("With tiddlers in the store sorted descending",function() {
+		testWithAndWithoutIndexers({sort: "descending"});
+	});
 
 	function testWithAndWithoutIndexers(options) {
 		describe("With no indexers", function() {
@@ -289,7 +289,7 @@ Tests the filtering mechanism.
 		// The following 2 tests should write a log -> WARNING: Filter modifier has a deprecated regexp operand XXXX
 		// The test should pass anyway.
 		it("should handle the field operator with a regular expression operand", function() {
-			spyOn(console, 'log');
+			spyOn(console, "log");
 			expect(wiki.filterTiddlers("[modifier/JoeBloggs/]").join(",")).toBe("TiddlerOne");
 			expect(console.log).toHaveBeenCalledWith("WARNING: Filter", "modifier", "has a deprecated regexp operand", /JoeBloggs/);
 			console.log.calls.reset();
@@ -298,7 +298,7 @@ Tests the filtering mechanism.
 		});
 
 		it("should handle regular expression operands without crashing", function() {
-			spyOn(console, 'log');
+			spyOn(console, "log");
 			// We don't really care about the results. Just don't get RSoD.
 			expect(() => wiki.filterTiddlers("[all/current/]")).not.toThrow();
 			expect(() => wiki.filterTiddlers("[prefix/anything/]")).not.toThrow();
@@ -333,7 +333,7 @@ Tests the filtering mechanism.
 		it("should handle the removesuffix operator", function() {
 			expect(wiki.filterTiddlers("[enlist[ABCDE abcde]removesuffix[DE]]").join(",")).toBe("ABC");
 			expect(wiki.filterTiddlers("[enlist[ABCDE abcde]removesuffix:casesensitive[DE]]").join(",")).toBe("ABC");
-			expect(wiki.filterTiddlers("[enlist[ABCDE abcde]removesuffix:caseinsensitive[de]]").join(",")).toBe("ABC,abc")
+			expect(wiki.filterTiddlers("[enlist[ABCDE abcde]removesuffix:caseinsensitive[de]]").join(",")).toBe("ABC,abc");
 			expect(wiki.filterTiddlers("[enlist[ABCDE abcde]removesuffix[]]").join(",")).toBe("ABCDE,abcde");
 		});
 	
@@ -465,8 +465,8 @@ Tests the filtering mechanism.
 		});
 
 		it("should handle the listed operator", function() {
-			expect(wiki.filterTiddlers("TiddlerOne MissingTiddler +[listed[]]").join(",")).toBe('hasList,one');
-			expect(wiki.filterTiddlers("one two +[listed[tags]]").join(",")).toBe('TiddlerOne,$:/TiddlerTwo,Tiddler Three');
+			expect(wiki.filterTiddlers("TiddlerOne MissingTiddler +[listed[]]").join(",")).toBe("hasList,one");
+			expect(wiki.filterTiddlers("one two +[listed[tags]]").join(",")).toBe("TiddlerOne,$:/TiddlerTwo,Tiddler Three");
 		});
 	
 		it("should handle the next operator", function() {
@@ -521,7 +521,7 @@ Tests the filtering mechanism.
 		});
 
 		it("should yield search results where 'tags' finds at least one token / anchored & casesensitive", function() {
-				expect(wiki.filterTiddlers("[search:title:some,anchored,casesensitive[Tiddler one]sort[title]]").join(",")).toBe("one,Tiddler Three,TiddlerOne");
+			expect(wiki.filterTiddlers("[search:title:some,anchored,casesensitive[Tiddler one]sort[title]]").join(",")).toBe("one,Tiddler Three,TiddlerOne");
 			expect(wiki.filterTiddlers("[search:title:some,anchored,casesensitive[Tiddler ONE]sort[title]]").join(",")).toBe("Tiddler Three,TiddlerOne");
 		});
 
@@ -546,7 +546,7 @@ Tests the filtering mechanism.
 		describe("testing the is operator",function() {
 	
 			it("should handle the '[is[current]]' operator", function() {
-			var fakeWidget = {getVariable: function() {return "Tiddler Three";}};
+				var fakeWidget = {getVariable: function() {return "Tiddler Three";}};
 				expect(wiki.filterTiddlers("[is[current]]",fakeWidget).join(",")).toBe("Tiddler Three");
 				expect(wiki.filterTiddlers("[[Tiddler Three]is[current]]",fakeWidget).join(",")).toBe("Tiddler Three");
 				expect(wiki.filterTiddlers("[[$:/TiddlerTwo]is[current]]",fakeWidget).join(",")).toBe("");
@@ -583,7 +583,7 @@ Tests the filtering mechanism.
 			});
 
 			it("should handle the '[is[draft]]' operator", function() {
-				var wiki = new $tw.Wiki();
+				var wiki = $tw.test.wiki();
 				wiki.addTiddlers([
 					{title: "A"},
 					{title: "Draft of 'A'", "draft.of": "A", "draft.title": "A"},
@@ -603,8 +603,8 @@ Tests the filtering mechanism.
 				expect(wiki.filterTiddlers("[all[]] F +[is[draft]]").join(",")).toEqual("Draft of 'A',Draft of 'B',Draft of 'E'");
 				expect(wiki.filterTiddlers("[all[]] F +[!is[draft]]").join(",")).toEqual("A,B,C,Draft of 'C',E,F");
 				// [is[draft]] and [!is[draft]] are proper complements
-				var included = wiki.filterTiddlers("[all[]] F +[is[draft]]")
-				var excluded = wiki.filterTiddlers("[all[]] F +[!is[draft]]")
+				var included = wiki.filterTiddlers("[all[]] F +[is[draft]]");
+				var excluded = wiki.filterTiddlers("[all[]] F +[!is[draft]]");
 				var all = [].concat(included, excluded).sort();
 				// combined, they should have exactly one of everything.
 				expect(wiki.filterTiddlers("[all[]] F +[sort[]]")).toEqual(all);
@@ -628,9 +628,9 @@ Tests the filtering mechanism.
 		it("should handle variable operands", function() {
 	
 			var widget = require("$:/core/modules/widgets/widget.js");
-		// Create a root widget for attaching event handlers. By using it as the parentWidget for another widget tree, one can reuse the event handlers
+			// Create a root widget for attaching event handlers. By using it as the parentWidget for another widget tree, one can reuse the event handlers
 			var rootWidget = new widget.widget({ type:"widget", children:[ {type:"widget", children:[]} ] },
-											   { wiki:wiki, document:$tw.document});
+				{ wiki:wiki, document:$tw.document});
 			rootWidget.makeChildWidgets();
 			var anchorWidget = rootWidget.children[0];
 			rootWidget.setVariable("myVar","Tidd");
@@ -703,7 +703,7 @@ Tests the filtering mechanism.
 			expect(wiki.filterTiddlers("1 2 3 4 +[min[2]]").join(",")).toBe("1,2,2,2");
 		});
 	
-	/* listops filters */
+		/* listops filters */
 		
 		it("should handle the allafter operator", function() {
 			expect(wiki.filterTiddlers("1 2 3 4 +[allafter[]]").join(",")).toBe("");
@@ -747,7 +747,7 @@ Tests the filtering mechanism.
 		it("should handle the insertafter operator", function() {
 			var widget = require("$:/core/modules/widgets/widget.js");
 			var rootWidget = new widget.widget({ type:"widget", children:[ {type:"widget", children:[]} ] },
-											   { wiki:wiki, document:$tw.document});
+				{ wiki:wiki, document:$tw.document});
 			rootWidget.makeChildWidgets();
 			var anchorWidget = rootWidget.children[0];
 			rootWidget.setVariable("myVar","c");
@@ -786,7 +786,7 @@ Tests the filtering mechanism.
 		it("should handle the insertbefore operator", function() {
 			var widget = require("$:/core/modules/widgets/widget.js");
 			var rootWidget = new widget.widget({ type:"widget", children:[ {type:"widget", children:[]} ] },
-											   { wiki:wiki, document:$tw.document});
+				{ wiki:wiki, document:$tw.document});
 			rootWidget.makeChildWidgets();
 			var anchorWidget = rootWidget.children[0];
 			rootWidget.setVariable("myVar","c");
@@ -972,7 +972,7 @@ Tests the filtering mechanism.
 		it("should handle the sortsub operator", function() {
 			var widget = require("$:/core/modules/widgets/widget.js");
 			var rootWidget = new widget.widget({ type:"widget", children:[ {type:"widget", children:[]} ] },
-											   { wiki:wiki, document:$tw.document});
+				{ wiki:wiki, document:$tw.document});
 			rootWidget.makeChildWidgets();
 			var anchorWidget = rootWidget.children[0];
 			rootWidget.setVariable("sort1","[length[]]");
@@ -1008,7 +1008,7 @@ Tests the filtering mechanism.
 		it("should handle multiple operands for search-replace", function() {
 			var widget = require("$:/core/modules/widgets/widget.js");
 			var rootWidget = new widget.widget({ type:"widget", children:[ {type:"widget", children:[]} ] },
-											   { wiki:wiki, document:$tw.document});
+				{ wiki:wiki, document:$tw.document});
 			rootWidget.makeChildWidgets();
 			var anchorWidget = rootWidget.children[0];
 			rootWidget.setVariable("var1","different");
@@ -1032,24 +1032,24 @@ Tests the filtering mechanism.
 		});
 		
 		it("should handle the pad operator", function() {
-		expect(wiki.filterTiddlers("[[2]pad[]]").join(",")).toBe("2");
-		expect(wiki.filterTiddlers("[[2]pad[0]]").join(",")).toBe("2");
-		expect(wiki.filterTiddlers("[[2]pad[1]]").join(",")).toBe("2");
-		expect(wiki.filterTiddlers("2 20 +[pad[3]]").join(",")).toBe("002,020");
-		expect(wiki.filterTiddlers("[[2]pad[9]]").join(",")).toBe("000000002");
-		expect(wiki.filterTiddlers("[[2]pad[9],[a]]").join(",")).toBe("aaaaaaaa2");
-		expect(wiki.filterTiddlers("[[12]pad[9],[abc]]").join(",")).toBe("abcabca12");
-		expect(wiki.filterTiddlers("[[12]pad:suffix[9],[abc]]").join(",")).toBe("12abcabca");
+			expect(wiki.filterTiddlers("[[2]pad[]]").join(",")).toBe("2");
+			expect(wiki.filterTiddlers("[[2]pad[0]]").join(",")).toBe("2");
+			expect(wiki.filterTiddlers("[[2]pad[1]]").join(",")).toBe("2");
+			expect(wiki.filterTiddlers("2 20 +[pad[3]]").join(",")).toBe("002,020");
+			expect(wiki.filterTiddlers("[[2]pad[9]]").join(",")).toBe("000000002");
+			expect(wiki.filterTiddlers("[[2]pad[9],[a]]").join(",")).toBe("aaaaaaaa2");
+			expect(wiki.filterTiddlers("[[12]pad[9],[abc]]").join(",")).toBe("abcabca12");
+			expect(wiki.filterTiddlers("[[12]pad:suffix[9],[abc]]").join(",")).toBe("12abcabca");
 		});
 	
 		it("should handle the escapecss operator", function() {
-		expect(wiki.filterTiddlers("[[Hello There]escapecss[]]").join(",")).toBe("Hello\\ There");
-		expect(wiki.filterTiddlers('\'"Reveal.js" by Devin Weaver[1]\' +[escapecss[]]').join(",")).toBe('\\"Reveal\\.js\\"\\ by\\ Devin\\ Weaver\\[1\\]');
-		expect(wiki.filterTiddlers(".foo#bar (){} '--a' 0 \0 +[escapecss[]]").join(",")).toBe("\\.foo\\#bar,\\(\\)\\{\\},--a,\\30 ,\ufffd");
-		expect(wiki.filterTiddlers("'' +[escapecss[]]").join(",")).toBe("");
-		expect(wiki.filterTiddlers("1234 +[escapecss[]]").join(",")).toBe("\\31 234");
-		expect(wiki.filterTiddlers("'-25' +[escapecss[]]").join(",")).toBe("-\\32 5");
-		expect(wiki.filterTiddlers("'-' +[escapecss[]]").join(",")).toBe("\\-");
+			expect(wiki.filterTiddlers("[[Hello There]escapecss[]]").join(",")).toBe("Hello\\ There");
+			expect(wiki.filterTiddlers('\'"Reveal.js" by Devin Weaver[1]\' +[escapecss[]]').join(",")).toBe('\\"Reveal\\.js\\"\\ by\\ Devin\\ Weaver\\[1\\]');
+			expect(wiki.filterTiddlers(".foo#bar (){} '--a' 0 \0 +[escapecss[]]").join(",")).toBe("\\.foo\\#bar,\\(\\)\\{\\},--a,\\30 ,\ufffd");
+			expect(wiki.filterTiddlers("'' +[escapecss[]]").join(",")).toBe("");
+			expect(wiki.filterTiddlers("1234 +[escapecss[]]").join(",")).toBe("\\31 234");
+			expect(wiki.filterTiddlers("'-25' +[escapecss[]]").join(",")).toBe("-\\32 5");
+			expect(wiki.filterTiddlers("'-' +[escapecss[]]").join(",")).toBe("\\-");
 		});
 		
 		it("should handle the format operator", function() {
@@ -1062,11 +1062,11 @@ Tests the filtering mechanism.
 		});
 	
 		it("should handle the deserializers operator", function() {
-		var expectedDeserializers = ["application/javascript","application/json","application/x-tiddler","application/x-tiddler-html-div","application/x-tiddlers","text/css","text/html","text/plain"];
-		if($tw.browser) {
-			expectedDeserializers.unshift("(DOM)");
-		}
-		expect(wiki.filterTiddlers("[deserializers[]]").join(",")).toBe(expectedDeserializers.join(","));
+			var expectedDeserializers = ["application/javascript","application/json","application/x-tiddler","application/x-tiddler-html-div","application/x-tiddlers","text/css","text/html","text/plain"];
+			if($tw.browser) {
+				expectedDeserializers.unshift("(DOM)");
+			}
+			expect(wiki.filterTiddlers("[deserializers[]]").join(",")).toBe(expectedDeserializers.join(","));
 		});
 		
 		it("should handle the charcode operator", function() {
@@ -1090,39 +1090,39 @@ Tests the filtering mechanism.
 		});
 	
 		it("should parse filter variable parameters", function(){
-		  expect($tw.utils.parseFilterVariable("currentTiddler")).toEqual(
-			{ name: 'currentTiddler', params: [  ] }
-		  );
-		  expect($tw.utils.parseFilterVariable("now DDMM")).toEqual(
-			{ name: 'now', params: [{ type: 'macro-parameter', start: 3, value: 'DDMM', end: 8 }] }
-		  );
-		  expect($tw.utils.parseFilterVariable("now DDMM UTC")).toEqual(
-			{ name: 'now', params: [{ type: 'macro-parameter', start: 3, value: 'DDMM', end: 8 }, { type: 'macro-parameter', start: 8, value: 'UTC', end: 12 }] }
-		  );
-		  expect($tw.utils.parseFilterVariable("now format:DDMM")).toEqual(
-			{ name: 'now', params: [{ type: 'macro-parameter', name:'format', start: 3, value: 'DDMM', end: 15 }] }	  	
-		  );
-		  expect($tw.utils.parseFilterVariable("now format:'DDMM'")).toEqual(
-			{ name: 'now', params: [{ type: 'macro-parameter', name:'format', start: 3, value: 'DDMM', end: 17 }] }	  	
-		  );
-		  expect($tw.utils.parseFilterVariable("nowformat:'DDMM'")).toEqual(
-			{ name: 'nowformat:\'DDMM\'', params: [] }
-		  );
-		  expect($tw.utils.parseFilterVariable("nowformat:'DD MM'")).toEqual(
-			{ name: 'nowformat:', params: [{ type: 'macro-parameter', start: 10, value: 'DD MM', end: 17 }] }
-		  );
-		  expect($tw.utils.parseFilterVariable("now [UTC]YYYY0MM0DD0hh0mm0ssXXX")).toEqual(
-			{ name: 'now', params: [{ type: 'macro-parameter', start: 3, value: '[UTC]YYYY0MM0DD0hh0mm0ssXXX', end: 31 }] }
-		  );
-		  expect($tw.utils.parseFilterVariable("now '[UTC]YYYY0MM0DD0hh0mm0ssXXX'")).toEqual(
-			{ name: 'now', params: [{ type: 'macro-parameter', start: 3, value: '[UTC]YYYY0MM0DD0hh0mm0ssXXX', end: 33 }] }
-		  );
-		  expect($tw.utils.parseFilterVariable("now format:'[UTC]YYYY0MM0DD0hh0mm0ssXXX'")).toEqual(
-			{ name: 'now', params: [{ type: 'macro-parameter', start: 3, name:'format', value: '[UTC]YYYY0MM0DD0hh0mm0ssXXX', end: 40 }] }
-		  );
-		  expect($tw.utils.parseFilterVariable("")).toEqual(
-			{ name: '', params: [] }
-		  );
+			expect($tw.utils.parseFilterVariable("currentTiddler")).toEqual(
+				{ name: "currentTiddler", params: [  ] }
+			);
+			expect($tw.utils.parseFilterVariable("now DDMM")).toEqual(
+				{ name: "now", params: [{ type: "macro-parameter", start: 3, value: "DDMM", end: 8 }] }
+			);
+			expect($tw.utils.parseFilterVariable("now DDMM UTC")).toEqual(
+				{ name: "now", params: [{ type: "macro-parameter", start: 3, value: "DDMM", end: 8 }, { type: "macro-parameter", start: 8, value: "UTC", end: 12 }] }
+			);
+			expect($tw.utils.parseFilterVariable("now format:DDMM")).toEqual(
+				{ name: "now", params: [{ type: "macro-parameter", name:"format", start: 3, value: "DDMM", end: 15 }] }	  	
+			);
+			expect($tw.utils.parseFilterVariable("now format:'DDMM'")).toEqual(
+				{ name: "now", params: [{ type: "macro-parameter", name:"format", start: 3, value: "DDMM", end: 17 }] }	  	
+			);
+			expect($tw.utils.parseFilterVariable("nowformat:'DDMM'")).toEqual(
+				{ name: "nowformat:'DDMM'", params: [] }
+			);
+			expect($tw.utils.parseFilterVariable("nowformat:'DD MM'")).toEqual(
+				{ name: "nowformat:", params: [{ type: "macro-parameter", start: 10, value: "DD MM", end: 17 }] }
+			);
+			expect($tw.utils.parseFilterVariable("now [UTC]YYYY0MM0DD0hh0mm0ssXXX")).toEqual(
+				{ name: "now", params: [{ type: "macro-parameter", start: 3, value: "[UTC]YYYY0MM0DD0hh0mm0ssXXX", end: 31 }] }
+			);
+			expect($tw.utils.parseFilterVariable("now '[UTC]YYYY0MM0DD0hh0mm0ssXXX'")).toEqual(
+				{ name: "now", params: [{ type: "macro-parameter", start: 3, value: "[UTC]YYYY0MM0DD0hh0mm0ssXXX", end: 33 }] }
+			);
+			expect($tw.utils.parseFilterVariable("now format:'[UTC]YYYY0MM0DD0hh0mm0ssXXX'")).toEqual(
+				{ name: "now", params: [{ type: "macro-parameter", start: 3, name:"format", value: "[UTC]YYYY0MM0DD0hh0mm0ssXXX", end: 40 }] }
+			);
+			expect($tw.utils.parseFilterVariable("")).toEqual(
+				{ name: "", params: [] }
+			);
 		});
 		
 		it("should handle the encodeuricomponent and decodeuricomponent operators", function() {
@@ -1137,7 +1137,7 @@ Tests the filtering mechanism.
 			// No such tiddlers. Nothing to return.
 			expect(wiki.filterTiddlers("[[nonexistent]moduleproperty[name]]").length).toBe(0);
 			// Non string properties should get toStringed.
-			expect(wiki.filterTiddlers("[[$:/core/modules/commands/init.js]moduleproperty[info]]").join(" ")).toBe('{"name":"init","synchronous":true}');
+			expect(wiki.filterTiddlers("[[$:/core/modules/startup.js]moduleproperty[synchronous]]").join(" ")).toBe("true");
 		});
 
 		it("should minimize unnecessary variable lookup", function() {
@@ -1150,5 +1150,5 @@ Tests the filtering mechanism.
 		});
 	}
 	
-	});
+});