tiddlywiki 5.4.0 → 5.4.1

package/editions/test/tiddlers/tests/test-edit-widgets/test-edit-text-widget.js

@@ -0,0 +1,198 @@
+/*\
+title: test-edit-text-widget.js
+type: application/javascript
+tags: [[$:/tags/test-spec]]
+
+Covers the `rows` / `autoHeight` / `minHeight` interaction in the
+edit-text widget. Regression guard for issue #9451 / PR #9454 follow-up
+fix (rows=1 autoHeight=yes must still grow).
+
+Assertions target the routing inside SimpleEngine.fixHeight (which
+branch runs, called with which minHeight) — pixel measurement needs a
+real browser.
+
+\*/
+
+"use strict";
+
+describe("Edit-text widget", function() {
+
+	// Shared helpers live in $:/tests/test-edit-widgets/helpers. See that
+	// file for what each helper prepares and where it is used across the suite.
+	var helpers = require("$:/tests/test-edit-widgets/helpers");
+
+	// Local wrapper: every test in THIS file seeds an empty "TestTiddler"
+	// as its default binding target, so we inject that by default.
+	function makeWiki(extraTiddlers) {
+		return helpers.makeWiki(extraTiddlers,{seedTestTiddler: true});
+	}
+
+	// Local alias — `renderEditText` reads more naturally than
+	// `helpers.renderFromAttrs` for the routing tests.
+	function renderEditText(attrs,wiki,tiddlerTitle) {
+		return helpers.renderFromAttrs(attrs,wiki,tiddlerTitle);
+	}
+
+	// ---------------------------------------------------------------
+	// Attribute parsing
+	// ---------------------------------------------------------------
+
+	describe("attribute parsing", function() {
+
+		// manual: on a bare <$edit-text tiddler="T"/>, open devtools and
+		// inspect the widget instance — the element should be a textarea,
+		// there should be no rows attribute, and auto-height should be on.
+		// Manual Preview: Also use the widget-tree
+		it("defaults: tag=textarea, autoHeight=yes, no rows, minHeight=100px", function() {
+			var et = renderEditText({});
+			expect(et.editTag).toBe("textarea");
+			expect(et.editAutoHeight).toBe(true);
+			expect(et.editRows).toBeUndefined();
+			expect(et.editMinHeight).toBe("100px");
+		});
+
+		// manual: render <$edit-text tiddler="T" rows=5 autoHeight="no" minHeight="1em"/>
+		// — the widget's internal state should reflect all three explicit
+		// values, overriding the defaults verified in the previous test.
+		// Manual Preview: Also use the widget-tree
+		it("explicit attributes override defaults (rows, autoHeight, minHeight)", function() {
+			var et = renderEditText({rows: "5", autoHeight: "no", minHeight: "1em"});
+			expect(et.editRows).toBe("5");
+			expect(et.editAutoHeight).toBe(false);
+			expect(et.editMinHeight).toBe("1em");
+		});
+
+		// manual: render <$edit-text tiddler="T" field="caption" tag="textarea"/>
+		// — the element should be a multi-line textarea even though the
+		// field is not `text`.
+		it("tag=textarea override applies to non-text fields", function() {
+			var et = renderEditText({field: "caption", tag: "textarea"});
+			expect(et.editTag).toBe("textarea");
+		});
+
+		// manual: set $:/config/TextEditor/EditorHeight/Mode = "fixed"
+		// (via control panel → settings → editor toolbar, or edit the
+		// tiddler directly). <$edit-text tiddler="T"/> should now behave
+		// as fixed-height (scrollbar on overflow) by default.
+		it("$:/config/TextEditor/EditorHeight/Mode=fixed flips default autoHeight to false", function() {
+			var wiki = makeWiki([
+				{title: "$:/config/TextEditor/EditorHeight/Mode", text: "fixed"}
+			]);
+			var et = renderEditText({},wiki);
+			expect(et.editAutoHeight).toBe(false);
+		});
+
+		// manual: with the same Mode=fixed config as above, an explicit
+		// <$edit-text tiddler="T" autoHeight="yes"/> should still auto-grow
+		// — the per-widget attribute wins over the global config.
+		it("explicit autoHeight=yes overrides Mode=fixed config", function() {
+			var wiki = makeWiki([
+				{title: "$:/config/TextEditor/EditorHeight/Mode", text: "fixed"}
+			]);
+			var et = renderEditText({autoHeight: "yes"},wiki);
+			expect(et.editAutoHeight).toBe(true);
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// DOM node construction (SimpleEngine)
+	// ---------------------------------------------------------------
+
+	describe("DOM node construction (non-toolbar SimpleEngine)", function() {
+
+		// manual: render <$edit-text tiddler="T" rows=1/> and inspect the
+		// element — it should carry rows="1". Proves SimpleEngine copies
+		// widget.editRows onto the DOM element.
+		it("sets the rows attribute on the DOM node when rows is specified", function() {
+			var et = renderEditText({rows: "1"});
+			expect(et.engine.domNode.getAttribute("rows")).toBe("1");
+		});
+	});
+
+	// ---------------------------------------------------------------
+	// fixHeight routing — the core of the fix
+	// ---------------------------------------------------------------
+
+	describe("fixHeight routing", function() {
+
+		var originalResize, resizeSpy;
+
+		beforeEach(function() {
+			originalResize = $tw.utils.resizeTextAreaToFit;
+			resizeSpy = jasmine.createSpy("resizeTextAreaToFit").and.returnValue(0);
+			$tw.utils.resizeTextAreaToFit = resizeSpy;
+		});
+
+		afterEach(function() {
+			$tw.utils.resizeTextAreaToFit = originalResize;
+		});
+
+		// Make the SimpleEngine.fixHeight think we are in a real DOM so it
+		// actually reaches the $tw.utils.resizeTextAreaToFit call. Without
+		// this the engine short-circuits because fakedom nodes carry
+		// isTiddlyWikiFakeDom === true.
+		function callFixHeight(et) {
+			et.engine.domNode.isTiddlyWikiFakeDom = false;
+			et.engine.fixHeight();
+		}
+
+		// manual: render <$edit-text tiddler="T" rows=1 autoHeight=yes minHeight=1em/>
+		// (the TiddlyTools idiom). In 5.4.0 pre-fix, the textarea stayed
+		// a single row forever; after the fix, it starts at 1 row and
+		// grows as you type newlines. This covers BRANCH A (autoHeight=yes)
+		// of SimpleEngine.fixHeight: resize is called with minHeight even
+		// when rows is set. Strict superset of the no-rows baseline.
+		it("rows=1 autoHeight=yes minHeight=1em still calls resize (regression test for the PR #9454 follow-up fix)", function() {
+			var et = renderEditText({rows: "1", autoHeight: "yes", minHeight: "1em"});
+			callFixHeight(et);
+			expect(resizeSpy).toHaveBeenCalled();
+			expect(resizeSpy.calls.mostRecent().args[1]).toBe("1em");
+		});
+
+		// manual: render <$edit-text tiddler="T" rows=5 autoHeight=no/> —
+		// the textarea must stay locked at exactly 5 rows tall, even if
+		// you paste in 50 lines (vertical scrollbar appears inside).
+		it("rows=5 autoHeight=no does NOT call resize and does NOT apply the fixed-height fallback", function() {
+			var et = renderEditText({rows: "5", autoHeight: "no"});
+			callFixHeight(et);
+			expect(resizeSpy).not.toHaveBeenCalled();
+			// rows attribute governs height — CSS height must remain unset
+			expect(et.engine.domNode.style.height).toBe("");
+		});
+
+		// manual: set $:/config/TextEditor/EditorHeight/Height = "250px",
+		// then render <$edit-text tiddler="T" autoHeight="no"/> — the
+		// textarea should be exactly 250px tall regardless of content.
+		it("autoHeight=no with no rows applies the fixed-height fallback from config", function() {
+			var wiki = makeWiki([
+				{title: "$:/config/TextEditor/EditorHeight/Height", text: "250px"}
+			]);
+			var et = renderEditText({autoHeight: "no"},wiki);
+			callFixHeight(et);
+			expect(resizeSpy).not.toHaveBeenCalled();
+			expect(et.engine.domNode.style.height).toBe("250px");
+		});
+
+		// manual: set $:/config/TextEditor/EditorHeight/Height = "5px",
+		// render <$edit-text tiddler="T" autoHeight="no"/> — the textarea
+		// should be 20px tall (clamped), not a sliver, so it stays usable.
+		it("autoHeight=no fallback height is clamped to at least 20px", function() {
+			var wiki = makeWiki([
+				{title: "$:/config/TextEditor/EditorHeight/Height", text: "5px"}
+			]);
+			var et = renderEditText({autoHeight: "no"},wiki);
+			callFixHeight(et);
+			expect(et.engine.domNode.style.height).toBe("20px");
+		});
+
+		// manual: render <$edit-text tiddler="T" field="caption" autoHeight="no"/>
+		// — the element is a single-line <input> and the CSS height should
+		// remain unset (no height fallback applies to inputs).
+		it("tag=input: neither resize nor fixed-height fallback runs", function() {
+			var et = renderEditText({field: "caption", autoHeight: "no"});
+			callFixHeight(et);
+			expect(resizeSpy).not.toHaveBeenCalled();
+			expect(et.engine.domNode.style.height).toBe("");
+		});
+	});
+});

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

@@ -18,4 +18,15 @@ describe("fakedom tests", function() {
 		expect($tw.fakeDocument.createTextNode("text").nodeType).toBe(3);
 		expect($tw.fakeDocument.createTextNode("text").TEXT_NODE).toBe(3);
 	});
+
+	// Real CSSStyleDeclaration returns undefined for Symbol property keys.
+	// Without a guard, the TW_Style Proxy throws on Symbol access. This bites
+	// in practice when Jasmine pretty-prints fakedom elements on failure.
+	// See related TODO in test-select-widget.js
+	it("returns undefined for Symbol property access on element.style", function() {
+		var el = $tw.fakeDocument.createElement("div");
+		expect(function() { return el.style[Symbol.toPrimitive]; }).not.toThrow();
+		expect(el.style[Symbol.toPrimitive]).toBeUndefined();
+		expect(function() { el.style[Symbol.iterator] = "x"; }).not.toThrow();
+	});
 });

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-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-utils-copyObjectProperiesSafe.js

@@ -0,0 +1,240 @@
+/*\
+title: test-utils-copyObjectPropertiesSafe.js
+type: application/javascript
+tags: [[$:/tags/test-spec]]
+
+Tests $tw.utils.copyObjectPropertiesSafe, the root cause of #9869.
+
+$eventcatcher serialises DOM events via JSON.stringify(copyObjectPropertiesSafe(event)).
+
+The original bug was caused by instanceof Node/Window being realm-specific.
+When an event originated from a different browser window, DOM objects from that
+window were not detected and JSON.stringify() could throw "Illegal invocation".
+
+The implementation must:
+- skip DOM nodes and Window objects from other realms
+- preserve normal event data
+- preserve CustomEvent.detail payloads
+- continue copying enumerable properties from non-DOM objects
+- preserve arrays and break circular references
+
+The tests use substitutes for foreign DOM objects because headless Node does not
+provide a second browser realm. These objects model the important characteristics:
+DOM nodes have nodeType/nodeName, and Window objects have window/self/document.
+\*/
+
+"use strict";
+
+describe("copyObjectPropertiesSafe (#9869)", function() {
+
+	var cops = $tw.utils.copyObjectPropertiesSafe;
+
+	// Simulates a DOM node from another realm.
+	// The important characteristics are:
+	// - nodeType/nodeName identify it as a DOM node
+	// - circular parentNode references resemble real DOM trees
+	function fakeElement(tagName,extra) {
+		var node = $tw.utils.extend({
+			nodeType: 1,
+			nodeName: tagName,
+			tagName: tagName
+		},extra || {});
+
+		node.parentNode = node;
+		return node;
+	}
+
+	// Simulates a Window object from another realm.
+	function fakeWindow() {
+		var win = {
+			document: {},
+			location: {}
+		};
+
+		win.window = win;
+		win.self = win;
+
+		return win;
+	}
+
+	// An event carrying foreign DOM nodes and a Window.
+	function fakeEvent(type,target,extra) {
+		return $tw.utils.extend({
+			type: type,
+			target: target,
+			currentTarget: target,
+			view: fakeWindow(),
+			detail: 0,
+			isTrusted: true
+		},extra || {});
+	}
+
+
+	it("does not throw serialising any event type from a secondary window", function() {
+		var events = [
+			fakeEvent("focusin",fakeElement("INPUT")),
+			fakeEvent("change",fakeElement("SELECT")),
+			fakeEvent("click",fakeElement("BUTTON"),{
+				button: 0,
+				clientX: 5,
+				clientY: 9,
+				relatedTarget: null
+			}),
+			fakeEvent("mouseover",fakeElement("DIV"),{
+				relatedTarget: fakeElement("SPAN")
+			})
+		];
+
+		events.forEach(function(event) {
+			expect(function() {
+				JSON.stringify(cops(event));
+			}).not.toThrow();
+		});
+	});
+
+
+	it("drops DOM nodes and Window but keeps serialisable event data", function() {
+		var event = fakeEvent("click",fakeElement("BUTTON"),{
+			button: 0,
+			clientX: 5,
+			clientY: 9
+		});
+
+		var result = JSON.parse(JSON.stringify(cops(event)));
+
+		expect(result.target).toBeUndefined();
+		expect(result.currentTarget).toBeUndefined();
+		expect(result.view).toBeUndefined();
+
+		expect(result.type).toBe("click");
+		expect(result.detail).toBe(0);
+		expect(result.isTrusted).toBe(true);
+		expect(result.button).toBe(0);
+		expect(result.clientX).toBe(5);
+		expect(result.clientY).toBe(9);
+	});
+
+
+	it("preserves nested objects, arrays and circular reference handling", function() {
+		var event = fakeEvent("custom",fakeElement("DIV"),{
+			detail: {
+				nested: {
+					a: 1,
+					b: [2,3]
+				}
+			},
+			path: [
+				fakeElement("DIV"),
+				fakeWindow(),
+				42
+			]
+		});
+
+		event.self = event;
+
+		var result = JSON.parse(JSON.stringify(cops(event)));
+
+		expect(result.detail).toEqual({
+			nested: {
+				a: 1,
+				b: [2,3]
+			}
+		});
+
+		expect(result.path).toEqual([
+			null,
+			null,
+			42
+		]);
+
+		expect(result.self).toBeUndefined();
+	});
+
+
+	it("preserves CustomEvent.detail objects including custom object instances", function() {
+		function DetailObject() {
+			this.name = "example";
+			this.values = [1,2,3];
+		}
+
+		var event = fakeEvent("custom",fakeElement("DIV"),{
+			detail: new DetailObject()
+		});
+
+		var result = JSON.parse(JSON.stringify(cops(event)));
+
+		expect(result.detail).toEqual({
+			name: "example",
+			values: [1,2,3]
+		});
+	});
+
+
+	it("preserves CustomEvent.detail objects while dropping DOM objects inside them", function() {
+		var event = fakeEvent("custom",fakeElement("DIV"),{
+			detail: {
+				value: 123,
+				nested: {
+					target: fakeElement("SPAN"),
+					kept: "yes"
+				},
+				items: [
+					fakeElement("BUTTON"),
+					42
+				]
+			}
+		});
+
+		var result = JSON.parse(JSON.stringify(cops(event)));
+
+		expect(result.detail.value).toBe(123);
+
+		expect(result.detail.nested.target).toBeUndefined();
+		expect(result.detail.nested.kept).toBe("yes");
+
+		expect(result.detail.items).toEqual([
+			null,
+			42
+		]);
+	});
+
+
+	it("accepts primitive, array and object arguments", function() {
+		var nullProto = Object.create(null);
+		nullProto.kept = true;
+
+		expect(cops(42)).toBe(42);
+		expect(cops(null)).toBe(null);
+
+		expect(cops([
+			1,
+			"two",
+			{three: 3}
+		])).toEqual([
+			1,
+			"two",
+			{three: 3}
+		]);
+
+		expect(cops({
+			a: 1,
+			b: {
+				c: 2
+			}
+		})).toEqual({
+			a: 1,
+			b: {
+				c: 2
+			}
+		});
+
+		expect(JSON.parse(JSON.stringify(cops({
+			nullProto: nullProto
+		})))).toEqual({
+			nullProto: {
+				kept: true
+			}
+		});
+	});
+
+});

package/editions/tw5.com/tiddlers/$__StoryList.tid

@@ -0,0 +1,3 @@
+list: HelloThere [[Quick Start]] [[Find Out More]] Releases $:/changenotes/5.4.1/#9836 [[TiddlyWiki on the Web]] [[Testimonials and Reviews]] GettingStarted Community
+title: $:/StoryList
+type: text/vnd.tiddlywiki

package/editions/tw5.com/tiddlers/about/Archive.tid

@@ -1,14 +1,16 @@
 created: 20231005205623086
-modified: 20250807100434131
+modified: 20260710090951727
 tags: About
 title: TiddlyWiki Archive
+type: text/vnd.tiddlywiki
 
 \procedure versions()
 5.1.0 5.1.1 5.1.2 5.1.3 5.1.4 5.1.5 5.1.6 5.1.7 5.1.8 5.1.9
 5.1.10 5.1.11 5.1.12 5.1.13 5.1.14 5.1.15 5.1.16 5.1.17 5.1.18 5.1.19
 5.1.20 5.1.21 5.1.22 5.1.23
 5.2.0 5.2.1 5.2.2 5.2.3 5.2.4 5.2.5 5.2.6 5.2.7
-5.3.0 5.3.1 5.3.2 5.3.3 5.3.4 5.3.5 5.3.6 5.3.7 5.3.8 5.4.0
+5.3.0 5.3.1 5.3.2 5.3.3 5.3.4 5.3.5 5.3.6 5.3.7 5.3.8
+5.4.0 5.4.1
 \end
 
 Older versions of TiddlyWiki are available in the [[archive|https://github.com/TiddlyWiki/tiddlywiki.com-gh-pages/tree/master/archive]]: