@zakkzhang/tw5-graph 1.6.4

package/plugins/graph/macros/edges.typed.tid

@@ -0,0 +1,54 @@
+\widget $edges.typed($editable:no)
+\whitespace trim
+<$parameters
+	$$functions={{{ [<functionsFilter>!is[blank]] ~"[all[]]" }}}
+	$$fields={{{ [<fieldsFilter>!is[blank]] ~"[all[]]" }}}
+	$$tiddler=<<currentTiddler>> >
+
+<!-- First create edges for field types -->
+
+<$list variable=fieldName filter="+[subfilter{$:/plugins/flibbles/graph/subfilters##edgetypes.fields}subfilter<$fields>]">
+
+<$let
+	dataTiddler=`$:/config/flibbles/graph/edges/fields/$(fieldName)$` >
+
+<$properties $for=edges
+	$tiddler=<<dataTiddler>>
+	delete={{{ [<$editable>!match[no]then[<$action-removetyped $tiddler=<<fromTiddler>> $field=<<fieldName>> $value=<<toTiddler>> />]] }}} >
+
+
+<$list variable=toTiddler counter=index filter="[<$tiddler>] :map:flat[gettyped<fieldName>] +[!is[blank]]">
+
+<$vars id=`$:/edge/fields/$($tiddler)$
+$(fieldName)$-$(index)$`>
+
+<$slot $name=ts-raw>
+
+<$edge $from=<<$tiddler>> $id=<<id>> />
+
+</$slot></$vars></$list></$properties></$let></$list>
+
+<!-- Now create edges for function types -->
+
+<$list variable=functionName filter="[subfilter{$:/plugins/flibbles/graph/subfilters##edgetypes.functions}subfilter<$functions>]">
+
+<$let
+	dataTiddler=`$:/config/flibbles/graph/edges/functions/$(functionName)$`
+	function={{{ [<dataTiddler>get[filter]] }}} >
+
+<$properties $for=edges
+	$tiddler=<<dataTiddler>> >
+
+<$list variable=toTiddler counter=index filter="[<$tiddler>] :map:flat[subfilter<function>] +[!is[blank]]">
+
+<$vars id=`$:/edge/functions/$($tiddler)$
+$(functionName)$-$(index)$`>
+
+<$slot $name=ts-raw>
+
+<$edge $from=<<$tiddler>> $id=<<id>> />
+
+</$slot></$vars></$list></$properties></$let></$list>
+\end
+
+\relink $edges.typed $functions:filter $fields:filter $tiddler:title

package/plugins/graph/macros/graph.view.tid

@@ -0,0 +1,24 @@
+\widget $graph.view($tiddler:"$:/graph/Default", $mode)
+\whitespace trim
+<$parameters
+	$params=viewParams
+	$parseMode=$defaultMode
+	$$template={{{ [<$tiddler>get[template]] ~[[$:/tags/flibbles/graph/Template]tagging[]first[]] }}}
+	$$engine={{{ [<$tiddler>get[engine]] ~[<graphengine>] }}} >
+
+<$vars
+	currentTiddler=<<$tiddler>>
+	graphengine=<<$engine>> >
+
+<$genesis
+	$type="$transclude"
+	$$tiddler=<<$template>>
+	$$fillignore=yes
+	$$mode={{{ [<$mode>!is[blank]else<$defaultMode>] }}}
+	$names="[<viewParams>jsonindexes[]!prefix[$]]"
+	$values="[<viewParams>jsonindexes[]!prefix[$]] :map[<viewParams>jsonget{!!title}]" />
+
+</$vars></$parameters>
+\end
+
+\relink $graph.view $tiddler

package/plugins/graph/macros/node.default.tid

@@ -0,0 +1,9 @@
+\widget $node.default()
+<$wikify name=label
+	mode=inline
+	text={{{ [{!!title}get[caption]else[<$text text={{!!title}} />]] }}} >
+
+  <$node $pos=<<pos>> label=<<label>> color={{!!color}} image={{!!icon}} />
+
+</$wikify>
+\end

package/plugins/graph/macros/nodes.neighbors.tid

@@ -0,0 +1,62 @@
+\widget $nodes.neighbors($filter, $fields:'[all[]]', $functions:'[all[]]', $interedges, $whitelist:'[!is[system]]')
+
+<!-- None of these \procedures are \functions because that mucks with caching. -->
+\procedure filter.cached() [{!!title}] :cache[all[tiddlers]subfilter<$filter>]
+
+<!-- Holy nuts this is getting complicated, but we need to :map:flat twice
+     in order to switch ..currentTiddler and currentTiddler, as the fields
+     and functions will expect it. -->
+\procedure edges.fields.flipped() [<..currentTiddler>] :map:flat[<currentTiddler>gettyped<..currentTiddler>]
+\procedure edges.functions.flipped() [<..currentTiddler>] :map:flat[<currentTiddler>subfilter<..currentTiddler>]
+
+\procedure edges.fields() :cache[subfilter{$:/plugins/flibbles/graph/subfilters##edgetypes.fields}subfilter<$fields>] :map:flat[<..currentTiddler>subfilter<edges.fields.flipped>]
+\procedure edges.functions() :cache[subfilter{$:/plugins/flibbles/graph/subfilters##edgetypes.functions}subfilter<$functions>addprefix[$:/config/flibbles/graph/edges/functions/]get[filter]] :map:flat[<..currentTiddler>subfilter<edges.functions.flipped>]
+
+\procedure neighbors.for() [subfilter<edges.fields>] [subfilter<edges.functions>] +[!is[blank]unique[]]
+\procedure neighbors.cached() [all[]] :cache[subfilter<neighbors.for>]
+
+\procedure incoming.raw() [all[tiddlers]subfilter<$whitelist>!search:title:regexp,casesensitive<regexp>] :filter[subfilter<neighbors.cached>search:title:regexp,casesensitive<regexp>]
+\procedure incoming.cached() :cache[subfilter<incoming.raw>]
+\whitespace trim
+
+<$vars
+	regexp={{{ [subfilter<filter.cached>escaperegexp[]join[|]addprefix[^(?:]addsuffix[)$]] }}}
+	functionsFilter=<<$functions>>
+	fieldsFilter=<<$fields>> >
+
+<!-- incoming neighbors -->
+
+<$list filter=<<incoming.cached>> >
+
+<$slot $name=ts-raw>
+
+<$node.default />
+
+</$slot>
+
+<$edges.typed>
+
+<%if [<$interedges>match[yes]] ~[<toTiddler>search:title:regexp,casesensitive<regexp>] %>
+
+<$edge $id=<<id>> />
+
+<%endif%></$edges.typed></$list>
+
+<!-- outgoing neighbors -->
+
+<$list filter="[subfilter<filter.cached>subfilter<neighbors.cached>subfilter<$whitelist>!search:title:regexp,casesensitive<regexp>] -[subfilter<incoming.cached>]">
+
+<$slot $name=ts-raw>
+
+<$node.default />
+
+</$slot>
+
+<%if [<$interedges>match[yes]] %>
+
+<$edges.typed />
+
+<%endif%></$list>
+\end
+
+\relink $nodes.neighbors $filter:filter $fields:filter $functions:filter $whitelist:filter

package/plugins/graph/macros/nodes.writable.tid

@@ -0,0 +1,37 @@
+\widget $nodes.writable($field, $variable:currentTiddler)
+
+\procedure actionAddnode()
+\whitespace trim
+<$action-modal $tiddler="$:/plugins/flibbles/graph/ui/Modals/SelectTiddler">
+  <% if [<selection>!is[tiddler]] %>
+    <$action-createtiddler $basetitle=<<selection>> />
+  <% endif %>
+  <% if [<$field>!match[]] %>
+    <$action-addtyped $tiddler=<<$tiddler>> $field=<<$field>> $value=<<selection>> />
+  <% endif %>
+  <$transclude $variable=recordPosition title=<<selection>> />
+</$action-modal>
+<$action-sendmessage $message=tm-focus-selector $param="input.graph-select" />
+\end actionAddnode
+
+\whitespace trim
+<$parameters $$tiddler={{!!title}}>
+
+<$properties $for=graph
+	doubleclick=<<actionAddnode>>
+	addNode=<<actionAddnode>>
+	drop="""<$action-addtyped $tiddler=<<$tiddler>> $field=<<$field>> $value=<<dropTiddler>> />"""
+	addEdge="""<$action.addedge/>"""
+/>
+
+<$properties delete="<$action-removetyped $tiddler=<<$tiddler>> $field=<<$field>> $value=<<nodeTiddler>> />">
+
+<$list variable=<<$variable>> filter="[<$tiddler>gettyped<$field>!is[draft]]">
+
+<$slot $name=ts-raw>
+
+<$node.default />
+
+\end
+
+\relink $nodes.writable $field:fieldname $tiddler:title

package/plugins/graph/macros/properties.persistent.tid

@@ -0,0 +1,27 @@
+\widget $properties.persistent($dataTiddler)
+\whitespace trim
+
+\function pos() [<$dataTiddler>getindex{!!title}]
+
+\procedure recordPosition(title)
+\whitespace trim
+<$action-setfield
+  $tiddler=<<$dataTiddler>>
+  $index=<<title>>
+  $value=`$(x)$,$(y)$`/>
+<%if [<$dataTiddler>!prefix[$:/graph/]] %>
+  <$fieldmangler tiddler=<<$dataTiddler>> >
+    <$action-sendmessage $message=tm-add-tag $param="$:/tags/flibbles/graph/TiddlerData" />
+  </$fieldmangler>
+<%endif%>
+\end recordPosition
+
+<$properties
+  free="<$transclude $variable=recordPosition title=<<nodeTiddler>> />"
+  delete="<$action-setfield $tiddler=<<$dataTiddler>> $index=<<nodeTiddler>>/>">
+
+<$slot $name=ts-raw />
+
+\end
+
+\relink $properties.persistent $dataTiddler:title

package/plugins/graph/macros/properties.popup.tid

@@ -0,0 +1,76 @@
+\widget $properties.popup($enabled:yes $ms:600, $width, $height:50%, $for:nodes)
+\whitespace trim
+
+<$parameters $state={{{ [<qualify "$:/state/graph/tooltip">addsuffix[-]addsuffix<$for>] }}} >
+
+<$let state=<<$state>>
+	delayState=`$(state)$-delay`
+	blurringState=`$(state)$-interrupt`
+	draggingState=`$(state)$-dragging`
+	$msLinger=0>
+
+<$properties $for={{{ [<$enabled>match[yes]then<$for>] }}}
+  hover="""\whitespace trim
+    <%if [<draggingState>] [<state>] +[is[tiddler]count[]match[0]] %>
+      <$action-delay $state=<<delayState>> $ms=<<$ms>> >
+        <$action-with $offset="mouse" $canvas=canvas>
+          <$vars
+              lr={{{ [<mouse-x>multiply[2]compare:number:gt<canvas-width>then[right]else[left]] }}}
+              tb={{{ [<mouse-y>multiply[2]compare:number:gt<canvas-height>then[bottom]else[top]] }}} >
+            <$action-popup $state=<<$state>> $coords="(0,0,0,0)"/>
+            <$genesis $type=$action-setfield $$tiddler=<<$state>>
+              $names="[<$for>subfilter{$:/plugins/flibbles/graph/subfilters##actioncontext}addprefix[context.]]"
+              $values="[<$for>subfilter{$:/plugins/flibbles/graph/subfilters##actioncontext}getvariable[]]"
+              x={{{ [<lr>match[left]then<mouse-x>] ~[<canvas-width>subtract<mouse-x>] }}}
+              y={{{ [<tb>match[top]then<mouse-y>] ~[<canvas-height>subtract<mouse-y>] }}}
+              lr=<<lr>>
+              tb=<<tb>> />
+          </$vars>
+        </$action-pointer>
+      </$action-delay>
+    <%endif%>
+    <$action-deletetiddler $tiddler=<<blurringState>> />"""
+  blur="""\whitespace trim
+    <$action-delay $state=<<blurringState>> $ms=<<$msLinger>> >
+      <$action-deletetiddler $tiddler=<<delayState>> />
+      <$action-popup $state=<<state>> />"""
+  drag="""\whitespace trim
+    <$action-deletetiddler $tiddler=<<delayState>> />
+    <$action-popup $state=<<state>> />
+    <$action-setfield $tiddler=<<draggingState>> text=dragging />"""
+  free='<$action-deletetiddler $tiddler=<<draggingState>> />' >
+
+<$slot $name="ts-raw" />
+
+</$properties>
+
+<$vars
+  x={{{ [<$state>get[x]] }}}
+  y={{{ [<$state>get[y]] }}}
+  lr={{{ [<$state>get[lr]] }}}
+  tb={{{ [<$state>get[tb]] }}}
+  width={{{ [<$width>!is[blank]addprefix[max-width:]addsuffix[;]] }}} >
+
+<!-- We aren't using the popup type because we need to be more dynamic about placing the popup in different directions. The text must be a coord because of $action-popup, but we don't use it. -->
+
+<%if [<$enabled>match[yes]] %>
+
+<$reveal
+  type=match
+  text="(0,0,0,0)"
+  state=<<$state>>
+  positionAllowNegative=yes
+  class="graph-popup tc-popup tc-popup-keep"
+  style=`$(width)$max-height:$($height)$;$(lr)$:$(x)$px;$(tb)$:$(y)$px;`>
+
+<$genesis $type=$vars
+  $names="[<$state>fields[]removeprefix[context.]]"
+  $values="[<$state>fields[]prefix[context.]] :map[<$state>get{!!title}]" >
+
+<$slot $name=tooltip>
+
+<$transclude $tiddler=<<nodeTiddler>> />
+
+\end
+
+\relink $properties.popup $state:title

package/plugins/graph/macros/properties.river.tid

@@ -0,0 +1,27 @@
+\widget $properties.river()
+\parameters ($state: "$:/state/flibbles/graph/river")
+\whitespace trim
+
+<%if [<graph-sidebar>!match[yes]] %>
+
+<$qualify name=state title=<<$state>> >
+
+<$properties $for=graph
+	blur="<$action-deletetiddler $tiddler=<<state>> />"
+	focus="<$action-setfield $tiddler=<<state>> text=focused />"
+	zoom={{{ [<state>get[text]match[focused]then[yes]else[no]] }}} />
+
+<$slot $name="ts-raw" />
+
+<$properties $for=graph navigation={{{ [<state>get[text]match[focused]then[]else[no]] }}} />
+
+</$qualify><%else%>
+
+<$properties $for=graph zoom=yes />
+
+<$slot $name="ts-raw" />
+
+<%endif%>
+\end
+
+\relink $properties.river $state:title

package/plugins/graph/macros/properties.settings.tid

@@ -0,0 +1,56 @@
+\widget $properties.settings()
+\whitespace trim
+
+<$properties.popup
+  $enabled={{!!popup}}
+  $ms={{{ [{!!title}get[popup.ms]else[600]] }}}
+  $width={{{ [{!!title}get[popup.width]else[300px]] }}}
+  $height={{{ [{!!title}get[popup.height]else[200px]] }}} >
+
+<$fill $name=tooltip>
+
+<$let
+  currentGraph=<<currentTiddler>>
+  currentTiddler=<<nodeTiddler>> >
+
+<%if [<currentGraph>has[popup.template]] %>
+
+<$transclude $tiddler=<<currentGraph>> $field="popup.template" />
+
+<%else%>
+
+{{}}
+<%endif%></$let></$fill>
+
+<$properties.river>
+
+<$properties $tiddler={{!!title}} $field="graph.edges" $for=edges >
+
+<$properties $tiddler={{!!title}} $field="graph.nodes" $for=nodes >
+
+<$properties.stack>
+
+<$let
+  fieldsFilter={{{ [{!!edges.fields}!is[blank]] ~"[all[]]" }}}
+  functionsFilter={{{ [{!!edges.functions}!is[blank]] ~"[all[]]" }}}>
+
+<$slot $name="ts-raw" $depth=4 />
+
+<%if [{!!neighbors.incoming}] =[{!!neighbors.outgoing}] +[match[1]count[]match[2]] %>
+
+<$wikify name=muted text="<<colour muted-foreground>>">
+
+<$properties color=<<muted>> >
+ 
+<$nodes.neighbors
+  $filter={{!!filter}}
+  $functions=<<functionsFilter>>
+  $fields=<<fieldsFilter>>
+  $interedges={{!!neighbors.interedges}}
+  $whitelist={{{ [{!!title}get[neighbors.whitelist]] ~"[!is[system]]" }}} />
+
+</$properties></$wikify><%endif%></$let></$properties.stack></$properties></$properties>
+<$properties $tiddler={{!!title}} $field="graph.graph" $for=graph />
+
+</$properties.river></$properties.popup>
+\end

package/plugins/graph/macros/properties.stack.tid

@@ -0,0 +1,17 @@
+\widget $properties.stack()
+\procedure $properties.stack.recurse(zth)
+\procedure node.stack() [list[$:/config/flibbles/graph/nodes/stack]] =[all[shadows+tiddlers]prefix[$:/config/flibbles/graph/nodes/stack/]sort[]] +[unique[]is[tiddler]]
+\whitespace trim
+<%if :cache[subfilter<node.stack>] +[zth<zth>] %>
+  <$properties $filter={{{ [<condition>get[filter]] }}} $tiddler=<<condition>> >
+    <$transclude $variable=$properties.stack.recurse $fillignore=yes zth={{{ [<zth>add[1]] }}} />
+  </$properties>
+<%else%>
+  <$slot $name=ts-raw />
+<%endif%>
+\end $properties.stack.recurse
+\whitespace trim
+
+<$transclude $variable=$properties.stack.recurse zth=0 $fillignore=yes />
+
+\end

package/plugins/graph/macros/tiddlywiki.files

@@ -0,0 +1,17 @@
+{
+	"directories": [
+		{
+			"path": ".",
+			"filesRegExp": "^.*\\.tid$",
+			"isTiddlerFile": false,
+			"fields": {
+				"title": {
+					"source": "basename",
+					"prefix": "$:/plugins/flibbles/graph/macros/"
+				},
+				"tags": "$:/tags/Global",
+				"code-body": "yes"
+			}
+		}
+	]
+}

package/plugins/graph/plugin.info

@@ -0,0 +1,14 @@
+{
+	"name": "Graph",
+	"title": "$:/plugins/flibbles/graph",
+	"description": "Lightweight and programmable graphing for Tiddlywiki",
+	"author": "Flibbles",
+	"version": "1.6.4",
+	"stability": "STABILITY_2_STABLE",
+	"core-version": ">=5.3.7",
+	"source": "https://github.com/flibbles/tw5-graph",
+	"demo": "http://flibbles.github.io/tw5-graph/",
+	"list": "readme settings",
+	"dependents": "",
+	"plugin-type": "plugin"
+}

package/plugins/graph/presettypes/edges/fields.tid

@@ -0,0 +1,18 @@
+title: $:/plugins/flibbles/graph/presettypes/edges/fields
+
+\procedure typeSelector()
+\whitespace trim
+<$select tiddler=`$:/config/flibbles/relink/fields/$(fieldName)$` default=list>
+  <$list filter="[[$:/plugins/flibbles/relink]is[tiddler]then[relinkfieldtype]else[fieldtype]modules[]moduleproperty[name]]">
+    <option>
+      <$text text={{!!title}} />
+    </option>
+  </$list>
+</$select>
+\end
+
+"Fields" presets define the edge properties for edges corresponding to tiddler fields. These types of edges can be easily added to a node using the <<.link EdgesAllWidget>> widget, or the more inclusive `$edges.typed` widget, which encompasses all other types of preset edge types.
+
+<$vars fieldName={{{ [<currentTiddler>removeprefix[$:/config/flibbles/graph/edges/fields/]] }}}>
+
+Field type: <<typeSelector>>

package/plugins/graph/presettypes/edges/functions.tid

@@ -0,0 +1,5 @@
+title: $:/plugins/flibbles/graph/presettypes/edges/functions
+
+"Function" edges define properties for edges generated from input nodes //individually// into a filter, and then creating an edge from that node to each of the filter's output.
+
+Filter: <$edit-text field=filter />

package/plugins/graph/presettypes/nodes/stack.tid

@@ -0,0 +1,6 @@
+title: $:/plugins/flibbles/graph/presettypes/nodes/stack
+orderable: yes
+
+"stack" nodes define the node properties that can be applied as a stack to contained nodes, such as nodes contained within `$properties.stack`. For each node, the stack of node properties are applied one after another, each depending on if that node matches any given stack property's filter.
+
+Filter: <$edit-text field=filter />

package/plugins/graph/propertytypes/actions.js

@@ -0,0 +1,15 @@
+/*\
+
+Defines behavior to be taken in the event that particular action is called.
+
+\*/
+
+"use strict";
+
+exports.name = "actions";
+
+exports.type = "wikitext";
+
+exports.toProperty = function(info, value) {
+	return value? true: null;
+};

package/plugins/graph/propertytypes/boolean.js

@@ -0,0 +1,23 @@
+/*\
+
+Defines behavior for boolean types in graph engine properties.
+
+\*/
+
+"use strict";
+
+exports.name = "boolean";
+
+var falses = {
+	no: true,
+	"false": true,
+	"0": true,
+	n: true,
+	f: true,
+	'': true,
+	' ': true
+};
+
+exports.toProperty = function(info, value) {
+	return !falses[value.toLowerCase()];
+};

package/plugins/graph/propertytypes/enum.js

@@ -0,0 +1,25 @@
+/*\
+
+Defines behavior for enum types in graph engine properties.
+
+\*/
+
+"use strict";
+
+exports.name = "enum";
+
+exports.toProperty = function(info, value) {
+	if (info.multiple) {
+		var values = $tw.utils.parseStringArray(value);
+		if (values.length === 0) {
+			return values;
+		}
+		var filtered = values.filter(v => info.values.indexOf(v) >= 0);
+		if (filtered.length > 0) {
+			return filtered;
+		}
+	} else if (value && info.values.indexOf(value) >= 0) {
+		return value;
+	}
+	return null;
+};

package/plugins/graph/propertytypes/image.js

@@ -0,0 +1,140 @@
+/*\
+
+Defines images types, and manages fetching a url from titles.
+
+\*/
+
+"use strict";
+
+exports.name = "image";
+
+exports.type = "title";
+
+exports.toProperty = function(info, value, options) {
+	var tiddler = options.widget.wiki.getTiddler(value);
+	if (!tiddler) {
+		// It does not appear to be a real tiddler,
+		// so let's treat it like a real URL.
+		return value;
+	}
+	var cache = options.widget.wiki.getGlobalCache("graph-image", function() {
+		return Object.create(null);
+	});
+	if (!cache[value]) {
+		var output = getTiddlerUri(value, options.widget);
+		if (output.uri === undefined && output.widget) {
+			var container = $tw.fakeDocument.createElement("div");
+			output.widget.render(container, null);
+			var svg = findSVGElement(container);
+			if (!svg) {
+				// Not an image as far as we can tell. Ignore the input.
+				output.uri = null;
+			} else {
+				injectNamespace(svg);
+				// wikitext images may benefit from colors. svg images should too, but let's
+				// not worry about that right now.
+				output.widget.color = options.widget.getColor("nodeColor");
+				injectStyle(svg, output.widget);
+				output.uri = "data:image/svg+xml," + encodeURIComponent(container.innerHTML);
+			}
+		}
+		cache[value] = output;
+	}
+	return cache[value].uri;
+};
+
+exports.refresh = function(info, value, changedTiddlers, widget) {
+	if (changedTiddlers[value]) {
+		return true;
+	}
+	var graphWidget = getGraphWidget(widget);
+	var tiddler = graphWidget.wiki.getTiddler(value);
+	if (tiddler) {
+		var output = getTiddlerUri(value, graphWidget);
+		if (output.widget && output.widget.refresh(changedTiddlers)) {
+			output.uri = undefined;
+			return true;
+		}
+	}
+	// Now we need to check whether the color for this image has changed
+	if (output && output.widget) {
+		var newColor = graphWidget.getColor("nodeColor");
+		if (newColor !== output.widget.color) {
+			output.color = newColor;
+			return true;
+		}
+	}
+	return false;
+};
+
+function getGraphWidget(widget) {
+	while (widget && !widget.getColor) {
+		widget = widget.parentWidget;
+	}
+	return widget;
+};
+
+function getTiddlerUri(title, widget) {
+	var wiki = widget.wiki;
+	var tiddler = wiki.getTiddler(title);
+	var output = {};
+	if(wiki.isImageTiddler(title)) {
+		// Check if it is an image tiddler
+		var type = tiddler.fields.type,
+			text = tiddler.fields.text,
+			_canonical_uri = tiddler.fields._canonical_uri,
+			typeInfo = $tw.config.contentTypeInfo[type] || {},
+			deserializerType = typeInfo.deserializerType || type;
+		if(text) {
+			// Render the appropriate element for the image type by looking up the encoding in the content type info
+			var encoding = typeInfo.encoding || "utf8";
+			if (encoding === "base64") {
+				// .pdf .png .jpg etc.
+				output.uri = "data:" + deserializerType + ";base64," + text;
+			} else {
+				// .svg .tid .xml etc.
+				output.uri = "data:" + deserializerType + ";" + encoding + "," + encodeURIComponent(text);
+			}
+		} else if(_canonical_uri) {
+			output.uri = _canonical_uri;
+		} else {
+			// This must be a lazily loaded tiddler. We don't suppor those yet.
+			output.uri = null;
+		}
+	} else {
+		// We assume it is wikitext trying to make an svg
+		output.widget = wiki.getCacheForTiddler(title, "graph-image", function() {
+			var parser = wiki.parseTiddler(title, {parseAsInline: true});
+			return wiki.makeWidget(parser, {parentWidget: widget});
+		});
+	}
+	return output;
+};
+
+function findSVGElement(element) {
+	if (element.tag === "svg") {
+		return element;
+	}
+	if (element.children) {
+		for (var i = 0; i < element.children.length; i++) {
+			var found = findSVGElement(element.children[i]);
+			if (found) {
+				return found;
+			}
+		}
+	}
+	return null;
+};
+
+function injectNamespace(svg) {
+	// wikitext svg does not need namespacing, but data URIs do
+	svg.setAttribute("xmlns", "http://www.w3.org/2000/svg");
+};
+
+function injectStyle(svg, widget) {
+	if (widget.color) {
+		var style = $tw.fakeDocument.createElement("style");
+		style.textContent = ":root{fill:" + widget.color + ";}";
+		svg.insertBefore(style, svg.children[0]);
+	}
+};