tiddlywiki 5.1.21 → 5.2.1

package/editions/de-AT/tiddlers/system/static.content.tid

@@ -1,11 +1,11 @@
 title: $:/core/templates/static.content
 type: text/vnd.tiddlywiki
-hack-to-give-us-something-to-compare-against: yes
 
 \define tv-wikilink-template() https://tiddlywiki.com/static/$uri_doubleencoded$.html
 
 <!-- For Google, and people without JavaScript-->
-<$reveal state="!!hack-to-give-us-something-to-compare-against" type="nomatch" text=<<savingEmpty>>>
+
+<$reveal default="yes" text=<<savingEmpty>> type="nomatch">
 
 Es scheint, dass bei diesem Browser JavaScript deaktiviert wurde. Sie können die statische HTML Version verwenden:
 

package/editions/de-AT/tiddlywiki.info

@@ -9,7 +9,8 @@
 		"tiddlywiki/seamless",
 		"tiddlywiki/centralised",
 		"tiddlywiki/tight",
-		"tiddlywiki/readonly"
+		"tiddlywiki/readonly",
+		"tiddlywiki/internals"
 	],
 	"languages": [
 		"en-GB",
@@ -30,4 +31,4 @@
 			"--rendertiddlers","[!is[system]]","$:/core/templates/static.tiddler.html","static","text/plain",
 			"--rendertiddler","$:/core/templates/static.template.css","static/static.css","text/plain"]
 	}
-}
+}

package/editions/de-AT-server/tiddlywiki.info

@@ -3,7 +3,8 @@
 	"plugins": [
 		"tiddlywiki/tiddlyweb",
 		"tiddlywiki/filesystem",
-		"tiddlywiki/highlight"
+		"tiddlywiki/highlight",
+		"tiddlywiki/internals"
 	],
 	"themes": [
 		"tiddlywiki/vanilla",

package/editions/de-DE/tiddlywiki.info

@@ -9,7 +9,8 @@
 		"tiddlywiki/seamless",
 		"tiddlywiki/centralised",
 		"tiddlywiki/tight",
-		"tiddlywiki/readonly"
+		"tiddlywiki/readonly",
+		"tiddlywiki/internals"
 	],
 	"languages": [
 		"en-GB",
@@ -33,4 +34,4 @@
 			"--rendertiddlers","[!is[system]]","$:/core/templates/static.tiddler.html","static","text/plain",
 			"--rendertiddler","$:/core/templates/static.template.css","static/static.css","text/plain"]
 	}
-}
+}

package/editions/dev/tiddlers/Continuous Deployment.tid

@@ -1,8 +1,8 @@
 created: 20190115173727727
-modified: 20190115173903645
+modified: 20200828094535533
 title: Continuous Deployment
 type: text/vnd.tiddlywiki
 
-TiddlyWiki 5 uses [[Travis CI|https://travis-ci.org/]] for continuous deployment. It is driven by the `.travis.yml` file in the root of the repo, along with the scripts in the `bin` folder that it invokes.
+TiddlyWiki 5 uses [[GitHub Actions|https://docs.github.com/en/actions]] for continuous deployment. It is driven by the workflow file `.github/workflows/ci.yml` in the repo, along with the scripts in the `bin` folder that it invokes.
 
-The build history can be seen at https://travis-ci.org/Jermolene/TiddlyWiki5
+The build history can be seen at https://github.com/Jermolene/TiddlyWiki5/actions

package/editions/dev/tiddlers/HelloThere.tid

@@ -8,11 +8,13 @@ Welcome to the developer documentation for TiddlyWiki (https://tiddlywiki.com/).
 
 * An assignment by Christian Jurke and Christian Heigele, two students working on their Master's degree in Information Technology at the Gießen University of Applied Sciences (Technische Hochschule Mittelhessen). Their work can be seen in the [[Introduction]] and the tiddlers that link from it.
 * New developer documentation
+** [[Data Storage in Single File TiddlyWiki]]
 ** [[Continuous Deployment]]
 ** [[GitHub Branches]]
 ** HookMechanism
 ** [[Using ES2016 for Writing Plugins]]
 ** [[Adding Babel Polyfill to TiddlyWiki]]
+** [[TiddlyWiki Drag and Drop Interoperability]]
 * The original developer documentation from https://tiddlywiki.com:
 ** [[TiddlyWiki for Developers]]
 ** [[TiddlyWiki Coding Style Guidelines]]
@@ -29,4 +31,4 @@ Welcome to the developer documentation for TiddlyWiki (https://tiddlywiki.com/).
 ** [[Scripts for building tiddlywiki.com]]
 ** SyncAdaptorModules
 ** WidgetModules
-** WikiRuleModules
+** WikiRuleModules

package/editions/dev/tiddlers/build/Releasing a new version of TiddlyWiki.tid

@@ -7,9 +7,10 @@ type: text/vnd.tiddlywiki
 
 # Ensure the new release banner image is up to date
 # Update ''master'' with changes from ''tiddlywiki-com''
-# Verify the version numbers in [[$:/config/OfficialPluginLibrary]] in `editions/tw5.com`
+# Verify the version numbers in [[$:/config/OfficialPluginLibrary]] in `core/wiki/config/OfficialPluginLibrary.tid`
 # Move the latest release note from the prerelease edition into the tw5.com edition
 # Adjust the release date and the ''released'' field of the latest release tiddler (eg, [[Release 5.1.3]])
+# Also adjust the github.com comparison link to point to the tag for the new release
 # Ensure [[TiddlyWiki Releases]] has the new version as the default tab
 # Adjust the modified time of HelloThere
 # Make sure ''master'' is fully committed
@@ -42,5 +43,4 @@ type: text/vnd.tiddlywiki
 # Adjust version number in [[$:/config/OfficialPluginLibrary]] (both in `editions/tw5.com` and `editions/prerelease/tiddlers/system`) and [[$:/config/LocalPluginLibrary]]
 # Adjust new release banner
 # Create the release note for the new release
-# Adjust version number in https://github.com/Jermolene/build.jermolene.github.io in `prerelease-bld.sh`, `bld.sh` and `make-library-bld.sh`
 # Commit changes to ''master'' and push to ~GitHub

package/editions/dev/tiddlers/from Heigele and Jurke/Data-Storage.tid

@@ -3,12 +3,4 @@ modified: 20140710081051087
 tags: doc
 title: Data-Storage
 
-TW has two approaches to save the user data. These approaches depends on way you use TW. either you use node.js as a server for TW its saves the tiddlers as plain text in different files or you use TW as standalone in a browser it persists the data within the HTML-File in two Div-Areas depending on whether the encryption of the TiddlyWiki is activated or not. If the TiddlyWiki is not encrypted the data is stored in the Div-Area called "~StoreArea". Every created Tiddler is stored in a own Div-area with a few custom values. An example of a saved Tiddler is shown below (\prettyref{lst:data-div}). 
-
-```html
-<div created="20140611153703343" modified="20140611153734589" tags="testTag" testfield="testvalue" title="TestTiddler" type="text/plain">
-	<pre>testText</pre>
-</div>
-```
-The Div-Area has the same attributes like the standard tillder fields, listed in  [[TiddlerFields|https://tiddlywiki.com/#TiddlerFields]], all attributes which are not in this list are parsed as a custom field. The only required attribute is the name attribute, all other attributes are optional.\\
-With a activated encryption the data is stored in a special Div-Area called "encryptedStoreArea". TiddlyWiki uses the Standford [[JavaScript Crypto Libary|http://bitwiseshiftleft.github.io/sjcl/]]. The encrypted Tiddlers are saved in a JSON string within this Div-Area.
+{{Data Storage}}

package/editions/dev/tiddlers/from Heigele and Jurke/wikimethod module type.tid

@@ -1,5 +1,6 @@
 created: 20140710185051844
-modified: 20140710185339032
+modified: 20201002010124844
 title: wikimethod module type
+tags: moduletypes
 
-The startup module [[$:/core/modules/startup/load-modules.js]]  in the TiddlyWiki core plug-in loads all modules of type``wikimethod`` and puts their exported functions into the wiki store.
+The startup module [[$:/core/modules/startup/load-modules.js]]  in the TiddlyWiki core plug-in loads all modules of type``wikimethod`` and puts their exported functions into the wiki store.

package/editions/dev/tiddlers/from tw5.com/How to create plugins in the browser.tid

@@ -31,7 +31,7 @@ Click the link to the plugin tiddler to open it. Assuming it doesn't currently e
 |!Field |!Value |
 |''dependents'' |Space separated list of dependent plugins (use square brackets for titles containing spaces) |
 |''description'' |Plugin description |
-|''name'' |Plugin name (only needed for themes) |
+|''name'' |Plugin name |
 |''plugin-type'' |Either "plugin" for a regular plugin, "theme" for a theme, or "language" for a language pack |
 |''type'' |Set to "application/json" |
 |''version'' |Set to the version number of the plugin (eg "0.0.1") |

package/editions/dev/tiddlers/from tw5.com/moduletypes/SyncAdaptorModules.tid

@@ -1,5 +1,5 @@
 created: 20130825162100000
-modified: 20140814094907624
+modified: 20201025162413404
 tags: dev moduletypes
 title: SyncAdaptorModules
 type: text/vnd.tiddlywiki
@@ -14,6 +14,8 @@ SyncAdaptorModules encapsulate storage mechanisms that can be used by the SyncMe
 
 SyncAdaptorModules are represented as JavaScript tiddlers with the field `module-type` set to `syncadaptor`.
 
+See [[this pull request|https://github.com/Jermolene/TiddlyWiki5/pull/4373]] for background on the evolution of this API.
+
 ! Exports
 
 The following properties should be exposed via the `exports` object:
@@ -25,7 +27,13 @@ Nothing should be exported if the adaptor detects that it isn't capable of opera
 
 ! Adaptor Module Methods
 
-Adaptor modules must handle the following methods.
+Adaptor modules must handle the methods described below.
+
+!!! Error Handling
+
+The syncadaptor must invoke the provided callback with the ''err'' parameter containing a string describing the error.
+
+The syncer has special handling for connection errors. For backwards compatibilty reasons, the syncer identifies connection errors as the string comprised of the content of the tiddler $:/language/Error/XMLHttpRequest with the string ": 0" appended to the end. For example, in English, the string is "XMLHttpRequest error code: 0" and in Brazilian Portuguese it is "Código de erro XMLHttpRequest: 0".
 
 !! `Constructor(options)`
 
@@ -47,12 +55,21 @@ Gets the supplemental information that the adaptor needs to keep track of for a
 
 Returns an object storing any additional information required by the adaptor.
 
+!! `getTiddlerRevision(title)`
+
+Gets the revision ID associated with the specified tiddler title.
+
+|!Parameter |!Description |
+|title |Tiddler title |
+
+Returns a revision ID.
+
 !! `getStatus(callback)`
 
 Retrieves status information from the server. This method is optional.
 
 |!Parameter |!Description |
-|callback |Callback function invoked with parameters `err,isLoggedIn,username` |
+|callback |Callback function invoked with parameters `err,isLoggedIn,username,isReadOnly` |
 
 !! `login(username,password,callback)`
 
@@ -63,6 +80,15 @@ Attempts to login to the server with specified credentials. This method is optio
 |password |Password |
 |callback |Callback function invoked with parameter `err` |
 
+!! `displayLoginPrompt(syncer)`
+
+Invoked by the syncer to display a custom login prompt. This method is optional.
+
+|!Parameter |!Description |
+|syncer |Reference to the syncer object making the call |
+
+The custom login prompt should send the widget message `tm-login` with the username and password in parameters ''username'' and ''password''.
+
 !! `logout(callback)`
 
 Attempts to logout of the server. This method is optional.
@@ -70,16 +96,39 @@ Attempts to logout of the server. This method is optional.
 |!Parameter |!Description |
 |callback |Callback function invoked with parameter `err` |
 
+!! `getUpdatedTiddlers(syncer,callback)`
+
+Retrieves the titles of tiddlers that need to be updated from the server.
+
+This method is optional. If an adaptor doesn't implement it then synchronisation will be unidirectional from the TiddlyWiki store to the adaptor, but not the other way.
+
+The syncer will use the `getUpdatedTiddlers()` method in preference to the `getSkinnyTiddlers()` method.
+
+|!Parameter |!Description |
+|syncer |Reference to the syncer object making the call |
+|callback |Callback function invoked with parameter `err,data` -- see below |
+
+The data provided by the callback is as follows:
+
+```
+{
+modifications: [<array of title>],
+deletions: [<array of title>],
+}
+```
+
 !! `getSkinnyTiddlers(callback)`
 
 Retrieves a list of skinny tiddlers from the server.
 
 This method is optional. If an adaptor doesn't implement it then synchronisation will be unidirectional from the TiddlyWiki store to the adaptor, but not the other way.
 
+The syncer will use the `getUpdatedTiddlers()` method in preference to the `getSkinnyTiddlers()` method.
+
 |!Parameter |!Description |
 |callback |Callback function invoked with parameter `err,tiddlers`, where `tiddlers` is an array of tiddler field objects |
 
-!! `saveTiddler(tiddler,callback,tiddlerInfo)`
+!! `saveTiddler(tiddler,callback)`
 
 Saves a tiddler to the server.
 
@@ -96,11 +145,16 @@ Loads a tiddler from the server.
 |title |Title of tiddler to be retrieved |
 |callback |Callback function invoked with parameter `err,tiddlerFields` |
 
-!! `deleteTiddler(title,callback,tiddlerInfo)`
+!! `deleteTiddler(title,callback,options)`
 
 Delete a tiddler from the server.
 
 |!Parameter |!Description |
 |title |Title of tiddler to be deleted |
 |callback |Callback function invoked with parameter `err` |
+|options |See below |
+
+The options parameter contains the following properties:
+
+|!Property |!Description |
 |tiddlerInfo |The tiddlerInfo maintained by the syncer for this tiddler |

package/editions/dev/tiddlers/from tw5.com/moduletypes/WikiRuleModules.tid

@@ -1,11 +1,11 @@
-created: 201308252147
-modified: 201311011307
+created: 20130825214700000
+modified: 20210121054620146
 tags: dev moduletypes
 title: WikiRuleModules
 
-WikiRuleModules cover the module types `wikirunrule`, `wikiblockrule` and `wikipragmarule`. Modules of these types encapsulate the logic of individual parsing rules used by the WikiParser engine. For example, there is a `wikirunrule` module that identifies references to HTML entities by matching the pattern `&<chars>;`.
+WikiRuleModules have a `module-type` of `wikirule`, and may have following types: `pragma`, `block`, `inline`. Modules of these types encapsulate the logic of individual parsing rules used by the WikiParser engine. For example, `entity.js` rule module identifies references to HTML entities by matching the pattern `&<chars>;`.
 
-Pragma rules are applied at the start of a block of text, and cover definitions and declarations that affect the parsing of the rest of the text. Block rules are only applied at the beginning of a block of wikitext, while run rules can appear anywhere. The only current example of a pragma rule is for macro definitions.
+Pragma rules are applied at the start of a block of text, and cover definitions and declarations that affect the parsing of the rest of the text. Block rules are only applied at the beginning of a block of wikitext, while inline rules can appear anywhere. The only current example of a pragma rule is for macro definitions.
 
 Examples of block rules:
 
@@ -13,7 +13,7 @@ Examples of block rules:
 * Tables
 * Lists
 
-Examples of run rules:
+Examples of inline rules:
 
 * Entities
 * HTML tags
@@ -24,6 +24,7 @@ Parser rule modules extend the `$tw.WikiParserRule` class. This is done by insta
 The standard methods and properties of parser rules are as follows:
 
 * `name`: a string containing the name of this parse rule
+* `types`: an object that defines the module's type. For example, `exports.types = {block: true};`
 * `init(parser)`: initialisation function called immediately after the constructor with a pointer back to the parser containing this rule
 * `findNextMatch(pos)`: returns the position of the next match after the specified position
 * `parse()`: parses the most recent match, returning an array of the generated parse tree nodes. Pragma rules don't return parse tree nodes but instead modify the parser object directly (for example, to add local macro definitions)

package/editions/dev/tiddlers/indexer modules.tid

@@ -0,0 +1,55 @@
+created: 20201002010134640
+modified: 20201002012758239
+tags: moduletypes dev
+title: indexer modules
+
+Indexer modules maintain indexes of tiddlers organized in a manner that's more efficient for different types of access, typically to speed up things like certain filter operators.  An example of this would be the tag indexer - it's much faster to maintain a lookup table listing which tiddlers have a given tag than to iterate over //all// of the tiddlers in a wiki and ask each of them if they have the tag you're interested in!
+
+Indexer modules have a `module-type` of `indexer`, and the indexers that are included with TiddlyWiki can be found under `core/modules/indexers`.
+
+! Methods
+
+Indexer modules must export a constructor function, which takes the current wiki object as its only argument.  The object built by the construction function must implement the following methods:
+
+!! `init()`
+
+This performs any initial setup required by an indexer.
+
+!! `rebuild()`
+
+This rebuilds an index from scratch, usually after a large number of changes have happened to a wiki.
+
+!! `update(updateDescriptor)`
+
+This is called every time a tiddler is added, changed, or deleted.  The `updateDescriptor` value is an object with two fields - `old` and `new` - which represent the pre-update and post-update state of the tiddler, respectively.  Each of these has three fields of their own:
+
+  * `tiddler` - the state of the tiddler (may be `null`)
+  * `shadow` - a boolean indicating whether or not the tiddler is a shadow
+  * `exists` - a boolean indicating whether or not the tiddler exists
+
+For example, let's say you have an indexer `idx` and you create a tiddler T with the text "test" - that would result in your indexer's `update` method being called like this:
+
+```javascript
+idx.update({
+  old: { tiddler: null, shadow: false, exists: false },
+  new: { tiddler: new $tw.Tiddler({title: 'T', text: 'test'}), shadow: false, exists: true }
+});
+```
+
+If you then change the text from "test" to "testing", `update` would be called like this:
+
+```javascript
+idx.update({
+  old: { tiddler: new $tw.Tiddler({title: 'T', text: 'test'}), shadow: false, exists: true },
+  new: { tiddler: new $tw.Tiddler({title: 'T', text: 'testing'}), shadow: false, exists: true }
+});
+```
+
+And finally, if you delete T, `update` will be called like this:
+
+```javascript
+idx.update({
+  old: { tiddler: new $tw.Tiddler({title: 'T', text: 'testing'}), shadow: false, exists: true },
+  new: { tiddler: null, shadow: false, exists: false }
+});
+```

package/editions/dev/tiddlers/new/Data Storage in Single File TiddlyWiki.tid

@@ -0,0 +1,100 @@
+created: 20210525165258247
+modified: 20210614134705320
+tags: Data-Storage doc [[Data Storage]]
+title: Data Storage in Single File TiddlyWiki
+
+The single file version of ~TiddlyWiki saves the tiddlers within the HTML file. 
+
+Version 5.2.0 of ~TiddlyWiki introduced a new format for how tiddlers are saved within the HTML file.
+
+
+---
+
+!! Up to and including ~TiddlyWiki v5.1.23
+
+Tiddlers are saved within the HTML file in one of two `<div>` tags depending on whether the TiddlyWiki is configured to encrypt its content or not. 
+
+!!! Without encryption
+If the ~TiddlyWiki is not encrypted the data is stored in a `<div>` tag with an `id` attribute of "storeArea".
+
+```html
+<div id="storeArea" style="display:none;">
+```
+
+Within the store area `<div>`, each tiddler is stored in its own div. 
+
+//Tiddler DIV//
+
+Each tiddler `<div>` has an attribute corresponding to each of the tiddler's fields, except the text field which is saved within a `pre` tag within the `<div>`. Note that all attributes and therefore field names must be lowercase letters, digits or the characters `-` (dash), `_` (underscore) and `.` (period). The only attribute that is required is `title`, all other attributes are optional. All attribute values and the text field within the `pre` tag are HTML encoded.
+
+Example:
+
+```html
+<div id="storeArea" style="display:none;">
+<div created="20140611153703343" modified="20140611153734589" tags="testTag" testfield="testvalue" title="TestTiddler" type="text/plain">
+<pre>testText</pre>
+</div>
+</div>
+```
+
+!!! With encryption
+
+If the ~TiddlyWiki is configured to encrypt its content, the tiddlers are stored as as an encrypted JSON string in a `<pre>` tag with the `id` attribute "encryptedStoreArea". 
+
+```html
+<pre id="encryptedStoreArea" type="text/plain" style="display:none;">
+```
+
+~TiddlyWiki uses the [[Stanford JavaScript Crypto Library|http://bitwiseshiftleft.github.io/sjcl/]]. 
+
+---
+
+!! From ~TiddlyWiki v5.2.0
+
+From v5.2.0 onwards, ~TiddlyWiki introduces a new JSON based format for the tiddler store area for unencrypted content, while retaining support for the older store area formats described above for backwards compatibility. The store area format remains unchanged for encrypted content.
+
+
+!!! Without encryption
+
+By default, all tiddlers are now stored as an array of JSON objects inside a `<script>` tag with the `class` attribute "tiddlywiki-tiddler-store" and the `type` "application/json". For better readability, every tiddler object begins on a new line. There are no longer any restrictions on characters that are allowed in tiddler field names. However, `<script>` tag store areas must encode the `<` character to `\u003c`.
+
+```html
+<script class="tiddlywiki-tiddler-store" type="application/json">[
+{"title":"XLSX Utilities Edition","created":"20161023202301847","modified":"20161023202301847","tags":"Editions","type":"text/vnd.tiddlywiki","text":"The ''XLSX Utilities'' edition of TiddlyWiki contains tools to work with `.XLSX` spreadsheets generated by applications like Microsoft Excel and Google Sheets. It can be used in the browser or under Node.js.\n\nhttps://tiddlywiki.com/editions/xlsx-utils/\r\n"},
+{"text":"In accordance with the [[Philosophy of Tiddlers]], documentation tiddlers are typically short and interlinked.\n\nWhen a tiddler seems as if it needs to contain subheadings, this is often a sign that it should in fact be split into several tiddlers. But it is reasonable for a [[reference tiddler|Reference Tiddlers]] to consist of an untitled introductory section followed by a titled section of details.\n\nConsistency of terminology is essential if the reader is not to become confused. Consistent typography and punctuation lend a professional quality to the documentation. Macros can improve the consistency and maintainability of the text.\n\nUse numbered lists for step-by-step instructions, and bullet points for lists whose order is arbitrary. Use a definition list in preference to a bulleted list if each bulleted item would begin with a term and a colon. If at all possible, avoid burdening the reader with a nested list.\n\nUse a table when information naturally falls into three or more columns, and also for lists of parameters, attributes, etc in [[reference tiddlers|Reference Tiddlers]].\n\nAvoid periods at the end of list items, headings and table cell text.\n\nThe documentation describes the current reality of ~TiddlyWiki. Avoid discussing future aspirations.\n","title":"Tiddler Structure","tags":"[[Improving TiddlyWiki Documentation]]","modified":"20210207124737959","created":"20150110183300000"}
+]</script>
+```
+
+To retain compatibility with external tools that might insert tiddlers by directly manipulating the ~TiddlyWiki HTML file, the older format `<div>` store area is still present in the HTML file immediately after the new `<script>` tag store area:
+
+
+```html
+<script class="tiddlywiki-tiddler-store" type="application/json">[
+{"title":"XLSX Utilities Edition","created":"20161023202301847","modified":"20161023202301847","tags":"Editions","type":"text/vnd.tiddlywiki","text":"The ''XLSX Utilities'' edition of TiddlyWiki contains tools to work with `.XLSX` spreadsheets generated by applications like Microsoft Excel and Google Sheets. It can be used in the browser or under Node.js.\n\nhttps://tiddlywiki.com/editions/xlsx-utils/\r\n"},
+{"text":"In accordance with the [[Philosophy of Tiddlers]], documentation tiddlers are typically short and interlinked.\n\nWhen a tiddler seems as if it needs to contain subheadings, this is often a sign that it should in fact be split into several tiddlers. But it is reasonable for a [[reference tiddler|Reference Tiddlers]] to consist of an untitled introductory section followed by a titled section of details.\n\nConsistency of terminology is essential if the reader is not to become confused. Consistent typography and punctuation lend a professional quality to the documentation. Macros can improve the consistency and maintainability of the text.\n\nUse numbered lists for step-by-step instructions, and bullet points for lists whose order is arbitrary. Use a definition list in preference to a bulleted list if each bulleted item would begin with a term and a colon. If at all possible, avoid burdening the reader with a nested list.\n\nUse a table when information naturally falls into three or more columns, and also for lists of parameters, attributes, etc in [[reference tiddlers|Reference Tiddlers]].\n\nAvoid periods at the end of list items, headings and table cell text.\n\nThe documentation describes the current reality of ~TiddlyWiki. Avoid discussing future aspirations.\n","title":"Tiddler Structure","tags":"[[Improving TiddlyWiki Documentation]]","modified":"20210207124737959","created":"20150110183300000"}
+]</script><div id="storeArea" style="display:none;"></div>
+```
+
+Any tiddlers in the older format `<div>` store area are also loaded before tiddlers from the new `<script>` store area. 
+
+!!! Multiple store areas and precedence
+
+Tiddlers from the new `<script>` tag store areas are loaded in the order of their store areas in the HTML file. Therefore if the same tiddler exists in two different `<script>` tag store areas, the tiddler from the later store area takes precedence. Note however that tiddlers from `<script>` tag store areas always take precedence over tiddlers from the older format  `<div>` store area. Therefore a tiddler from the older `<div>` store area can never overwrite a tiddler from  a `<script>` tag store area.
+
+Note that all `<script>` tags with the `class` attribute "tiddlywiki-tiddler-store" that precede the `$:/boot.js` module in the HTML file will have their content parsed as JSON and loaded as tiddlers.
+
+This allows external tools to easily insert tiddlers into an HTML file by prepending an additional `<script>` tag(s) at the very start of the HTML file:
+
+```html
+<script class="tiddlywiki-tiddler-store" type="application/json">[
+{"created":"20210525212411223","text":"This is some test text","tags":"[[test tag]] [[another tag]]","title":"My new tiddler to insert","modified":"20210525212430577"}
+]</script>
+<!doctype html>
+...
+```
+
+Although invalid HTML, all known browsers will silently move the script tag to a valid position within the 
+
+Additional topics:
+
+* [[Extracting tiddlers from a single file TiddlyWiki]]

package/editions/dev/tiddlers/new/Data Storage.tid

@@ -0,0 +1,10 @@
+created: 20140708085814626
+modified: 20210525165526997
+tags: doc
+title: Data Storage
+
+~TiddlyWiki has two approaches to saving the user data (tiddlers) depending on whether you are using the single file version, or are using the node.js server.
+
+~TiddlyWiki on node.js saves each tiddler in a separate text file. For details on the file formats supported for tiddlers on node.js, see [[Tiddler Files|https://tiddlywiki.com/#TiddlerFiles]].
+
+The single file version of ~TiddlyWiki saves the tiddlers within the HTML file. See [[Data Storage in Single File TiddlyWiki]]

package/editions/dev/tiddlers/new/HookMechanism.tid

@@ -1,17 +1,30 @@
 created: 20141122200310516
-modified: 20170209130807520
+modified: 20201213161842776
 title: HookMechanism
 type: text/vnd.tiddlywiki
 
 The hook mechanism provides a way for plugins to intercept and modify default functionality. Hooks are added as follows:
 
 ```js
+/*
+name: name of hook function (by convention prefixed with `th-`)
+handler: function to be called when hook is invoked
+*/
 $tw.hooks.addHook(name,handler);
 ```
 
+The handler function will be called with parameters that depend on the specific hook in question, but they always follow the pattern `handler(value,params...)`
+
+* ''value'': an optional value that is to be transformed by the hook function
+* ''params'': one or more optional parameters that are passed to the hook function
+
+If required by the hook in question, the handler function must return the modified ''value''.
+
 Multiple handlers can be assigned to the same name using repeated calls. When a hook is invoked by name all registered functions will be called sequentially in their order of addition.
 
-Though not essential care should be taken to ensure that hooks are added before they are invoked. For example: [[Hook: tc-opening-default-tiddlers-list]] should ideally be added before the story startup module is invoked otherwise any hook specified additions to the default tiddlers will not be seen on the initial loading of the page, though will be visible if the user clicks the home button.
+Note that the ''value'' passed to the subsequent hook function will be the return value of the previous hook function.
+
+Though not essential care should be taken to ensure that hooks are added before they are invoked. For example: [[Hook: th-opening-default-tiddlers-list]] should ideally be added before the story startup module is invoked otherwise any hook specified additions to the default tiddlers will not be seen on the initial loading of the page, though will be visible if the user clicks the home button.
 
 !! Example
 

package/editions/dev/tiddlers/new/Hook_ th-before-importing.tid

@@ -0,0 +1,68 @@
+created: 20210203184649726
+modified: 20210208152038746
+tags: HookMechanism
+title: Hook: th-before-importing
+type: text/vnd.tiddlywiki
+
+This hook allows plugins to inspect or modify the `importTiddler` object ''before'' any tiddlers are imported. It is invoked after the final "Import" button is clicked, but ''before'' the selected tiddlers are being imported into the store.
+
+''Intended Usecases'':
+
+* Manipulate the import "selection state"
+* Eg: create a customized "log-tiddler" that contains a heading, that should only be written once
+
+''Important'': 
+
+* This hook ''should not'' be used to manpulate the `importTiddler.fields.text` element!
+* If you want to give the users a possibility to verify the imported data, use ùpgraders like: `$:/core/modules/upgraders/` instead
+* If you need to manipulate the imported tiddler content, without default user interaction, consider: [[Hook: th-importing-tiddler]] instead
+
+The hook is part of the `NavigatorWidget.prototype.handlePerformImportEvent` function.
+
+Hook function parameters:
+
+* ''importTiddler'': an object, that contains information about "selected / unselected" tiddlers and more
+
+Return value:
+
+* ''importTiddler'': object
+
+The hook must return the `importTiddler` object. For many usecases the object will be returned unmodified.
+
+''Example code how to implement a hook in your project''
+
+```
+/*\
+title: $:/plugins/<author>/<plugin>/th-before-importing.js
+type: application/javascript
+module-type: startup
+
+YOUR DISCRCRIPTION COMES HERE!
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false, exports: true */
+"use strict";
+
+// Export name and synchronous status
+exports.name = "<yournamecomesherewithoutspaces>";
+exports.platforms = ["browser"];
+exports.after = ["startup"];
+exports.synchronous = true;
+
+// Define your variables here!
+
+exports.startup = function() {
+	$tw.hooks.addHook("th-before-importing",function(importTiddler) {
+
+// YOUR CODE !
+
+		return importTiddler;
+	});
+};
+
+})();
+
+```

package/editions/dev/tiddlers/new/Hook_ th-closing-tiddler.tid

@@ -0,0 +1,20 @@
+created: 20210623075733310
+modified: 20210623081959571
+tags: HookMechanism
+title: Hook: th-closing-tiddler
+type: text/vnd.tiddlywiki
+
+This hook allows plugins to monitor the closing of a tiddler from the story.
+
+Hook function parameters:
+
+* ''event'': Widget message object with the following properties:
+** ''event'': DOM event object that triggered the widget message
+** ''tiddlerTitle'': the title of the tiddler being closed
+** ''widget'': reference to the widget that sent the message.
+
+Return value:
+
+* ''event'': Widget message object
+
+The original event widget message object can be returned unmodified by the hook. 

package/editions/dev/tiddlers/new/Hook__th-importing-tiddler.tid

@@ -1,11 +1,13 @@
 created: 20170209130829546
-modified: 20171010115148355
+modified: 20210203190724491
 tags: HookMechanism
 title: Hook: th-importing-tiddler
 type: text/vnd.tiddlywiki
 
 This hook allows plugins to inspect or modify tiddlers as they are imported via the import mechanism. It is invoked when the final "Import" button is clicked, and the selected tiddlers are being imported into the store.
 
+The hook is part of the `NavigatorWidget.prototype.handlePerformImportEvent` function.
+
 Use this hook if you want to process each imported tiddler after they have been extracted from the files.  See [[Hook: th-importing-file]] if you want to control how tiddlers are extracted from files during an import.
 
 Hook function parameters: