solarite 0.2.4 → 0.3.1

package/src/{solarite/r.js → h.js}

@@ -1,11 +1,12 @@
 import Template from "./Template.js";
 import Util from "./Util.js";
 import Globals from "./Globals.js";
+import {assert} from "./assert.js";
 
 /**
  * Convert strings to HTMLNodes.
- * Using r as a tag will always create a Template.
- * Using r() as a function() will always create a DOM element.
+ * Using h`...` as a tag will always create a Template.
+ * Using h() as a function() will always create a DOM element.
  *
  * Features beyond what standard js tagged template strings do:
  * 1. r`` sub-expressions
@@ -15,24 +16,27 @@ import Globals from "./Globals.js";
  * 5. TODO:  list more
  *
  * Currently supported:
- * 1. r(el, options)`<b>${'Hi'}</b>`   // Create template and render its nodes to el.
- * 2. r(el, template, ?options)        // Render the Template created by #1 to element.
+ * 1. h(el, options)`<b>${'Hi'}</b>`   // Create template and render its nodes to el.
+ * 2. h(el, template, ?options)        // Render the Template created by #1 to element.
  *
- * 3. r`<b>Hello</b> ${'World'}!`      // Create Template that can later be used to create nodes.
+ * 3. h`<b>Hello</b> ${'World'}!`      // Create Template that can later be used to create nodes.
  *
- * 4. r('Hello');                      // Create single text node.
- * 5. r('<b>Hello</b>');               // Create single HTMLElement
- * 6. r('<b>Hello</b><u>Goodbye</u>'); // Create document fragment because there's more than one node.
- * 7. r()`Hello<b>${'World'}!</b>`     // Same as 4-6, but evaluates the string as a Solarite template, which
+ * 4. h('Hello');                      // Create single text node.
+ * 5. h('<b>Hello</b>');               // Create single HTMLElement
+ * 6. h('<b>Hello</b><u>Goodbye</u>'); // Create document fragment because there's more than one node.
+ * 7. h()`Hello<b>${'World'}!</b>`     // Same as 4-6, but evaluates the string as a Solarite template, which
  *                                     // includes properly handling nested components and r`` sub-expressions.
- * 8. r(template)                      // Render Template created by #1.
- *
- * 9. r({render(){...}})              // Pass an object with a render method, and optionally other props/methods.
+ * 8. h(template)                      // Render Template created by #1.
  *
+ * 9. h({render(){...}})               // Pass an object with a render method, and optionally other props/methods.
+ * 10. h(string, object, ...)          // JSX TODO
  * @param htmlStrings {?HTMLElement|string|string[]|function():Template|{render:function()}}
  * @param exprs {*[]|string|Template|Object}
  * @return {Node|HTMLElement|Template} */
-export default function r(htmlStrings=undefined, ...exprs) {
+export default function h(htmlStrings=undefined, ...exprs) {
+
+	if (htmlStrings === undefined && !exprs.length && arguments.length)
+		throw new Error('h() cannot be called with undefined.');
 
 	// TODO: Make this a more flat if/else and call other functions for the logic.
 	if (htmlStrings instanceof Node) {
@@ -55,7 +59,7 @@ export default function r(htmlStrings=undefined, ...exprs) {
 		}
 
 		// 2. Render template created by #4 to element.
-		else if (exprs[0] instanceof Template) {
+		else { // instanceof Template
 			let options = exprs[1];
 			template.render(parent, options);
 
@@ -66,16 +70,6 @@ export default function r(htmlStrings=undefined, ...exprs) {
 				parent.append(this.rootNg.getParentNode());
 			}
 		}
-
-
-
-		// null for expr[0], remove whole element.
-		   // This path never happens?
-		else {
-			throw new Error('unsupported');
-			//let ngm = NodeGroupManager.get(parent);
-			//ngm.render(null, exprs[1])
-		}
 	}
 
 	// 3. Path if used as a template tag.
@@ -84,6 +78,23 @@ export default function r(htmlStrings=undefined, ...exprs) {
 	}
 
 	else if (typeof htmlStrings === 'string' || htmlStrings instanceof String) {
+		// 10. JSX
+		if (typeof exprs[0] === 'object') {
+			let tag = htmlStrings;
+			let props = exprs[0] || {};
+			let children = exprs.slice(1);
+
+			let templateHtmlStrings = [];
+			let templateExprs = [];
+
+			// TODO How to know which children are static html and which are expression placeholders?
+			// Perhaps we have to treat every text child as a string?
+
+			assert(templateHtmlStrings.length === templateExprs.length+1);
+			return new Template(templateHtmlStrings, templateExprs);
+		}
+
+
 		// If it starts with a string, trim both ends.
 		// TODO: Also trim if it ends with whitespace?
 		if (htmlStrings.match(/^\s^</))
@@ -107,7 +118,7 @@ export default function r(htmlStrings=undefined, ...exprs) {
 	else if (htmlStrings === undefined) {
 		return (htmlStrings, ...exprs) => {
 			//Globals.rendered.add(parent)
-			let template = r(htmlStrings, ...exprs);
+			let template = h(htmlStrings, ...exprs);
 			return template.render();
 		}
 	}
@@ -119,13 +130,19 @@ export default function r(htmlStrings=undefined, ...exprs) {
 
 
 	// 9. Create dynamic element with render() function.
+	// TODO: This path doesn't handle embeds like data-id="..."
 	else if (typeof htmlStrings === 'object') {
 		let obj = htmlStrings;
 
+		if (obj.constructor.name !== 'Object') 
+			throw new Error(`Solarate Web Component class ${obj.constructor?.name} must extend HTMLElement.`);
+
+
 		// Special rebound render path, called by normal path.
+		// Intercepts the main r`...` function call inside render().
 		if (Globals.objToEl.has(obj)) {
 			return function(...args) {
-			   let template = r(...args);
+			   let template = h(...args);
 			   let el = template.render();
 				Globals.objToEl.set(obj, el);
 			}.bind(obj);
@@ -134,20 +151,33 @@ export default function r(htmlStrings=undefined, ...exprs) {
 		// Normal path
 		else {
 			Globals.objToEl.set(obj, null);
-			obj.render(); // Calls the Special rebound render path above, when the render function calls r(this)
+			obj[renderF](); // Calls the Special rebound render path above, when the render function calls r(this)
 			let el = Globals.objToEl.get(obj);
 			Globals.objToEl.delete(obj);
 
 			for (let name in obj)
 				if (typeof obj[name] === 'function')
-					el[name] = obj[name].bind(el);
+					el[name] = obj[name].bind(el);  // Make the "this" of functions be el.
+					// TODO: But this doesn't work for passing an object with functions as a constructor arg via an attribute:
+					// <my-element arg=${{myFunc() { return this }}}
 				else
 					el[name] = obj[name];
 
+			// Bind id's
+			// This doesn't work for id's referenced by attributes.
+			// for (let idEl of el.querySelectorAll('[id],[data-id]')) {
+			// 	Util.bindId(el, idEl);
+			// 	Util.bindId(obj, idEl);
+			// }
+			// TODO: Bind styles
+
 			return el;
 		}
 	}
 
 	else
 		throw new Error('Unsupported arguments.')
-}
+}
+
+// Trick to prevent minifier from renaming this function.
+let renderF = 'render';

package/src/{solarite/hash.js → hash.js}

@@ -10,7 +10,7 @@ export function getObjectId(obj) {
 	
 	let result = objectIds.get(obj);
 	if (!result) { // convert to string, store in result, then add 1 to lastObjectId.
-		result = (lastObjectId++); // We use a unique prefix to ensure it doesn't collide w/ strings not from getObjectId()
+		result = '~\f' + (lastObjectId++); // We use a unique, 2-byte prefix to ensure it doesn't collide w/ strings not from getObjectId()
 		objectIds.set(obj, result)
 	}
 	return result;
@@ -29,14 +29,7 @@ function toJSON() {
 
 // Node.prototype.toJSON = toJSON;
 // Function.prototype.toJSON = toJSON;
-// Sometimes these get unassigned by Chrome and Brave 119, as well as Firefox, seemingly randomly!
-// The same tests sometimes pass, sometimes fail, even after browser and OS restarts.
-// So we check the assignments on every run of getObjectHash()
-if (Node.prototype.toJSON !== toJSON) {
-	Node.prototype.toJSON = toJSON;
-	if (Function.prototype.toJSON !== toJSON) // Will it only unmap one but not the other?
-		Function.prototype.toJSON = toJSON;
-}
+
 
 /**
  * Get a string that uniquely maps to the values of the given object.
@@ -51,6 +44,16 @@ if (Node.prototype.toJSON !== toJSON) {
  * @param obj {*}
  * @returns {string} */
 export function getObjectHash(obj) {
+
+	// Sometimes these get unassigned by Chrome and Brave 119, as well as Firefox, seemingly randomly!
+	// The same tests sometimes pass, sometimes fail, even after browser and OS restarts.
+	// So we check the assignments on every run of getObjectHash()
+	if (Node.prototype.toJSON !== toJSON) {
+		Node.prototype.toJSON = toJSON;
+		if (Function.prototype.toJSON !== toJSON) // Will it only unmap one but not the other?
+			Function.prototype.toJSON = toJSON;
+	}
+
 	let result;
 	isHashing = true;
 	try {

package/src/unused/FastLookupArray.js

@@ -0,0 +1,54 @@
+/**
+ * partialUpdate test is 20% slower when using this, even before I override any methods!*/
+export default class FastLookupArray extends Array {
+	constructor() {
+		super(...arguments)
+		this.indexMap = new Map(); // You can replace with WeakMap() but ensure only objects are added.
+
+	}
+
+	push(item) { // doesn't support pushing multiple
+		if (!this.indexMap.has(item)) {
+			this[this.length] = item;
+			this.indexMap.set(item, this.length - 1);
+		}
+	}
+
+	indexOf(item) {
+		return this.indexMap.get(item) || -1;
+	}
+
+	remove(item) {
+		const index = this.indexOf(item);
+		if (index !== -1) {
+			this.splice(index, 1);
+			this.indexMap.delete(item);
+
+			// Adjust the map indices for the items after the removed one
+			for (let i = index; i < this.length; i++)
+				this.indexMap.set(this[i], i);
+		}
+	}
+
+	insertBefore(referenceItem, newItem) {
+		const refIndex = this.indexOf(referenceItem);
+		if (refIndex !== -1) {
+			this.splice(refIndex, 0, newItem);
+			this.indexMap.set(newItem, refIndex);
+
+			// Adjust the map indices for the items after the inserted one
+			for (let i = refIndex + 1; i < this.length; i++)
+				this.indexMap.set(this[i], i);
+		}
+	}
+
+	set(index, item) {
+		const currentItem = this[index];
+		if (currentItem !== undefined)
+			this.indexMap.delete(currentItem);
+		this[index] = item;
+		this.indexMap.set(item, index);
+	}
+
+	// TODO: Override splice?
+}

package/src/unused/Hashes.js

@@ -0,0 +1,339 @@
+import {getObjectId} from "../hash.js";
+import Template from "../Template.js";
+
+/**
+ * Convert obj to a non-cyclic form that can be given to JSON.serialize.
+ * This is useful for creating a string that represents a hash of all the deep values of an object.
+ *
+ * One instance of a node always has the same hash, even if its attributes/children have changed.
+ *
+ * TODO: Could memoize be faster if given an old version of the same object, and it only finds the differences?
+ * Or if we inline getObjectId()
+ *
+ * @param obj {Object|Array|function|Node}
+ * @param seenMap Used internally.
+ * @param idCounter Used internally.
+ * @returns {{}|*|string} */
+export function memoize(obj, seenMap = new Map(), idCounter = {value: 0}) {
+
+	// If obj is a Node, Element, or Window, we treat it specially
+	if (obj?.nodeType) { // Benchmarking shows this is faster than "instanceof Node"
+		let nodeId = getObjectId(obj);
+		return `&N:${nodeId}`;
+	}
+
+	// TODO: Should I instead use id's to keep track of functions?
+	let type = typeof obj
+
+	if (obj && type === 'object') {
+		if (seenMap.has(obj))
+			return `&O:${seenMap.get(obj)}`;
+
+		else {
+			seenMap.set(obj, idCounter.value++);
+			if (typeof obj.memoize === 'function')
+				return obj.memoize();
+
+			// We iterate through the keys of an object because an object may have changed since the last time we saw it.
+			const serializedObj = {};
+			for (let key in obj)
+				serializedObj[key] = memoize(obj[key], seenMap, idCounter);
+			return serializedObj;
+		}
+	} else if (type === 'function')
+		//return `&F:${obj}` // String version of function.  This version fails the loop.eventBindings test.
+		return `&F:${getObjectId(obj)}`; // Memory reference to function.  this makes it twice as slow!
+
+	else
+		return obj;
+}
+
+
+function fnv1a(...data) {
+	let hash = 0x811c9dc5; // FNV offset basis
+	for (let i = 0; i < data.length; i++) {
+		hash ^= data[i]; // XOR
+		hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24); // FNV prime multiplication
+	}
+	return hash >>> 0; // Convert to 32-bit unsigned integer
+}
+
+const FNV_PRIME_64 = BigInt("1099511628211");
+const OFFSET_BASIS_64 = BigInt("14695981039346656037");
+function fnv1a_64bit(...data) {
+	let hash = OFFSET_BASIS_64;
+	for (let i = 0; i < data.length; i++) {
+		hash ^= data[i]; // XOR
+		//	hash = BigInt.asUintN(64, hash*FNV_PRIME_64);
+	}
+	return hash;
+}
+
+
+// Faster than memoize
+export function hashObject(obj) {
+	let combinedData = (0);
+	if (obj === null)
+		return combinedData;
+
+	if (Array.isArray(obj)) {
+		for (let i=(0); i<obj.length; i++) {
+			let v = hashObject(obj[i])
+			combinedData = fnv1a(combinedData, i, v);
+		}
+	}
+
+	else if (typeof obj === 'object') {
+		let i = (0);
+		for (const key in obj) {
+			let k = getObjectId3(key)
+			let v = hashObject(obj[key])
+			combinedData = fnv1a(combinedData, i, k, v);
+			i++
+		}
+	}
+	else if (typeof obj === 'number')
+		return (obj)
+	else if (typeof obj === 'string')
+		return getObjectId3(obj)
+	else
+		return getObjectId2(obj);
+
+	return combinedData;
+}
+
+// TODO: Use this number instead as the high bits for getObjectId2?
+let lastObjectId2 = (1_010_101_101); // Big enough to not easily not collide with the space of unhashed numbers.
+let objectIds2 = new Map();
+
+export function getObjectId2(obj) {
+	let result = objectIds2.get(obj);
+	if (!result) {
+		result = (lastObjectId2++); // convert to string, store in result, then add 1 to lastObjectId.
+		objectIds2.set(obj, result)
+	}
+	return result;
+}
+
+
+let objectIds3 = {};
+
+export function getObjectId3(obj) {
+	// if (typeof obj === 'string') {
+	// 	let l = obj.length;
+	// 	if (l < 512) { // Faster than getObjectId3.  512 was picked randomly and has not been benchmarked.
+	// 		let result = 1;
+	// 		for (let i=0; i < l; i++)
+	// 			result ^= obj.charCodeAt(i) << (i%16);
+	// 		return result
+	// 	}
+	// }
+
+
+	let result = objectIds3[obj];
+	if (!result) {
+		result = (lastObjectId2++); // convert to string, store in result, then add 1 to lastObjectId.
+		objectIds3[obj] = result
+	}
+	return result;
+}
+
+
+let hash64Cache = new WeakMap();
+export {hash64Cache};
+
+// 25% slower than 32-bit version but still faster than memoize+JSON.stringify()
+// TODO: hardcoded hash values for true and false?
+export function hashObject64(obj) {
+	let resultLow = 0;
+	let resultHigh = 0;
+
+	if (obj instanceof Template)
+		obj = [obj.htmlId, ...obj.exprs]
+
+	if (obj === null)
+		return [0, 0];
+
+	else if (Array.isArray(obj)) {
+		let result
+		//  = hash64Cache.get(obj);
+		// if (!result) {
+		for (let i = (0); i < obj.length; i++) {
+			let [vLow, vHigh] = hashObject64(obj[i])
+			resultLow = fnv1a(resultLow, i, vLow)
+			resultHigh = fnv1a(resultHigh, vHigh)
+		}
+		result = [resultLow, resultHigh]
+		//	hash64Cache.set(obj, result)
+		//}
+		return result;
+	}
+
+	else if (typeof obj === 'object') {
+		let result
+		//  	= hash64Cache.get(obj);
+		// if (!result) {
+		let i = (0);
+		for (const key in obj) {
+			let k = getObjectId3(key)
+			let [vLow, vHigh] = hashObject64(obj[key])
+			resultLow = fnv1a(resultLow, i, vLow)
+			resultHigh = fnv1a(resultHigh, k, vHigh)
+			i++
+		}
+		result = [resultLow, resultHigh]
+		//	hash64Cache.set(obj, result)
+		//}
+
+		return result;
+	}
+	else if (typeof obj === 'number')
+		return [0, obj]
+	else if (typeof obj === 'string')
+		return [0, getObjectId3(obj)]
+	else
+		return [0, getObjectId2(obj)];
+}
+
+
+
+
+// Perforamnce varies greatly.
+export function memoize2(obj) {
+
+	if (obj === null)
+		return 'null';
+
+	switch (obj?.constructor) {
+		case Function:
+		case Node:
+			return getObjectId(obj);
+		case Array:
+			return '[' + obj.map(item => memoize2(item)) + ']'
+		case Object:
+			let result = '{';
+			for (let key in obj) {
+				//key = key.match(/[^A-Z0-9_]/i) ? JSON.stringify(key) : key;
+				key = (key.includes(':')) ? JSON.stringify(key) : key;
+				result += `${key}:${memoize2(obj[key])}`
+			}
+			return result +'}';
+		default:
+			return JSON.stringify(obj);
+	}
+}
+
+// as fast as memoize2, or faster.
+export function memoize3(obj) {
+
+	if (obj === null)
+		return 'null';
+
+	let type = typeof obj;
+	if (Array.isArray(obj))
+		return '[' + obj.map(item => memoize2(item)) + ']'
+	if (obj instanceof Node || type === 'function')
+		return getObjectId(obj);
+	if (type=== 'object') {
+		let result = '{';
+		for (let key in obj) {
+			//key = key.match(/[^A-Z0-9_]/i) ? JSON.stringify(key) : key;
+			key = (key.includes(':')) ? JSON.stringify(key) : key;
+			result += `${key}:${memoize2(obj[key])}`
+		}
+		return result +'}';
+	}
+	return JSON.stringify(obj);
+}
+
+
+
+
+// as fast as memoize2, or faster.
+export function memoize4(obj, seenMap=new Map(), idCounter={value: 0}) {
+	let result;
+	if (obj instanceof Template) {
+		if (obj.exprs.length === 1)
+			return obj.htmlId + '\f' + memoize4(obj.exprs[0]) // \f is the "Form feed" control character, unlikely to be usedin regular text.
+
+		let exprLength = obj.exprs.length;
+		result = new Array(exprLength + 1);
+		result[0] = obj.htmlId;
+		let exprs = obj.exprs;
+		for (let i = 0; i < exprLength; i++)
+			result[i + 1] = memoize4(exprs[i])
+	}
+
+	else if (obj === null)
+		result = 'null';
+
+	else if (Array.isArray(obj)) {
+		if (seenMap.has(obj))
+			result = `&A${seenMap.get(obj)}`;
+		else {
+			seenMap.set(obj, idCounter.value++);
+			result = '[' + obj.map(item => memoize2(item)) + ']'
+		}
+	}
+	else if (obj instanceof Node || typeof obj === 'function')
+		result = getObjectId(obj);
+
+	else if (typeof obj=== 'object') {
+		if (seenMap.has(obj))
+			result = `&O${seenMap.get(obj)}`;
+
+		else {
+			seenMap.set(obj, idCounter.value++);
+
+			// // String contact approach.
+			// result = '{';
+			// for (let key in obj) {
+			// 	//key = key.match(/[^A-Z0-9_]/i) ? JSON.stringify(key) : key;
+			// 	key = (key.includes(':')) ? JSON.stringify(key) : key;
+			// 	result += `${key}:${memoize2(obj[key])}`
+			// }
+			// result = result + '}';
+
+			// Buffer approach.  Seems slightly faster.
+			let keys = Object.keys(obj);
+			let buffer = new Array(keys.length) + 2;
+			buffer[0] = '{'
+			buffer[buffer.length-1] = '}'
+			let idx = 1;
+			for (let key of keys) {
+				//key = key.match(/[^A-Z0-9_]/i) ? JSON.stringify(key) : key;
+				key = (key.includes(':')) ? JSON.stringify(key) : key;
+				buffer[idx] = `${key}:${memoize2(obj[key])},`
+				idx++;
+			}
+			result = buffer.join('');
+		}
+	}
+	else
+		result = JSON.stringify(obj);
+
+
+	return result;
+}
+
+
+
+
+
+// Takes half as long as just calling JSON.serialize!
+function containsFunction(obj) {
+	// Base case: if the object itself is a function
+	let type = typeof obj;
+	if (type === 'function') {
+		return true;
+	}
+
+	// If the object is an object or array, recursively search its properties
+	if (type === 'object' && obj !== null)
+		for (let key in obj)
+			if (containsFunction(obj[key]))
+				return true;
+
+	// If none of the properties are functions, return false
+	return false;
+}

package/src/unused/InUse.test.js

@@ -0,0 +1,92 @@
+import {InUseArray, InUseMap} from "./InUseMap.js";
+import Testimony, {assert} from "../../tests/Testimony.js";
+
+Testimony.test('InUseArray.constructor', () => {
+	const arr = new InUseArray();
+	assert.eq(arr.count, 0, 'Initial count should be 0');
+	assert.eq(arr.length, 0, 'Initial length should be 0');
+});
+
+Testimony.test('InUseArray.use - with no value', () => {
+	const arr = new InUseArray(1, 2, 3);
+	const val = arr.use();
+	assert.eq(val, 1, 'Should return the first value');
+	assert.eq(arr.count, 1, 'Count should be incremented');
+});
+
+Testimony.test('InUseArray.use - with specific value', () => {
+	const arr = new InUseArray(1, 2, 3);
+	arr.count = 1; // Mark the first element as in-use
+	const val = arr.use(3);
+	assert.eq(val, 3, 'Should return the specified value');
+	assert.eq(arr.count, 2, 'Count should be incremented');
+	assert.eq(arr[1], 3, 'Value should be moved to the in-use section');
+	assert.eq(arr[2], 2, 'Remaining value should be in the available section');
+});
+
+Testimony.test('InUseArray.use', () => {
+	const arr = new InUseArray(1, 2, 3);
+	let val = arr.use(4);
+	assert.eq(val, undefined,'Should return undefined');
+	assert.eq(arr.use(), 1);
+	assert.eq(arr.use(3), 3);
+	assert.eq(arr.use(), 2);
+	assert.eq(arr.use(), undefined);
+});
+
+Testimony.test('InUseArray.use - all in use', () => {
+	const arr = new InUseArray(1, 2, 3);
+	arr.count = 3;
+	const val = arr.use();
+	assert.eq(val, undefined, 'Should return undefined');
+});
+
+Testimony.test('InUseArray.free', () => {
+	const arr = new InUseArray(1, 2, 3);
+	arr.count = 3;
+	arr.free();
+	assert.eq(arr.count, 0, 'Count should be reset to 0');
+});
+
+Testimony.test('InUseArray.reset', () => {
+	const arr = new InUseArray(1, 2, 3);
+	arr.reset();
+	assert.eq(arr.length, 0, 'Array should be empty');
+});
+
+
+
+
+Testimony.test('InUseMap.add', () => {
+	const map = new InUseMap();
+	map.add('key', 'value');
+	assert.eq(map.data['key'][0], 'value', 'Value should be added to the map');
+});
+
+Testimony.test('InUseMap.getAll', () => {
+	const map = new InUseMap();
+	map.add('key', 'value');
+	const values = map.getAll('key');
+	assert.eq(values.length, 1, 'Should return an array with one value');
+	assert.eq(values[0], 'value', 'Should return the correct value');
+});
+
+Testimony.test('InUseMap.use', () => {
+	const map = new InUseMap();
+	map.add('key', 'value');
+	let value = map.use('key');
+	assert.eq(value, 'value', 'Should return and mark the value as in-use');
+	value = map.use('key');
+	assert.eq(value, undefined, 'Should return and mark the value as in-use');
+});
+
+Testimony.test('InUseMap.hasValue', () => {
+	const map = new InUseMap();
+	map.add('key1', 'value1');
+	map.add('key2', 'value2');
+	const keys = map.hasValue('value1');
+	assert.eq(keys.length, 1, 'Should return an array with one key');
+	assert.eq(keys[0], 'key1', 'Should return the correct key');
+});
+
+