tiddlywiki 5.2.3 → 5.2.5

package/core/modules/utils/linked-list.js

@@ -15,10 +15,11 @@ function LinkedList() {
 
 LinkedList.prototype.clear = function() {
 	// LinkedList performs the duty of both the head and tail node
-	this.next = Object.create(null);
-	this.prev = Object.create(null);
-	this.first = undefined;
-	this.last = undefined;
+	this.next = new LLMap();
+	this.prev = new LLMap();
+	// Linked list head initially points to itself
+	this.next.set(null, null);
+	this.prev.set(null, null);
 	this.length = 0;
 };
 
@@ -41,28 +42,29 @@ Push behaves like array.push and accepts multiple string arguments. But it also
 accepts a single array argument too, to be consistent with its other methods.
 */
 LinkedList.prototype.push = function(/* values */) {
-	var values = arguments;
+	var i, values = arguments;
 	if($tw.utils.isArray(values[0])) {
 		values = values[0];
 	}
-	for(var i = 0; i < values.length; i++) {
+	for(i = 0; i < values.length; i++) {
 		_assertString(values[i]);
 	}
-	for(var i = 0; i < values.length; i++) {
+	for(i = 0; i < values.length; i++) {
 		_linkToEnd(this,values[i]);
 	}
 	return this.length;
 };
 
 LinkedList.prototype.pushTop = function(value) {
+	var t;
 	if($tw.utils.isArray(value)) {
-		for (var t=0; t<value.length; t++) {
+		for (t=0; t<value.length; t++) {
 			_assertString(value[t]);
 		}
-		for(var t=0; t<value.length; t++) {
+		for(t=0; t<value.length; t++) {
 			_removeOne(this,value[t]);
 		}
-		for(var t=0; t<value.length; t++) {
+		for(t=0; t<value.length; t++) {
 			_linkToEnd(this,value[t]);
 		}
 	} else {
@@ -74,11 +76,11 @@ LinkedList.prototype.pushTop = function(value) {
 
 LinkedList.prototype.each = function(callback) {
 	var visits = Object.create(null),
-		value = this.first;
-	while(value !== undefined) {
+		value = this.next.get(null);
+	while(value !== null) {
 		callback(value);
-		var next = this.next[value];
-		if(typeof next === "object") {
+		var next = this.next.get(value);
+		if(Array.isArray(next)) {
 			var i = visits[value] || 0;
 			visits[value] = i+1;
 			value = next[i];
@@ -105,91 +107,79 @@ LinkedList.prototype.makeTiddlerIterator = function(wiki) {
 };
 
 function _removeOne(list,value) {
-	var prevEntry = list.prev[value],
-		nextEntry = list.next[value],
+	var nextEntry = list.next.get(value);
+	if(nextEntry === undefined) {
+		return;
+	}
+	var prevEntry = list.prev.get(value),
 		prev = prevEntry,
-		next = nextEntry;
-	if(typeof nextEntry === "object") {
+		next = nextEntry,
+		ref;
+	if(Array.isArray(nextEntry)) {
 		next = nextEntry[0];
 		prev = prevEntry[0];
 	}
 	// Relink preceding element.
-	if(list.first === value) {
-		list.first = next
-	} else if(prev !== undefined) {
-		if(typeof list.next[prev] === "object") {
-			if(next === undefined) {
-				// Must have been last, and 'i' would be last element.
-				list.next[prev].pop();
-			} else {
-				var i = list.next[prev].indexOf(value);
-				list.next[prev][i] = next;
-			}
-		} else {
-			list.next[prev] = next;
-		}
+	ref = list.next.get(prev);
+	if(Array.isArray(ref)) {
+		var i = ref.indexOf(value);
+		ref[i] = next;
 	} else {
-		return;
+		list.next.set(prev,next);
 	}
+
 	// Now relink following element
-	// Check "next !== undefined" rather than "list.last === value" because
-	// we need to know if the FIRST value is the last in the list, not the last.
-	if(next !== undefined) {
-		if(typeof list.prev[next] === "object") {
-			if(prev === undefined) {
-				// Must have been first, and 'i' would be 0.
-				list.prev[next].shift();
-			} else {
-				var i = list.prev[next].indexOf(value);
-				list.prev[next][i] = prev;
-			}
-		} else {
-			list.prev[next] = prev;
-		}
+	ref = list.prev.get(next);
+	if(Array.isArray(ref)) {
+		var i = ref.indexOf(value);
+		ref[i] = prev;
 	} else {
-		list.last = prev;
+		list.prev.set(next,prev);
 	}
+
 	// Delink actual value. If it uses arrays, just remove first entries.
-	if(typeof nextEntry === "object") {
+	if(Array.isArray(nextEntry) && nextEntry.length > 1) {
 		nextEntry.shift();
 		prevEntry.shift();
 	} else {
-		list.next[value] = undefined;
-		list.prev[value] = undefined;
+		list.next.set(value,undefined);
+		list.prev.set(value,undefined);
 	}
 	list.length -= 1;
 };
 
 // Sticks the given node onto the end of the list.
 function _linkToEnd(list,value) {
-	if(list.first === undefined) {
-		list.first = value;
-	} else {
-		// Does it already exists?
-		if(list.first === value || list.prev[value] !== undefined) {
-			if(typeof list.next[value] === "string") {
-				list.next[value] = [list.next[value]];
-				list.prev[value] = [list.prev[value]];
-			} else if(typeof list.next[value] === "undefined") {
-				// list.next[value] must be undefined.
-				// Special case. List already has 1 value. It's at the end.
-				list.next[value] = [];
-				list.prev[value] = [list.prev[value]];
-			}
-			list.prev[value].push(list.last);
-			// We do NOT append a new value onto "next" list. Iteration will
-			// figure out it must point to End-of-List on its own.
-		} else {
-			list.prev[value] = list.last;
+	var old = list.next.get(value);
+	var last = list.prev.get(null);
+	// Does it already exists?
+	if(old !== undefined) {
+		if(!Array.isArray(old)) {
+			old = [old];
+			list.next.set(value,old);
+			list.prev.set(value,[list.prev.get(value)]);
 		}
-		// Make the old last point to this new one.
-		if(typeof list.next[list.last] === "object") {
-			list.next[list.last].push(value);
+		old.push(null);
+		list.prev.get(value).push(last);
+	} else {
+		list.next.set(value,null);
+		list.prev.set(value,last);
+	}
+	// Make the old last point to this new one.
+	if(value !== last) {
+		var array = list.next.get(last);
+		if(Array.isArray(array)) {
+			array[array.length-1] = value;
 		} else {
-			list.next[list.last] = value;
+			list.next.set(last,value);
 		}
+		list.prev.set(null,value);
+	} else {
+		// Edge case, the pushed value was already the last value.
+		// The second-to-last nextPtr for that value must point to itself now.
+		var array = list.next.get(last);
+		array[array.length-2] = value;
 	}
-	list.last = value;
 	list.length += 1;
 };
 
@@ -199,6 +189,20 @@ function _assertString(value) {
 	}
 };
 
+var LLMap = function() {
+	this.map = Object.create(null);
+};
+
+// Just a wrapper so our object map can also accept null.
+LLMap.prototype = {
+	set: function(key,val) {
+		(key === null) ? (this.null = val) : (this.map[key] = val);
+	},
+	get: function(key) {
+		return (key === null) ? this.null : this.map[key];
+	}
+};
+
 exports.LinkedList = LinkedList;
 
 })();

package/core/modules/utils/logger.js

@@ -48,7 +48,9 @@ Logger.prototype.log = function(/* args */) {
 			this.saveBufferLogger.buffer = this.saveBufferLogger.buffer.slice(-this.saveBufferLogger.saveLimit);
 		}
 		if(console !== undefined && console.log !== undefined) {
-			return Function.apply.call(console.log, console, [$tw.utils.terminalColour(this.colour),this.componentName + ":"].concat(Array.prototype.slice.call(arguments,0)).concat($tw.utils.terminalColour()));
+			var logMessage = [$tw.utils.terminalColour(this.colour) + this.componentName + ":"].concat(Array.prototype.slice.call(arguments,0));
+			logMessage[logMessage.length-1] += $tw.utils.terminalColour();
+			return Function.apply.call(console.log, console, logMessage);
 		}
 	} 
 };

package/core/modules/utils/parsetree.js

@@ -12,12 +12,26 @@ Parse tree utility functions.
 /*global $tw: false */
 "use strict";
 
+/*
+Add attribute to parse tree node
+Can be invoked as (node,name,value) or (node,attr)
+*/
 exports.addAttributeToParseTreeNode = function(node,name,value) {
-	var attribute = {name: name, type: "string", value: value};
+	var attribute = typeof name === "object" ? name : {name: name, type: "string", value: value};
+	name = attribute.name;
 	node.attributes = node.attributes || {};
+	node.orderedAttributes = node.orderedAttributes || [];
 	node.attributes[name] = attribute;
-	if(node.orderedAttributes) {
+	var foundIndex = -1;
+	$tw.utils.each(node.orderedAttributes,function(attr,index) {
+		if(attr.name === name) {
+			foundIndex = index;
+		}
+	});
+	if(foundIndex === -1) {
 		node.orderedAttributes.push(attribute);
+	} else {
+		node.orderedAttributes[foundIndex] = attribute;
 	}
 };
 
@@ -51,10 +65,8 @@ exports.addClassToParseTreeNode = function(node,classString) {
 		// If the class attribute does not exist, we must create it first.
 		attribute = {name: "class", type: "string", value: ""};
 		node.attributes["class"] = attribute;
-		if(node.orderedAttributes) {
-			// If there are orderedAttributes, we've got to add them there too.
-			node.orderedAttributes.push(attribute);
-		}
+		node.orderedAttributes = node.orderedAttributes || [];
+		node.orderedAttributes.push(attribute);
 	}
 	if(attribute.type === "string") {
 		if(attribute.value !== "") {
@@ -74,10 +86,8 @@ exports.addStyleToParseTreeNode = function(node,name,value) {
 	if(!attribute) {
 		attribute = {name: "style", type: "string", value: ""};
 		node.attributes.style = attribute;
-		if(node.orderedAttributes) {
-			// If there are orderedAttributes, we've got to add them there too.
-			node.orderedAttributes.push(attribute);
-		}
+		node.orderedAttributes = node.orderedAttributes || [];
+		node.orderedAttributes.push(attribute);
 	}
 	if(attribute.type === "string") {
 		attribute.value += name + ":" + value + ";";

package/core/modules/utils/utils.js

@@ -354,6 +354,9 @@ exports.formatDateString = function(date,template) {
 	var result = "",
 		t = template,
 		matches = [
+			[/^TIMESTAMP/, function() {
+				return date.getTime();
+			}],
 			[/^0hh12/, function() {
 				return $tw.utils.pad($tw.utils.getHours12(date));
 			}],

package/core/modules/widgets/action-deletefield.js

@@ -36,7 +36,7 @@ Compute the internal state of the widget
 */
 DeleteFieldWidget.prototype.execute = function() {
 	this.actionTiddler = this.getAttribute("$tiddler",this.getVariable("currentTiddler"));
-	this.actionField = this.getAttribute("$field");
+	this.actionField = this.getAttribute("$field",null);
 };
 
 /*
@@ -59,7 +59,7 @@ DeleteFieldWidget.prototype.invokeAction = function(triggeringWidget,event) {
 		tiddler = this.wiki.getTiddler(self.actionTiddler),
 		removeFields = {},
 		hasChanged = false;
-	if(this.actionField && tiddler) {
+	if((this.actionField !== null) && tiddler) {
 		removeFields[this.actionField] = undefined;
 		if(this.actionField in tiddler.fields) {
 			hasChanged = true;

package/core/modules/widgets/action-popup.js

@@ -14,6 +14,8 @@ Action widget to trigger a popup.
 
 var Widget = require("$:/core/modules/widgets/widget.js").widget;
 
+var Popup = require("$:/core/modules/utils/dom/popup.js");
+
 var ActionPopupWidget = function(parseTreeNode,options) {
 	this.initialise(parseTreeNode,options);
 };
@@ -57,20 +59,20 @@ Invoke the action associated with this widget
 */
 ActionPopupWidget.prototype.invokeAction = function(triggeringWidget,event) {
 	// Trigger the popup
-	var popupLocationRegExp = /^\((-?[0-9\.E]+),(-?[0-9\.E]+),(-?[0-9\.E]+),(-?[0-9\.E]+)\)$/,
-		match = popupLocationRegExp.exec(this.actionCoords || "");
-	if(match) {
+	var coordinates = Popup.parseCoordinates(this.actionCoords || "");
+	if(coordinates) {
 		$tw.popup.triggerPopup({
 			domNode: null,
 			domNodeRect: {
-				left: parseFloat(match[1]),
-				top: parseFloat(match[2]),
-				width: parseFloat(match[3]),
-				height: parseFloat(match[4])
+				left: coordinates.left,
+				top: coordinates.top,
+				width: coordinates.width,
+				height: coordinates.height
 			},
 			title: this.actionState,
 			wiki: this.wiki,
-			floating: this.floating
+			floating: this.floating,
+			absolute: coordinates.absolute
 		});
 	} else {
 		$tw.popup.cancel(0);

package/core/modules/widgets/button.js

@@ -14,6 +14,8 @@ Button widget
 
 var Widget = require("$:/core/modules/widgets/widget.js").widget;
 
+var Popup = require("$:/core/modules/utils/dom/popup.js");
+
 var ButtonWidget = function(parseTreeNode,options) {
 	this.initialise(parseTreeNode,options);
 };
@@ -147,7 +149,7 @@ ButtonWidget.prototype.isSelected = function() {
 
 ButtonWidget.prototype.isPoppedUp = function() {
 	var tiddler = this.popupTitle ? this.wiki.getTiddler(this.popupTitle) : this.wiki.getTiddler(this.popup);
-	var result = tiddler && tiddler.fields.text ? $tw.popup.readPopupState(tiddler.fields.text) : false;
+	var result = tiddler && tiddler.fields.text ? Popup.readPopupState(tiddler.fields.text) : false;
 	return result;
 };
 
@@ -173,6 +175,7 @@ ButtonWidget.prototype.triggerPopup = function(event) {
 	if(this.popupTitle) {
 		$tw.popup.triggerPopup({
 			domNode: this.domNodes[0],
+			absolute: (this.popupAbsCoords === "yes"),
 			title: this.popupTitle,
 			wiki: this.wiki,
 			noStateReference: true
@@ -180,6 +183,7 @@ ButtonWidget.prototype.triggerPopup = function(event) {
 	} else {
 		$tw.popup.triggerPopup({
 			domNode: this.domNodes[0],
+			absolute: (this.popupAbsCoords === "yes"),
 			title: this.popup,
 			wiki: this.wiki
 		});
@@ -223,6 +227,7 @@ ButtonWidget.prototype.execute = function() {
 	this.setField = this.getAttribute("setField");
 	this.setIndex = this.getAttribute("setIndex");
 	this.popupTitle = this.getAttribute("popupTitle");
+	this.popupAbsCoords = this.getAttribute("popupAbsCoords", "no");
 	this.tabIndex = this.getAttribute("tabindex");
 	this.isDisabled = this.getAttribute("disabled","no");
 	// Make child widgets
@@ -252,7 +257,7 @@ Selectively refreshes the widget if needed. Returns true if the widget or any of
 */
 ButtonWidget.prototype.refresh = function(changedTiddlers) {
 	var changedAttributes = this.computeAttributes();
-	if(changedAttributes.actions || changedAttributes.to || changedAttributes.message || changedAttributes.param || changedAttributes.set || changedAttributes.setTo || changedAttributes.popup || changedAttributes.hover || changedAttributes.selectedClass || changedAttributes.style || changedAttributes.dragFilter || changedAttributes.dragTiddler || (this.set && changedTiddlers[this.set]) || (this.popup && changedTiddlers[this.popup]) || (this.popupTitle && changedTiddlers[this.popupTitle]) || changedAttributes.setTitle || changedAttributes.setField || changedAttributes.setIndex || changedAttributes.popupTitle || changedAttributes.disabled || changedAttributes["default"]) {
+	if(changedAttributes.actions || changedAttributes.to || changedAttributes.message || changedAttributes.param || changedAttributes.set || changedAttributes.setTo || changedAttributes.popup || changedAttributes.hover || changedAttributes.selectedClass || changedAttributes.style || changedAttributes.dragFilter || changedAttributes.dragTiddler || (this.set && changedTiddlers[this.set]) || (this.popup && changedTiddlers[this.popup]) || (this.popupTitle && changedTiddlers[this.popupTitle]) || changedAttributes.popupAbsCoords || changedAttributes.setTitle || changedAttributes.setField || changedAttributes.setIndex || changedAttributes.popupTitle || changedAttributes.disabled || changedAttributes["default"]) {
 		this.refreshSelf();
 		return true;
 	} else if(changedAttributes["class"]) {

package/core/modules/widgets/checkbox.js

@@ -66,14 +66,14 @@ CheckboxWidget.prototype.render = function(parent,nextSibling) {
 CheckboxWidget.prototype.getValue = function() {
 	var tiddler = this.wiki.getTiddler(this.checkboxTitle);
 	if(tiddler || this.checkboxFilter) {
-		if(this.checkboxTag) {
+		if(tiddler && this.checkboxTag) {
 			if(this.checkboxInvertTag === "yes") {
 				return !tiddler.hasTag(this.checkboxTag);
 			} else {
 				return tiddler.hasTag(this.checkboxTag);
 			}
 		}
-		if(this.checkboxField || this.checkboxIndex) {
+		if(tiddler && (this.checkboxField || this.checkboxIndex)) {
 			// Same logic applies to fields and indexes
 			var value;
 			if(this.checkboxField) {
@@ -206,11 +206,18 @@ CheckboxWidget.prototype.handleChangeEvent = function(event) {
 	}
 	// Set the list field (or index) if specified
 	if(this.checkboxListField || this.checkboxListIndex) {
-		var listContents, oldPos, newPos;
+		var fieldContents, listContents, oldPos, newPos;
 		if(this.checkboxListField) {
-			listContents = tiddler.getFieldList(this.checkboxListField);
+			fieldContents = tiddler ? tiddler.fields[this.checkboxListField] : undefined;
+		} else {
+			fieldContents = this.wiki.extractTiddlerDataItem(this.checkboxTitle,this.checkboxListIndex);
+		}
+		if($tw.utils.isArray(fieldContents)) {
+			// Make a copy so we can modify it without changing original that's refrenced elsewhere
+			listContents = fieldContents.slice(0);
 		} else {
-			listContents = $tw.utils.parseStringArray(this.wiki.extractTiddlerDataItem(this.checkboxTitle,this.checkboxListIndex) || "") || [];
+			listContents = $tw.utils.parseStringArray(fieldContents) || [];
+			// No need to copy since parseStringArray returns a fresh array, not refrenced elsewhere
 		}
 		oldPos = notValue ? listContents.indexOf(notValue) : -1;
 		newPos = value ? listContents.indexOf(value) : -1;

package/core/modules/widgets/error.js

@@ -0,0 +1,63 @@
+/*\
+title: $:/core/modules/widgets/error.js
+type: application/javascript
+module-type: widget
+
+Error widget
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var ErrorWidget = function(parseTreeNode,options) {
+	this.initialise(parseTreeNode,options);
+};
+
+/*
+Inherit from the base widget class
+*/
+ErrorWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+ErrorWidget.prototype.render = function(parent,nextSibling) {
+	this.parentDomNode = parent;
+	this.computeAttributes();
+	this.execute();
+	var message = this.getAttribute("$message","Unknown error"),
+		domNode = this.document.createElement("span");
+	domNode.appendChild(this.document.createTextNode(message));
+	domNode.className = "tc-error";
+	parent.insertBefore(domNode,nextSibling);
+	this.domNodes.push(domNode);
+};
+
+/*
+Compute the internal state of the widget
+*/
+ErrorWidget.prototype.execute = function() {
+	// Nothing to do for a text node
+};
+
+/*
+Selectively refreshes the widget if needed. Returns true if the widget or any of its children needed re-rendering
+*/
+ErrorWidget.prototype.refresh = function(changedTiddlers) {
+	var changedAttributes = this.computeAttributes();
+	if(changedAttributes["$message"]) {
+		this.refreshSelf();
+		return true;
+	} else {
+		return false;
+	}
+};
+
+exports.error = ErrorWidget;
+
+})();

package/core/modules/widgets/genesis.js

@@ -0,0 +1,108 @@
+/*\
+title: $:/core/modules/widgets/genesis.js
+type: application/javascript
+module-type: widget
+
+Genesis widget for dynamically creating widgets
+
+\*/
+(function(){
+
+/*jslint node: true, browser: true */
+/*global $tw: false */
+"use strict";
+
+var Widget = require("$:/core/modules/widgets/widget.js").widget;
+
+var GenesisWidget = function(parseTreeNode,options) {
+	this.initialise(parseTreeNode,options);
+};
+
+/*
+Inherit from the base widget class
+*/
+GenesisWidget.prototype = new Widget();
+
+/*
+Render this widget into the DOM
+*/
+GenesisWidget.prototype.render = function(parent,nextSibling) {
+	this.parentDomNode = parent;
+	this.computeAttributes({filterFn: function(name) {
+		// Only compute our own attributes which start with a single dollar
+		return name.charAt(0) === "$" && name.charAt(1) !== "$";
+	}});
+	this.execute();
+	this.renderChildren(parent,nextSibling);
+};
+
+/*
+Compute the internal state of the widget
+*/
+GenesisWidget.prototype.execute = function() {
+	var self = this;
+	// Collect attributes
+	this.genesisType = this.getAttribute("$type","element");
+	this.genesisRemappable = this.getAttribute("$remappable","yes") === "yes";
+	this.genesisNames = this.getAttribute("$names","");
+	this.genesisValues = this.getAttribute("$values","");
+	// Construct parse tree
+	var isElementWidget = this.genesisType.charAt(0) !== "$",
+		nodeType = isElementWidget ? "element" : this.genesisType.substr(1),
+		nodeTag = isElementWidget ? this.genesisType : undefined;
+	var parseTreeNodes = [{
+		type: nodeType,
+		tag: nodeTag,
+		attributes: {},
+		orderedAttributes: [],
+		children: this.parseTreeNode.children || [],
+		isNotRemappable: !this.genesisRemappable
+	}];
+	// Apply explicit attributes
+	$tw.utils.each($tw.utils.getOrderedAttributesFromParseTreeNode(this.parseTreeNode),function(attribute) {
+		var name = attribute.name;
+		if(name.charAt(0) === "$") {
+			if(name.charAt(1) === "$") {
+				// Double $$ is changed to a single $
+				name = name.substr(1);
+			} else {
+				// Single dollar is ignored
+				return;
+			}
+		}
+		$tw.utils.addAttributeToParseTreeNode(parseTreeNodes[0],$tw.utils.extend({},attribute,{name: name}));
+	});
+	// Apply attributes in $names/$values
+	this.attributeNames = [];
+	this.attributeValues = [];
+	if(this.genesisNames && this.genesisValues) {
+		this.attributeNames = this.wiki.filterTiddlers(self.genesisNames,this);
+		this.attributeValues = this.wiki.filterTiddlers(self.genesisValues,this);
+		$tw.utils.each(this.attributeNames,function(varname,index) {
+			$tw.utils.addAttributeToParseTreeNode(parseTreeNodes[0],varname,self.attributeValues[index] || "");
+		});
+	}
+	// Construct the child widgets
+	this.makeChildWidgets(parseTreeNodes);
+};
+
+/*
+Selectively refreshes the widget if needed. Returns true if the widget or any of its children needed re-rendering
+*/
+GenesisWidget.prototype.refresh = function(changedTiddlers) {
+	var changedAttributes = this.computeAttributes(),
+		filterNames = this.getAttribute("$names",""),
+		filterValues = this.getAttribute("$values",""),
+		attributeNames = this.wiki.filterTiddlers(filterNames,this),
+		attributeValues = this.wiki.filterTiddlers(filterValues,this);
+	if($tw.utils.count(changedAttributes) > 0 || !$tw.utils.isArrayEqual(this.attributeNames,attributeNames) || !$tw.utils.isArrayEqual(this.attributeValues,attributeValues)) {
+		this.refreshSelf();
+		return true;
+	} else {
+		return this.refreshChildren(changedTiddlers);
+	}
+};
+
+exports.genesis = GenesisWidget;
+
+})();

package/core/modules/widgets/importvariables.js

@@ -39,7 +39,10 @@ Compute the internal state of the widget
 ImportVariablesWidget.prototype.execute = function(tiddlerList) {
 	var widgetPointer = this;
 	// Got to flush all the accumulated variables
-	this.variables = new this.variablesConstructor();
+	this.variables = Object.create(null);
+	if(this.parentWidget) {
+		Object.setPrototypeOf(this.variables,this.parentWidget.variables);
+	}
 	// Get our parameters
 	this.filter = this.getAttribute("filter");
 	// Compute the filter

package/core/modules/widgets/keyboard.js

@@ -53,6 +53,10 @@ KeyboardWidget.prototype.render = function(parent,nextSibling) {
 };
 
 KeyboardWidget.prototype.handleChangeEvent = function(event) {
+	if ($tw.keyboardManager.handleKeydownEvent(event, {onlyPriority: true})) {
+		return true;
+	}
+
 	var keyInfo = $tw.keyboardManager.getMatchingKeyDescriptor(event,this.keyInfoArray);
 	if(keyInfo) {
 		var handled = this.invokeActions(this,event);

package/core/modules/widgets/let.js

@@ -51,11 +51,9 @@ LetWidget.prototype.computeAttributes = function() {
 	$tw.utils.each($tw.utils.getOrderedAttributesFromParseTreeNode(this.parseTreeNode),function(attribute) {
 		var value = self.computeAttribute(attribute),
 			name = attribute.name;
-		if(name.charAt(0) !== "$") {
-			// Now that it's prepped, we're allowed to look this variable up
-			// when defining later variables
-			self.currentValueFor[name] = value;
-		}
+		// Now that it's prepped, we're allowed to look this variable up
+		// when defining later variables
+		self.currentValueFor[name] = value;
 	});
 	// Run through again, setting variables and looking for differences
 	$tw.utils.each(this.currentValueFor,function(value,name) {