tiddlywiki 5.3.8 → 5.4.1

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

@@ -7,16 +7,13 @@ Tests the JSON filters and the format:json operator
 
 \*/
 
-
-/* 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("json filter tests", function() {
 
-	var wiki = new $tw.Wiki();
+	var wiki = $tw.test.wiki();
 	var tiddlers = [{
 		title: "First",
 		text: '{"a":"one","b":"","c":1.618,"d": {"e": "four","f": ["five","six",true,false,null]}}',
@@ -127,7 +124,7 @@ describe("json filter tests", function() {
 		expect(wiki.filterTiddlers("[jsonset[a],[aa]]")).toEqual(['"First"','"Second"','"Third"']);
 		expect(wiki.filterTiddlers("[{First}jsonset[]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
 		expect(wiki.filterTiddlers("[{First}jsonset[],[Antelope]]")).toEqual(['"Antelope"']);
-		expect(wiki.filterTiddlers("[{First}jsonset:number[],[not a number]]")).toEqual(['0']);
+		expect(wiki.filterTiddlers("[{First}jsonset:number[],[not a number]]")).toEqual(["0"]);
 		expect(wiki.filterTiddlers("[{First}jsonset[id],[Antelope]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]},"id":"Antelope"}']);
 		expect(wiki.filterTiddlers("[{First}jsonset:notatype[id],[Antelope]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]},"id":"Antelope"}']);
 		expect(wiki.filterTiddlers("[{First}jsonset:boolean[id],[false]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]},"id":false}']);
@@ -143,6 +140,33 @@ describe("json filter tests", function() {
 		expect(wiki.filterTiddlers("[{First}jsonset:json[notjson]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
 	});
 
+	it("should support the jsondelete operator", function() {
+		// Delete top-level object property
+		expect(wiki.filterTiddlers("[{First}jsondelete[a]]")).toEqual(['{"b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[b]]")).toEqual(['{"a":"one","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[c]]")).toEqual(['{"a":"one","b":"","d":{"e":"four","f":["five","six",true,false,null]}}']);
+		// Delete nested object property
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[e]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"f":["five","six",true,false,null]}}']);
+		// Delete array element
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[f],[0]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["six",true,false,null]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[f],[1]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five",true,false,null]}}']);
+		// Delete using negative array index
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[f],[-1]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[f],[-2]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,null]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[f],[-5]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["six",true,false,null]}}']);
+		// Delete from array
+		expect(wiki.filterTiddlers("[{Second}jsondelete[0]]")).toEqual(['["deux","trois",["quatre","cinq"]]']);
+		expect(wiki.filterTiddlers("[{Second}jsondelete[1]]")).toEqual(['["une","trois",["quatre","cinq"]]']);
+		expect(wiki.filterTiddlers("[{Second}jsondelete[-1]]")).toEqual(['["une","deux","trois"]']);
+		// Attempting to delete non-existent property should return unchanged
+		expect(wiki.filterTiddlers("[{First}jsondelete[missing-property]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
+		expect(wiki.filterTiddlers("[{First}jsondelete[d],[missing]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
+		// Attempting to delete root should return unchanged
+		expect(wiki.filterTiddlers("[{First}jsondelete[]]")).toEqual(['{"a":"one","b":"","c":1.618,"d":{"e":"four","f":["five","six",true,false,null]}}']);
+		// Non-JSON input should return unchanged
+		expect(wiki.filterTiddlers("[{Third}jsondelete[a]]")).toEqual(["This is not JSON"]);
+	});
+
 	it("should support the format:json operator", function() {
 		expect(wiki.filterTiddlers("[{First}format:json[]]")).toEqual(["{\"a\":\"one\",\"b\":\"\",\"c\":1.618,\"d\":{\"e\":\"four\",\"f\":[\"five\",\"six\",true,false,null]}}"]);
 		expect(wiki.filterTiddlers("[{First}format:json[4]]")).toEqual(["{\n    \"a\": \"one\",\n    \"b\": \"\",\n    \"c\": 1.618,\n    \"d\": {\n        \"e\": \"four\",\n        \"f\": [\n            \"five\",\n            \"six\",\n            true,\n            false,\n            null\n        ]\n    }\n}"]);

package/editions/test/tiddlers/tests/test-linked-list.js

@@ -29,7 +29,7 @@ describe("LinkedList class tests", function() {
 	// creates and initializes a new {array, list} pair for testing
 	function newPair(initialArray) {
 		var pair = {array: [], list: new $tw.utils.LinkedList()};
-		if (initialArray) {
+		if(initialArray) {
 			push(pair, initialArray);
 		}
 		return pair;
@@ -126,7 +126,7 @@ describe("LinkedList class tests", function() {
 		compare(pushTop(remove(newPair(["A", "A"]), ["A", "A"]), ["B", "A"])); // BA
 
 		// Again, but this time with other values mixed in
-		compare(remove(newPair(["B", "A", "A", "C"]), ["A", "A"])) // BC;
+		compare(remove(newPair(["B", "A", "A", "C"]), ["A", "A"])); // BC;
 		// And again, but this time with value inbetween too.
 		compare(remove(newPair(["B", "A", "X", "Y", "Z", "A", "C"]), ["A", "A"])); // BXYZC
 
@@ -195,10 +195,10 @@ describe("LinkedList class tests", function() {
 		// This actually caused an infinite loop once. So important test here.
 		push(pair, ["A"]);
 		compare(pair); // XYCAA
-		pushTop(pair, "A") // switch those last As
+		pushTop(pair, "A"); // switch those last As
 		compare(pair); // XYCAA
 		remove(pair, ["A", "A"]); // Remove all As, then add them back
-		pushTop(pair, ["A", "A"])
+		pushTop(pair, ["A", "A"]);
 		compare(pair); // XYCAA
 	});
 

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

@@ -12,7 +12,7 @@ Tests for source attribute in parser returned from wiki.parseTextReference
 describe("Wiki.parseTextReference tests", function() {
 
 	// Create a wiki
-	var wiki = new $tw.Wiki();
+	var wiki = $tw.test.wiki();
 	wiki.addTiddler({
 		title: "TiddlerOne",
 		text: "The quick brown fox in $:/TiddlerTwo",

package/editions/test/tiddlers/tests/test-parsetree-positions.js

@@ -0,0 +1,60 @@
+/*\
+title: test-parsetree-positions.js
+type: application/javascript
+tags: [[$:/tags/test-spec]]
+
+Regression tests for #9882: wikitext parser rules must emit accurate
+`start`/`end` source positions on their parse tree nodes. Tooling that maps
+rendered output back to the source text relies on these offsets.
+
+\*/
+
+"use strict";
+
+describe("Parse tree source position tests (#9882)", function() {
+
+	// Create a wiki
+	var wiki = $tw.test.wiki();
+
+	// Define a parsing shortcut
+	var parse = function(text) {
+		return wiki.parseText("text/vnd.tiddlywiki",text).tree;
+	};
+
+	it("should give inline code runs a text node that spans only the code, not the backticks", function() {
+		// codeinline.js: `code` gives a text node "code" spanning offsets 1 to 5. The closing backtick at 5 is excluded.
+		// Bug: `end` was set to `this.parser.pos`, which sits past the closing backtick, so end was 6 and the span swallowed the backtick.
+		expect(parse("`code`")).toEqual(
+			[ { type: "element", tag: "p", rule: "parseblock", start: 0, end: 6, children: [ { type: "element", tag: "code", rule: "codeinline", start: 0, end: 6, children: [ { type: "text", text: "code", start: 1, end: 5 } ] } ] } ]
+		);
+		// ``a`b`` gives text "a`b" spanning 2 to 5. `end` must be the offset of the closing marker whatever its length.
+		// Bug: `end` was `this.parser.pos` (7), two characters past the code, so it also swallowed the closing ``.
+		expect(parse("``a`b``")).toEqual(
+			[ { type: "element", tag: "p", rule: "parseblock", start: 0, end: 7, children: [ { type: "element", tag: "code", rule: "codeinline", start: 0, end: 7, children: [ { type: "text", text: "a`b", start: 2, end: 5 } ] } ] } ]
+		);
+	});
+
+	it("should start the text node of a suppressed external link after the ~", function() {
+		// extlink.js: ~https://example.com/ emits the plain text "https://example.com/", which spans offsets 1 to 21.
+		// Bug: `start` was the offset of the ~ (0), so the span was one character too wide and began on the ~ that the text omits.
+		expect(parse("~https://example.com/")).toEqual(
+			[ { type: "element", tag: "p", rule: "parseblock", start: 0, end: 21, children: [ { type: "text", text: "https://example.com/", start: 1, end: 21, rule: "extlink" } ] } ]
+		);
+	});
+
+	it("should give a suppressed wikilink's text node source positions", function() {
+		// wikilinkprefix.js: ~SuppressedLink emits the plain text "SuppressedLink", spanning offsets 1 to 15.
+		// Bug: the text node carried no `start`/`end` at all. The parser framework then defaulted `start` to the ~ offset (0).
+		expect(parse("~SuppressedLink")).toEqual(
+			[ { type: "element", tag: "p", rule: "parseblock", start: 0, end: 15, children: [ { type: "text", text: "SuppressedLink", start: 1, end: 15, rule: "wikilinkprefix" } ] } ]
+		);
+	});
+
+	it("should record the filter's start offset for an \\import pragma", function() {
+		// import.js: \import [tag[x]] records the filter value "[tag[x]]" starting at offset 8, right after "\import ".
+		// Bug: `filterStart` was assigned `this.parser.source` (the whole source string) instead of `this.parser.pos`, so `start` was a string, not an offset.
+		expect(parse("\\import [tag[x]]\n")).toEqual(
+			[ { type: "importvariables", rule: "import", start: 0, end: 16, attributes: { filter: { type: "string", value: "[tag[x]]", start: 8, end: 16 } }, children: [] } ]
+		);
+	});
+});

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

@@ -14,7 +14,7 @@ Tests the reduce prefix and filter.
 
 describe("general filter prefix tests", function() {
 	it("should handle nonexistent prefixes gracefully", function() {
-		var wiki = new $tw.Wiki();
+		var wiki = $tw.test.wiki();
 		var results = wiki.filterTiddlers("[tag[A]] :nonexistent[tag[B]]");
 		expect(results).toEqual(["Filter Error: Unknown prefix for filter run"]);
 	});
@@ -215,7 +215,7 @@ describe("general filter prefix tests", function() {
 
 describe("'reduce' and 'intersection' filter prefix tests", function() {
 
-	var wiki = new $tw.Wiki();
+	var wiki = $tw.test.wiki();
 
 	wiki.addTiddler({
 		title: "Brownies",
@@ -337,7 +337,7 @@ describe("'reduce' and 'intersection' filter prefix tests", function() {
 	it("should handle the reduce 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("add-price","[get[price]multiply{!!quantity}add<accumulator>]");
@@ -372,13 +372,13 @@ describe("'reduce' and 'intersection' filter prefix tests", function() {
 	it("should handle the variance operator", function() {
 		expect(parseFloat(wiki.filterTiddlers("[tag[shopping]get[price]variance[]]").join(","))).toBeCloseTo(2.92);
 		expect(parseFloat(wiki.filterTiddlers("[tag[food]get[price]variance[]]").join(","))).toBeCloseTo(3.367);
-		expect(wiki.filterTiddlers(" +[variance[]]").toString()).toBe("NaN");
+		expect(wiki.filterTiddlers(" +[variance[]]").toString()).toBe("");
 	});
 
 	it("should handle the standard-deviation operator", function() {
 		expect(parseFloat(wiki.filterTiddlers("[tag[shopping]get[price]standard-deviation[]]").join(","))).toBeCloseTo(1.71);
 		expect(parseFloat(wiki.filterTiddlers("[tag[food]get[price]standard-deviation[]]").join(","))).toBeCloseTo(1.835);
-		expect(wiki.filterTiddlers(" +[standard-deviation[]]").toString()).toBe("NaN");
+		expect(wiki.filterTiddlers(" +[standard-deviation[]]").toString()).toBe("");
 	});	
 
 	it("should handle the :intersection prefix", function() {
@@ -392,7 +392,7 @@ describe("'reduce' and 'intersection' filter prefix tests", function() {
 	it("should handle the :filter prefix and filter 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("larger-than-18","[get[text]length[]compare:integer:gteq[18]]");
@@ -420,6 +420,8 @@ describe("'reduce' and 'intersection' filter prefix tests", function() {
 		expect(wiki.filterTiddlers("[tag[cakes]] :sort:string[{!!title}]").join(",")).toBe("cheesecake,Cheesecake,chocolate cake,Chocolate Cake,Persian love cake,Pound cake");
 		expect(wiki.filterTiddlers("[tag[cakes]] :sort:string:casesensitive[{!!title}]").join(",")).toBe("Cheesecake,Chocolate Cake,Persian love cake,Pound cake,cheesecake,chocolate cake");
 		expect(wiki.filterTiddlers("[tag[cakes]] :sort:string:casesensitive,reverse[{!!title}]").join(",")).toBe("chocolate cake,cheesecake,Pound cake,Persian love cake,Chocolate Cake,Cheesecake");
+		expect(wiki.filterTiddlers("1.2.0 1.0.0 1.0.5 :sort:version[{!!title}]").join(",")).toBe("1.0.0,1.0.5,1.2.0");
+		expect(wiki.filterTiddlers("1.2.0 1.0.0 1.0.5 :sort:version:reverse[{!!title}]").join(",")).toBe("1.2.0,1.0.5,1.0.0");
 	});
 
 	it("should handle the :map prefix", function() {
@@ -446,7 +448,7 @@ describe("'reduce' and 'intersection' filter prefix tests", function() {
 	it("should handle macro parameters for filter run prefixes",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("greet","Hello $name$",[{name:"name"}],true);

package/editions/test/tiddlers/tests/test-select-widget.js

@@ -0,0 +1,144 @@
+/*\
+title: test-select-widget.js
+type: application/javascript
+tags: [[$:/tags/test-spec]]
+
+Tests the select widget, focused on multi-select refresh behaviour.
+
+\*/
+
+"use strict";
+
+describe("Select widget", function() {
+
+	var widget = require("$:/core/modules/widgets/widget.js");
+
+	// Helpers reused from: test-widget.js and  test-checkbox-widget.js
+	function createWidgetNode(parseTreeNode,wiki) {
+		return new widget.widget(parseTreeNode,{
+			wiki: wiki,
+			document: $tw.fakeDocument
+		});
+	}
+
+	function parseText(text,wiki,options) {
+		var parser = wiki.parseText("text/vnd.tiddlywiki",text,options);
+		return parser ? {type: "widget", children: parser.tree} : undefined;
+	}
+
+	function renderWidgetNode(widgetNode) {
+		$tw.fakeDocument.setSequenceNumber(0);
+		var wrapper = $tw.fakeDocument.createElement("div");
+		widgetNode.render(wrapper,null);
+		return wrapper;
+	}
+
+	function refreshWidgetNode(widgetNode,wrapper,changes) {
+		var changedTiddlers = {};
+		if(changes) {
+			$tw.utils.each(changes,function(title) {
+				changedTiddlers[title] = true;
+			});
+		}
+		widgetNode.refresh(changedTiddlers,wrapper,null);
+	}
+
+	// Don't pass fakedom elements to Jasmine matchers. The matchers pretty-print
+	// values on assertion which walks the element.style Proxy with Symbol keys and
+	// crashes inside convertStyleNameToPropertyName.
+	// TODO: once issue: "fakedom style Proxy guards against non-string property keys" lands
+	//       revert these workarounds to idiomatic matchers (toBe(null), toBeUndefined()).
+	function findSelectDom(node) {
+		if(node.tag === "select") return node;
+		if(node.children) {
+			for(var i = 0; i < node.children.length; i++) {
+				var found = findSelectDom(node.children[i]);
+				if(found) return found;
+			}
+		}
+		return null;
+	}
+
+	function selectedFlags(parent) {
+		var result = [];
+		for(var i = 0; i < parent.children.length; i++) {
+			result.push(!!parent.children[i].selected);
+		}
+		return result;
+	}
+
+	// Regression test for https://github.com/TiddlyWiki/TiddlyWiki5/issues/9839
+	// PR #8093 added <optgroup> support but used `child.children.length === 0` to
+	// distinguish a plain <option> from an <optgroup>. That heuristic misfires for
+	// any <option> whose contents render to inline HTML elements (e.g. tc-tiddlylink
+	// auto-links generated for "$:/..." titles), so the option's `selected` state
+	// was never restored on refresh.
+	it("preserves multi-select state across refresh when options contain inline HTML children",function() {
+		var wiki = $tw.test.wiki();
+		wiki.addTiddlers([
+			{title: "Picks", mylist: "foo $:/mumble"}
+		]);
+		// Each option has element children to mimic the auto-link case from #9839.
+		// Explicit value attribute lets fakedom resolve option.value (real browsers
+		// fall back to text content).
+		var widgetText = "<$select tiddler='Picks' field='mylist' multiple>" +
+			"<option value='foo'><span>foo</span></option>" +
+			"<option value='bar'><span>bar</span></option>" +
+			"<option value='$:/mumble'><a class='tc-tiddlylink'>$:/mumble</a></option>" +
+			"</$select>";
+		var widgetNode = createWidgetNode(parseText(widgetText,wiki),wiki);
+		var wrapper = renderWidgetNode(widgetNode);
+		var select = findSelectDom(wrapper);
+		expect(select === null).toBe(false);
+		expect(select.children.length).toBe(3);
+
+		// After initial render, options matching the field value should be selected.
+		// foo (idx 0), bar (idx 1), $:/mumble (idx 2).
+		expect(selectedFlags(select)).toEqual([true,false,true]);
+
+		// Change the stored field value and refresh - this is where the bug surfaced:
+		// the "$:/mumble" option (with an <a> child) was wrongly skipped.
+		wiki.addTiddler({title: "Picks", mylist: "bar $:/mumble"});
+		refreshWidgetNode(widgetNode,wrapper,["Picks"]);
+
+		expect(selectedFlags(select)).toEqual([false,true,true]);
+		// The inner <a> must not be touched - .selected is meaningful only on <option>.
+		var innerLinkSelected = select.children[2].children[0].selected;
+		expect(innerLinkSelected === undefined).toBe(true);
+	});
+
+	it("still selects options inside <optgroup> across refresh, including $:/-prefixed entries with inline HTML",function() {
+		var wiki = $tw.test.wiki();
+		wiki.addTiddlers([
+			{title: "Picks", mylist: "1 $:/mumble"}
+		]);
+		// The "high" group mixes a plain option with a $:/-prefixed option whose
+		// content is wrapped in an auto-link <a> - same pattern that broke #9839
+		// for top-level options, exercised here inside an <optgroup>.
+		var widgetText = "<$select tiddler='Picks' field='mylist' multiple>" +
+			"<optgroup label='low'>" +
+				"<option value='1'>1</option>" +
+				"<option value='2'>2</option>" +
+			"</optgroup>" +
+			"<optgroup label='high'>" +
+				"<option value='4'>4</option>" +
+				"<option value='$:/mumble'><a class='tc-tiddlylink'>$:/mumble</a></option>" +
+			"</optgroup>" +
+			"</$select>";
+		var widgetNode = createWidgetNode(parseText(widgetText,wiki),wiki);
+		var wrapper = renderWidgetNode(widgetNode);
+		var select = findSelectDom(wrapper);
+		expect(select === null).toBe(false);
+		expect(select.children.length).toBe(2);
+
+		// Initial state: "1" and "$:/mumble" selected
+		expect(selectedFlags(select.children[0])).toEqual([true,false]);
+		expect(selectedFlags(select.children[1])).toEqual([false,true]);
+
+		wiki.addTiddler({title: "Picks", mylist: "2 4"});
+		refreshWidgetNode(widgetNode,wrapper,["Picks"]);
+		expect(selectedFlags(select.children[0])).toEqual([false,true]);
+		expect(selectedFlags(select.children[1])).toEqual([true,false]);
+	});
+
+});

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

@@ -11,64 +11,64 @@ Tests the tagging mechanism.
 
 describe("Tags Operator tests", function() {
 
-describe("With no indexers", function() {
-	var wikiOptions = {enableIndexers: []},
-		wiki = setupWiki(wikiOptions);
-	runTests(wiki,wikiOptions);
-});
+	describe("With no indexers", function() {
+		var wikiOptions = {enableIndexers: []},
+			wiki = setupWiki(wikiOptions);
+		runTests(wiki,wikiOptions);
+	});
 
-describe("With all indexers", function() {
-	var wikiOptions = {},
-		wiki = setupWiki();
-	runTests(wiki,wikiOptions);
-});
+	describe("With all indexers", function() {
+		var wikiOptions = {},
+			wiki = setupWiki();
+		runTests(wiki,wikiOptions);
+	});
 
-function setupWiki(wikiOptions) {
+	function setupWiki(wikiOptions) {
 	// Create a wiki
-	var wiki = new $tw.Wiki(wikiOptions);
-
-	// Add a few  tiddlers
-	wiki.addTiddler({ title: "aaa",text: "text aaa",color: "red"});
-	wiki.addTiddler({ title: "1"});
-	wiki.addTiddler({ title: "10"});
-	wiki.addTiddler({ title: "bbb"});
-	wiki.addTiddler({ title: "bb bb"});
-	wiki.addTiddler({ title: "BBB"});
-	wiki.addTiddler({ title: "AAA"});
-	wiki.addTiddler({ title: "BB BB"});
-	wiki.addTiddler({ title: "bb bb", text: "text bb bb"});
-	return wiki;
-}
+		var wiki = new $tw.Wiki(wikiOptions);
+
+		// Add a few  tiddlers
+		wiki.addTiddler({ title: "aaa",text: "text aaa",color: "red"});
+		wiki.addTiddler({ title: "1"});
+		wiki.addTiddler({ title: "10"});
+		wiki.addTiddler({ title: "bbb"});
+		wiki.addTiddler({ title: "bb bb"});
+		wiki.addTiddler({ title: "BBB"});
+		wiki.addTiddler({ title: "AAA"});
+		wiki.addTiddler({ title: "BB BB"});
+		wiki.addTiddler({ title: "bb bb", text: "text bb bb"});
+		return wiki;
+	}
 
 	// Our tests
-function runTests(wiki,wikiOptions) {
+	function runTests(wiki,wikiOptions) {
 
-	var TAGS = "aaa 10 1 bbb AAA [[bb bb]] BBB [[BB BB]]";
+		var TAGS = "aaa 10 1 bbb AAA [[bb bb]] BBB [[BB BB]]";
 
-	// Tests before PR #8228 to make sure there are now incompatibilities
-	it("should apply tags ordering in SORT order up to TW v5.3.6", function () {
-		var wiki = new $tw.Wiki(wikiOptions);
-		var EXPECTED = "1,10,aaa,AAA,bb bb,BB BB,bbb,BBB";
+		// Tests before PR #8228 to make sure there are now incompatibilities
+		it("should apply tags ordering in SORT order up to TW v5.3.6", function () {
+			var wiki = new $tw.Wiki(wikiOptions);
+			var EXPECTED = "1,10,aaa,AAA,bb bb,BB BB,bbb,BBB";
 
-		wiki.addTiddler({ title: "test-tags-operator", text: "", tags: TAGS});
-		expect(wiki.filterTiddlers("[[test-tags-operator]tags[]sort[title]]").join(',')).toBe(EXPECTED);
+			wiki.addTiddler({ title: "test-tags-operator", text: "", tags: TAGS});
+			expect(wiki.filterTiddlers("[[test-tags-operator]tags[]sort[title]]").join(",")).toBe(EXPECTED);
 
-		wiki.addTiddler({ title: "$:/config/Tags/CustomSort/subfilter", text: "[{!!title}]"});
-		expect(wiki.filterTiddlers("[[test-tags-operator]tags[]] :sort:alphanumeric:caseinsensitive[subfilter{$:/config/Tags/CustomSort/subfilter}]").join(',')).toBe(EXPECTED);
+			wiki.addTiddler({ title: "$:/config/Tags/CustomSort/subfilter", text: "[{!!title}]"});
+			expect(wiki.filterTiddlers("[[test-tags-operator]tags[]] :sort:alphanumeric:caseinsensitive[subfilter{$:/config/Tags/CustomSort/subfilter}]").join(",")).toBe(EXPECTED);
 
 		// Due to the implementation of the tags[] operator with v5.3.6 we can not guarantee the order that `[tags[]]` returns
-	});
+		});
 
-	// The following test can be enabled once the core allows us to do so.
-	xit("should apply tags ordering in order of creation. TW v5.3.7+", function () {
-		var wiki = new $tw.Wiki(wikiOptions);
+		// The following test can be enabled once the core allows us to do so.
+		xit("should apply tags ordering in order of creation. TW v5.3.7+", function () {
+			var wiki = new $tw.Wiki(wikiOptions);
 
-		wiki.addTiddler({ title: "$:/config/Tags/CustomSort/subfilter", text: ""});
-		wiki.addTiddler({ title: "test-tags-operator", text: "", tags: TAGS});
+			wiki.addTiddler({ title: "$:/config/Tags/CustomSort/subfilter", text: ""});
+			wiki.addTiddler({ title: "test-tags-operator", text: "", tags: TAGS});
 
-		var EXPECTED = "aaa,10,1,bbb,AAA,bb bb,BBB,BB BB"
-		expect(wiki.filterTiddlers("[[test-tags-operator]tags[]] :sort:alphanumeric:caseinsensitive[subfilter{$:/config/Tags/CustomSort/subfilter}]").join(',')).toBe(EXPECTED);
-	});
-}
+			var EXPECTED = "aaa,10,1,bbb,AAA,bb bb,BBB,BB BB";
+			expect(wiki.filterTiddlers("[[test-tags-operator]tags[]] :sort:alphanumeric:caseinsensitive[subfilter{$:/config/Tags/CustomSort/subfilter}]").join(",")).toBe(EXPECTED);
+		});
+	}
 
 });