tiddlywiki 5.3.8 → 5.4.0

package/core-server/server/server.js

@@ -0,0 +1,393 @@
+/*\
+title: $:/core/modules/server/server.js
+type: application/javascript
+module-type: library
+
+Serve tiddlers over http
+
+\*/
+
+"use strict";
+
+let fs, url, path, querystring, crypto, zlib;
+
+if($tw.node) {
+	fs = require("fs"),
+	url = require("url"),
+	path = require("path"),
+	querystring = require("querystring"),
+	crypto = require("crypto"),
+	zlib = require("zlib");
+}
+
+/*
+A simple HTTP server with regexp-based routes
+options: variables - optional hashmap of variables to set (a misnomer - they are really constant parameters)
+		 routes - optional array of routes to use
+		 wiki - reference to wiki object
+*/
+function Server(options) {
+	var self = this;
+	this.routes = options.routes || [];
+	this.authenticators = options.authenticators || [];
+	this.wiki = options.wiki;
+	this.boot = options.boot || $tw.boot;
+	// Initialise the variables
+	this.variables = $tw.utils.extend({},this.defaultVariables);
+	if(options.variables) {
+		for(var variable in options.variables) {
+			if(options.variables[variable]) {
+				this.variables[variable] = options.variables[variable];
+			}
+		}
+	}
+	// Setup the default required plugins
+	this.requiredPlugins = this.get("required-plugins").split(",");
+	// Initialise CORS
+	this.corsEnable = this.get("cors-enable") === "yes";
+	// Initialise CSRF
+	this.csrfDisable = this.get("csrf-disable") === "yes";
+	// Initialize Gzip compression
+	this.enableGzip = this.get("gzip") === "yes";
+	// Initialize browser-caching
+	this.enableBrowserCache = this.get("use-browser-cache") === "yes";
+	// Initialise authorization
+	var authorizedUserName;
+	if(this.get("username") && this.get("password")) {
+		authorizedUserName = this.get("username");
+	} else if(this.get("credentials")) {
+		authorizedUserName = "(authenticated)";
+	} else {
+		authorizedUserName = "(anon)";
+	}
+	this.authorizationPrincipals = {
+		readers: (this.get("readers") || authorizedUserName).split(",").map($tw.utils.trim),
+		writers: (this.get("writers") || authorizedUserName).split(",").map($tw.utils.trim)
+	};
+	if(this.get("admin") || authorizedUserName !== "(anon)") {
+		this.authorizationPrincipals["admin"] = (this.get("admin") || authorizedUserName).split(",").map($tw.utils.trim);
+	}
+	// Load and initialise authenticators
+	$tw.modules.forEachModuleOfType("authenticator", function(title,authenticatorDefinition) {
+		// console.log("Loading authenticator " + title);
+		self.addAuthenticator(authenticatorDefinition.AuthenticatorClass);
+	});
+	// Load route handlers
+	$tw.modules.forEachModuleOfType("route", function(title,routeDefinition) {
+		// console.log("Loading server route " + title);
+		self.addRoute(routeDefinition);
+	});
+	this.routes.sort((a, b) => {
+		const priorityA = a.info?.priority ?? 100,
+			priorityB = b.info?.priority ?? 100;
+		return priorityB - priorityA;
+	});
+	// Initialise the http vs https
+	this.listenOptions = null;
+	this.protocol = "http";
+	var tlsKeyFilepath = this.get("tls-key"),
+		tlsCertFilepath = this.get("tls-cert"),
+		tlsPassphrase = this.get("tls-passphrase");
+	if(tlsCertFilepath && tlsKeyFilepath) {
+		this.listenOptions = {
+			key: fs.readFileSync(path.resolve(this.boot.wikiPath,tlsKeyFilepath),"utf8"),
+			cert: fs.readFileSync(path.resolve(this.boot.wikiPath,tlsCertFilepath),"utf8"),
+			passphrase: tlsPassphrase || ""
+		};
+		this.protocol = "https";
+	}
+	this.transport = require(this.protocol);
+	// Name the server and init the boot state
+	this.servername = $tw.utils.transliterateToSafeASCII(this.get("server-name") || this.wiki.getTiddlerText("$:/SiteTitle") || "TiddlyWiki5");
+	this.boot.origin = this.get("origin")? this.get("origin"): this.protocol+"://"+this.get("host")+":"+this.get("port");
+	this.boot.pathPrefix = this.get("path-prefix") || "";
+}
+
+/*
+Send a response to the client. This method checks if the response must be sent
+or if the client alrady has the data cached. If that's the case only a 304
+response will be transmitted and the browser will use the cached data.
+Only requests with status code 200 are considdered for caching.
+request: request instance passed to the handler
+response: response instance passed to the handler
+statusCode: stauts code to send to the browser
+headers: response headers (they will be augmented with an `Etag` header)
+data: the data to send (passed to the end method of the response instance)
+encoding: the encoding of the data to send (passed to the end method of the response instance)
+*/
+function sendResponse(request,response,statusCode,headers,data,encoding) {
+	if(this.enableBrowserCache && (statusCode == 200)) {
+		var hash = crypto.createHash("md5");
+		// Put everything into the hash that could change and invalidate the data that
+		// the browser already stored. The headers the data and the encoding.
+		hash.update(data);
+		hash.update(JSON.stringify(headers));
+		if(encoding) {
+			hash.update(encoding);
+		}
+		var contentDigest = hash.digest("hex");
+		// RFC 7232 section 2.3 mandates for the etag to be enclosed in quotes
+		headers["Etag"] = '"' + contentDigest + '"';
+		headers["Cache-Control"] = "max-age=0, must-revalidate";
+		// Check if any of the hashes contained within the if-none-match header
+		// matches the current hash.
+		// If one matches, do not send the data but tell the browser to use the
+		// cached data.
+		// We do not implement "*" as it makes no sense here.
+		var ifNoneMatch = request.headers["if-none-match"];
+		if(ifNoneMatch) {
+			var matchParts = ifNoneMatch.split(",").map(function(etag) {
+				return etag.replace(/^[ "]+|[ "]+$/g, "");
+			});
+			if(matchParts.indexOf(contentDigest) != -1) {
+				response.writeHead(304,headers);
+				response.end();
+				return;
+			}
+		}
+	} else {
+		// RFC 7231, 6.1. Overview of Status Codes:
+		// Browser clients may cache 200, 203, 204, 206, 300, 301, 
+		// 404, 405, 410, 414, and 501 unless given explicit cache controls
+		headers["Cache-Control"] = headers["Cache-Control"] || "no-store";
+	}
+	/*
+	If the gzip=yes is set, check if the user agent permits compression. If so,
+	compress our response if the raw data is bigger than 2k. Compressing less
+	data is inefficient. Note that we use the synchronous functions from zlib
+	to stay in the imperative style. The current `Server` doesn't depend on
+	this, and we may just as well use the async versions.
+	*/
+	if(this.enableGzip && (data.length > 2048)) {
+		var acceptEncoding = request.headers["accept-encoding"] || "";
+		if(/\bdeflate\b/.test(acceptEncoding)) {
+			headers["Content-Encoding"] = "deflate";
+			data = zlib.deflateSync(data);
+		} else if(/\bgzip\b/.test(acceptEncoding)) {
+			headers["Content-Encoding"] = "gzip";
+			data = zlib.gzipSync(data);
+		}
+	}
+
+	response.writeHead(statusCode,headers);
+	response.end(data,encoding);
+}
+
+Server.prototype.defaultVariables = {
+	port: "8080",
+	host: "127.0.0.1",
+	"required-plugins": "$:/plugins/tiddlywiki/filesystem,$:/plugins/tiddlywiki/tiddlyweb",
+	"root-tiddler": "$:/core/save/all",
+	"root-render-type": "text/plain",
+	"root-serve-type": "text/html",
+	"tiddler-render-type": "text/html",
+	"tiddler-render-template": "$:/core/templates/server/static.tiddler.html",
+	"system-tiddler-render-type": "text/plain",
+	"system-tiddler-render-template": "$:/core/templates/wikified-tiddler",
+	"debug-level": "none",
+	"gzip": "no",
+	"use-browser-cache": "no"
+};
+
+Server.prototype.get = function(name) {
+	return this.variables[name];
+};
+
+Server.prototype.addRoute = function(route) {
+	this.routes.push(route);
+};
+
+Server.prototype.addAuthenticator = function(AuthenticatorClass) {
+	// Instantiate and initialise the authenticator
+	var authenticator = new AuthenticatorClass(this),
+		result = authenticator.init();
+	if(typeof result === "string") {
+		$tw.utils.error("Error: " + result);
+	} else if(result) {
+		// Only use the authenticator if it initialised successfully
+		this.authenticators.push(authenticator);
+	}
+};
+
+Server.prototype.findMatchingRoute = function(request,state) {
+	for(var t=0; t<this.routes.length; t++) {
+		var potentialRoute = this.routes[t],
+			pathname = state.urlInfo.pathname,
+			match;
+		if(state.pathPrefix) {
+			if(pathname.substr(0,state.pathPrefix.length) === state.pathPrefix) {
+				pathname = pathname.substr(state.pathPrefix.length) || "/";
+				match = potentialRoute.path.exec(pathname);
+			} else {
+				match = false;
+			}
+		} else {
+			match = potentialRoute.path.exec(pathname);
+		}
+		if(match && (potentialRoute.methods?.includes(request.method) || potentialRoute.method === request.method)) {
+			state.params = [];
+			for(var p=1; p<match.length; p++) {
+				state.params.push(match[p]);
+			}
+			return potentialRoute;
+		}
+	}
+	return null;
+};
+
+Server.prototype.methodMappings = {
+	"GET": "readers",
+	"OPTIONS": "readers",
+	"HEAD": "readers",
+	"PUT": "writers",
+	"POST": "writers",
+	"DELETE": "writers"
+};
+
+/*
+Check whether a given user is authorized for the specified authorizationType ("readers" or "writers"). Pass null or undefined as the username to check for anonymous access
+*/
+Server.prototype.isAuthorized = function(authorizationType,username) {
+	var principals = this.authorizationPrincipals[authorizationType] || [];
+	return principals.indexOf("(anon)") !== -1 || (username && (principals.indexOf("(authenticated)") !== -1 || principals.indexOf(username) !== -1));
+};
+
+Server.prototype.requestHandler = function(request,response,options) {
+	options = options || {};
+	// Compose the state object
+	var self = this;
+	var state = {};
+	state.wiki = options.wiki || self.wiki;
+	state.boot = options.boot || self.boot;
+	state.server = self;
+	state.urlInfo = url.parse(request.url);
+	state.queryParameters = querystring.parse(state.urlInfo.query);
+	state.pathPrefix = options.pathPrefix || this.get("path-prefix") || "";
+	// Enable CORS
+	if(this.corsEnable) {
+		response.setHeader("Access-Control-Allow-Origin", "*");
+		response.setHeader("Access-Control-Allow-Headers", "*");
+		response.setHeader("Access-Control-Allow-Methods", "*");
+		response.setHeader("Access-Control-Expose-Headers", "*");
+	}
+	state.sendResponse = sendResponse.bind(self,request,response);
+	// Get the principals authorized to access this resource
+	state.authorizationType = options.authorizationType || this.methodMappings[request.method] || "readers";
+	// Check for the CSRF header if this is a write
+	if(!this.csrfDisable && state.authorizationType === "writers" && request.headers["x-requested-with"] !== "TiddlyWiki") {
+		response.writeHead(403,"'X-Requested-With' header required to login to '" + this.servername + "'");
+		response.end();
+		return;
+	}
+	// Check whether anonymous access is granted
+	state.allowAnon = this.isAuthorized(state.authorizationType,null);
+	// Authenticate with the first active authenticator
+	if(this.authenticators.length > 0) {
+		if(!this.authenticators[0].authenticateRequest(request,response,state)) {
+			// Bail if we failed (the authenticator will have sent the response)
+			return;
+		}
+	}
+	// Authorize with the authenticated username
+	if(!this.isAuthorized(state.authorizationType,state.authenticatedUsername)) {
+		response.writeHead(401,"'" + state.authenticatedUsername + "' is not authorized to access '" + this.servername + "'");
+		response.end();
+		return;
+	}
+	// Reply to OPTIONS
+	if(this.corsEnable && request.method === "OPTIONS") {
+		response.writeHead(204);
+		response.end();
+		return;
+	}
+	// Find the route that matches this path
+	var route = self.findMatchingRoute(request,state);
+	// Optionally output debug info
+	if(self.get("debug-level") !== "none") {
+		console.log("Request path:",JSON.stringify(state.urlInfo));
+		console.log("Request headers:",JSON.stringify(request.headers));
+		console.log("authenticatedUsername:",state.authenticatedUsername);
+	}
+	// Return a 404 if we didn't find a route
+	if(!route) {
+		response.writeHead(404);
+		response.end();
+		return;
+	}
+	// Receive the request body if necessary and hand off to the route handler
+	if(route.bodyFormat === "stream" || request.method === "GET" || request.method === "HEAD") {
+		// Let the route handle the request stream itself
+		route.handler(request,response,state);
+	} else if(route.bodyFormat === "string" || !route.bodyFormat) {
+		// Set the encoding for the incoming request
+		request.setEncoding("utf8");
+		var data = "";
+		request.on("data",function(chunk) {
+			data += chunk.toString();
+		});
+		request.on("end",function() {
+			state.data = data;
+			route.handler(request,response,state);
+		});
+	} else if(route.bodyFormat === "buffer") {
+		var data = [];
+		request.on("data",function(chunk) {
+			data.push(chunk);
+		});
+		request.on("end",function() {
+			state.data = Buffer.concat(data);
+			route.handler(request,response,state);
+		});
+	} else {
+		response.writeHead(400,"Invalid bodyFormat " + route.bodyFormat + " in route " + route.method + " " + route.path.source);
+		response.end();
+	}
+};
+
+/*
+Listen for requests
+port: optional port number (falls back to value of "port" variable)
+host: optional host address (falls back to value of "host" variable)
+prefix: optional prefix (falls back to value of "path-prefix" variable)
+*/
+Server.prototype.listen = function(port,host,prefix) {
+	var self = this;
+	// Handle defaults for port and host
+	port = port || this.get("port");
+	host = host || this.get("host");
+	prefix = prefix || this.get("path-prefix") || "";
+	// Check for the port being a string and look it up as an environment variable
+	if(parseInt(port,10).toString() !== port) {
+		port = process.env[port] || 8080;
+	}
+	// Warn if required plugins are missing
+	var missing = [];
+	for(var index=0; index<this.requiredPlugins.length; index++) {
+		if(!this.wiki.getTiddler(this.requiredPlugins[index])) {
+			missing.push(this.requiredPlugins[index]);
+		}
+	}
+	if(missing.length > 0) {
+		var error = "Warning: Plugin(s) required for client-server operation are missing.\n"+
+			"\""+ missing.join("\", \"")+"\"";
+		$tw.utils.warning(error);
+	}
+	// Create the server
+	var server;
+	if(this.listenOptions) {
+		server = this.transport.createServer(this.listenOptions,this.requestHandler.bind(this));
+	} else {
+		server = this.transport.createServer(this.requestHandler.bind(this));
+	}
+	// Display the port number after we've started listening (the port number might have been specified as zero, in which case we will get an assigned port)
+	server.on("listening",function() {
+		var address = server.address(),
+			url = self.protocol + "://" + (address.family === "IPv6" ? "[" + address.address + "]" : address.address) + ":" + address.port + prefix;
+		$tw.utils.log("Serving on " + url,"brown/orange");
+		$tw.utils.log("(press ctrl-C to exit)","red");
+	});
+	// Listen
+	return server.listen(port,host);
+};
+
+exports.Server = Server;

package/core-server/utils/base64.js

@@ -0,0 +1,30 @@
+/*\
+title: $:/core-modules/modules/utils/base64.js
+type: application/javascript
+module-type: utils-node
+
+Base64 UTF-8 utlity functions.
+
+\*/
+
+"use strict";
+
+const { TextEncoder, TextDecoder } = require("node:util");
+
+exports.btoa = (binstr) => Buffer.from(binstr, "binary").toString("base64");
+
+exports.atob = (b64) => Buffer.from(b64, "base64").toString("binary");
+
+function base64ToBytes(base64) {
+	const binString = exports.atob(base64);
+	return Uint8Array.from(binString, (m) => m.codePointAt(0));
+};
+
+function bytesToBase64(bytes) {
+	const binString = Array.from(bytes, (byte) => String.fromCodePoint(byte)).join("");
+	return exports.btoa(binString);
+};
+
+exports.base64EncodeUtf8 = (str) => bytesToBase64(new TextEncoder().encode(str));
+
+exports.base64DecodeUtf8 = (str) => new TextDecoder().decode(base64ToBytes(str));

package/core-server/utils/escapecss.js

@@ -0,0 +1,95 @@
+/*\
+title: $:/core-server/modules/utils/escapecss.js
+type: application/javascript
+module-type: utils-node
+
+Provides CSS.escape() functionality.
+
+\*/
+
+"use strict";
+
+exports.escapeCSS = (function() {
+	// see also https://drafts.csswg.org/cssom/#serialize-an-identifier
+
+	/* eslint-disable */
+	/*! https://mths.be/cssescape v1.5.1 by @mathias | MIT license */
+	return function(value) {
+		if (arguments.length == 0) {
+			throw new TypeError('`CSS.escape` requires an argument.');
+		}
+		var string = String(value);
+		var length = string.length;
+		var index = -1;
+		var codeUnit;
+		var result = '';
+		var firstCodeUnit = string.charCodeAt(0);
+		while (++index < length) {
+			codeUnit = string.charCodeAt(index);
+			// Note: there’s no need to special-case astral symbols, surrogate
+			// pairs, or lone surrogates.
+
+			// If the character is NULL (U+0000), then the REPLACEMENT CHARACTER
+			// (U+FFFD).
+			if (codeUnit == 0x0000) {
+				result += '\uFFFD';
+				continue;
+			}
+
+			if (
+				// If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+				// U+007F, […]
+				(codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit == 0x007F ||
+				// If the character is the first character and is in the range [0-9]
+				// (U+0030 to U+0039), […]
+				(index == 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+				// If the character is the second character and is in the range [0-9]
+				// (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+				(
+					index == 1 &&
+					codeUnit >= 0x0030 && codeUnit <= 0x0039 &&
+					firstCodeUnit == 0x002D
+				)
+			) {
+				// https://drafts.csswg.org/cssom/#escape-a-character-as-code-point
+				result += '\\' + codeUnit.toString(16) + ' ';
+				continue;
+			}
+
+			if (
+				// If the character is the first character and is a `-` (U+002D), and
+				// there is no second character, […]
+				index == 0 &&
+				length == 1 &&
+				codeUnit == 0x002D
+			) {
+				result += '\\' + string.charAt(index);
+				continue;
+			}
+
+			// If the character is not handled by one of the above rules and is
+			// greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
+			// is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
+			// U+005A), or [a-z] (U+0061 to U+007A), […]
+			if (
+				codeUnit >= 0x0080 ||
+				codeUnit == 0x002D ||
+				codeUnit == 0x005F ||
+				codeUnit >= 0x0030 && codeUnit <= 0x0039 ||
+				codeUnit >= 0x0041 && codeUnit <= 0x005A ||
+				codeUnit >= 0x0061 && codeUnit <= 0x007A
+			) {
+				// the character itself
+				result += string.charAt(index);
+				continue;
+			}
+
+			// Otherwise, the escaped character.
+			// https://drafts.csswg.org/cssom/#escape-a-character
+			result += '\\' + string.charAt(index);
+
+		}
+		return result;
+	};
+	/* eslint-enable */
+})();

package/core-server/utils/repository.js

@@ -0,0 +1,45 @@
+/*\
+title: $:/core/modules/utils/repository.js
+type: application/javascript
+module-type: utils
+
+Utilities for working with the TiddlyWiki repository file structure
+
+\*/
+"use strict";
+
+/*
+Get an object containing all the plugins as a hashmap by title of the JSON representation of the plugin
+Options:
+
+ignoreEnvironmentVariables: defaults to false
+*/
+exports.getAllPlugins = function(options) {
+	options = options || {};
+	var path = require("path"),
+		tiddlers = {};
+	// Collect up the library plugins
+	var collectPlugins = function(folder) {
+			var pluginFolders = $tw.utils.getSubdirectories(folder) || [];
+			for(var p=0; p<pluginFolders.length; p++) {
+				if(!$tw.boot.excludeRegExp.test(pluginFolders[p])) {
+					var pluginFields = $tw.loadPluginFolder(path.resolve(folder,"./" + pluginFolders[p]));
+					if(pluginFields && pluginFields.title) {
+						tiddlers[pluginFields.title] = pluginFields;
+					}
+				}
+			}
+		},
+		collectPublisherPlugins = function(folder) {
+			var publisherFolders = $tw.utils.getSubdirectories(folder) || [];
+			for(var t=0; t<publisherFolders.length; t++) {
+				if(!$tw.boot.excludeRegExp.test(publisherFolders[t])) {
+					collectPlugins(path.resolve(folder,"./" + publisherFolders[t]));
+				}
+			}
+		};
+	$tw.utils.each($tw.getLibraryItemSearchPaths($tw.config.pluginsPath,options.ignoreEnvironmentVariables ? undefined : $tw.config.pluginsEnvVar),collectPublisherPlugins);
+	$tw.utils.each($tw.getLibraryItemSearchPaths($tw.config.themesPath,options.ignoreEnvironmentVariables ? undefined : $tw.config.themesEnvVar),collectPublisherPlugins);
+	$tw.utils.each($tw.getLibraryItemSearchPaths($tw.config.languagesPath,options.ignoreEnvironmentVariables ? undefined : $tw.config.languagesEnvVar),collectPlugins);
+	return tiddlers;
+};

package/editions/de-AT/tiddlers/external/tiddlywiki.files

@@ -1,9 +1,9 @@
 {
 	"tiddlers": [
 		{
-			"file": "../../../tw5.com/tiddlers/images/New Release Banner.png",
+			"file": "../../../tw5.com/tiddlers/images/New Release Banner.webp",
 			"fields": {
-				"type": "image/jpeg",
+				"type": "image/webp",
 				"title": "New Release Banner",
 				"tags": "picture"
 			}

package/editions/de-AT/tiddlers/system/$__editions_de-AT-DE_download-empty.tid

@@ -4,7 +4,7 @@ title: $:/editions/de-AT-DE/download-empty
 type: text/vnd.tiddlywiki
 
 \define saveTiddlerFilter()
-[[$:/core]] [[$:/isEncrypted]] [[$:/themes/tiddlywiki/snowwhite]] [[$:/themes/tiddlywiki/vanilla]] [[$:/languages/de-DE]] [[$:/languages/de-AT]] [[$:/language]] -[[$:/boot/boot.css]] -[type[application/javascript]library[yes]] -[[$:/boot/boot.js]] -[[$:/boot/bootprefix.js]] +[sort[title]]
+[[$:/core]] [[$:/isEncrypted]] [[$:/themes/tiddlywiki/snowwhite]] [[$:/themes/tiddlywiki/vanilla]] [[$:/languages/de-DE]] [[$:/languages/de-AT]] [[$:/language]] -[[$:/boot/boot.css]] -[type[application/javascript]library[yes]] -[[$:/boot/boot.js]] -[[$:/boot/bootprefix.js]] -[has[plugin-type]field:platform[server]] +[sort[title]]
 \end
 \define savingEmpty()
 yes

package/editions/de-AT/tiddlywiki.info

@@ -20,8 +20,7 @@
 		"index": [
 			"--rendertiddler","$:/core/save/all","index.html","text/plain"],
 		"empty": [
-			"--rendertiddler","$:/editions/de-AT-DE/download-empty","empty.html","text/plain",
-			"--rendertiddler","$:/editions/de-AT-DE/download-empty","empty.hta","text/plain"],
+			"--rendertiddler","$:/editions/de-AT-DE/download-empty","empty.html","text/plain"],
 		"favicon": [
 			"--savetiddler","$:/favicon.ico","favicon.ico"],
 		"static": [

package/editions/de-DE/tiddlywiki.info

@@ -24,8 +24,7 @@
 		"index": [
 			"--rendertiddler","$:/core/save/all","index.html","text/plain"],
 		"empty": [
-			"--rendertiddler","$:/editions/de-AT-DE/download-empty","empty.html","text/plain",
-			"--rendertiddler","$:/editions/de-AT-DE/download-empty","empty.hta","text/plain"],
+			"--rendertiddler","$:/editions/de-AT-DE/download-empty","empty.html","text/plain"],
 		"favicon": [
 			"--savetiddler","$:/favicon.ico","favicon.ico"],
 		"static": [

package/editions/dev/tiddlers/$__StoryList.tid

@@ -0,0 +1,3 @@
+list: [[New Tiddler]] HelloThere Introduction
+title: $:/StoryList
+type: text/vnd.tiddlywiki