diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..9ed6902
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,15 @@
+.dub
+docs.json
+docs/
+/dom_persist
+dom_persist.so
+dom_persist.dylib
+dom_persist.dll
+libdom_persist.a
+dom_persist.lib
+dom_persist-test-*
+*.exe
+*.o
+*.obj
+*.lst
+*.db
diff --git a/LICENSE.txt b/LICENSE.txt
new file mode 100644
index 0000000..36b7cd9
--- /dev/null
+++ b/LICENSE.txt
@@ -0,0 +1,23 @@
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute,
+execute, and transmit the Software, and to prepare derivative works of the
+Software, and to permit third-parties to whom the Software is furnished to
+do so, all subject to the following:
+
+The copyright notices in the Software and this entire statement, including
+the above license grant, this restriction and the following disclaimer,
+must be included in all copies of the Software, in whole or in part, and
+all derivative works of the Software, unless such copies or derivative
+works are solely in the form of machine-executable object code generated by
+a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/dub.json b/dub.json
new file mode 100644
index 0000000..62e7762
--- /dev/null
+++ b/dub.json
@@ -0,0 +1,13 @@
+{
+	"authors": [
+		"John Pearcey"
+	],
+	"copyright": "Copyright © 2024, John Pearcey",
+	"dependencies": {
+		"console-colors": "~>1.3.1",
+		"d2sqlite3": "~>1.0.0"
+	},
+	"description": "Persist Html/Dom to file with element indexing",
+	"license": "proprietary",
+	"name": "dom_persist"
+}
\ No newline at end of file
diff --git a/dub.selections.json b/dub.selections.json
new file mode 100644
index 0000000..bc63a03
--- /dev/null
+++ b/dub.selections.json
@@ -0,0 +1,7 @@
+{
+	"fileVersion": 1,
+	"versions": {
+		"console-colors": "1.3.1",
+		"d2sqlite3": "1.0.0"
+	}
+}
diff --git a/source/attributeHandler.d b/source/attributeHandler.d
new file mode 100644
index 0000000..9bb88ff
--- /dev/null
+++ b/source/attributeHandler.d
@@ -0,0 +1,167 @@
+module attributeHandler;
+
+/**
+ * Module mainly for attribute parsing for DB retrieval, and some other
+ * common attribute functionality
+ */
+
+import std.stdio;
+
+
+/**
+ * Simple attribute parser.
+ * 
+ * Remember to escape the " and/or ' with " or ' if these values are required.
+ */
+class AttribParser {
+	
+	string 			strAtts;
+	string[string]	mapAtts;
+	
+	this( string strAtts ){
+		this.strAtts = strAtts;
+	}
+	
+	ref string[string] getAsMap(){
+		
+		if(mapAtts !is null ) return mapAtts;
+		
+		int state = 0;
+		string nxtKey = "";
+		string nxtVal = "";
+		char cQtp = '\0';
+		
+		foreach( i,c; strAtts ){
+			
+			switch(state){
+			case 0:
+				// wait for a key
+				switch(c){
+				
+				case '>':
+					//this is the end of the element tag
+					return mapAtts;
+					
+				case ' ', '\t':
+					break;
+					
+				default:
+					state += 1;
+					nxtKey ~= c;					
+				}
+				break;
+				
+			case 1:
+				//parsing a key
+				switch(c){
+					
+				case ' ':
+					if(nxtKey=="") break;
+					goto case '=';
+					
+				case '=':
+					state += 1;					
+					break;
+
+				default:
+					nxtKey ~= c;					
+				}
+				break;
+			
+			case 2:
+				
+				//waiting for a value
+				switch(c){
+				case '"', '\'':
+					cQtp = c;
+					state += 1;					
+					break;
+					
+				case '=', ' ', '\t':				
+					break;
+					
+				default:
+					// not a quote, must be the next attribute and the previous att has an empty value					
+					mapAtts[nxtKey] = "";
+					nxtKey = ""~c;
+					state=0;
+				}
+				break;
+				
+			case 3:
+				//looking for the value end, must be a quote
+				switch(c){
+					
+				case '"','\'':
+					if(cQtp!=c){
+						nxtVal ~= c;
+						break;
+					}
+					mapAtts[nxtKey] = nxtVal;
+					nxtKey = "";
+					nxtVal = "";
+					state = 0;					
+					break;
+					
+				default:
+					nxtVal ~= c;
+				}
+				break;
+
+			default:
+			}
+		}		
+		return mapAtts;
+	}
+	
+}
+
+
+unittest{
+
+	writeln( "Testing attribute parsing" );
+
+	string strAtts = "  color=\"red\" 	font='big font'  nowrap v-align='top' border=\"\"  ";
+	AttribParser atts = new AttribParser( strAtts );
+	
+	auto attMap =  atts.getAsMap();
+	foreach( key; attMap.keys() ){
+		
+		string value = attMap[key];
+		
+		switch(key){
+			
+		case "color":
+			assert( value=="red");
+			break;
+			
+		case "font":
+			assert( value=="big font");
+			break;
+			
+		case "nowrap":
+		case "border":
+			assert( value=="");
+			break;
+			
+		case "v-align":
+			assert( value=="top");
+			break;
+			
+		default:	
+			writeln("unknown key was: ", key);
+			assert(false);
+		}
+	}
+
+	
+	atts = new AttribParser( "" );
+	attMap =  atts.getAsMap();
+	assert( attMap.length==0 );
+
+	atts = new AttribParser( "color='pink' > other garbage" );
+	attMap =  atts.getAsMap();
+	assert( attMap.length==1 );	
+	assert( attMap["color"]=="pink" );
+	
+}
diff --git a/source/dom_persist.d b/source/dom_persist.d
new file mode 100644
index 0000000..7cdde89
--- /dev/null
+++ b/source/dom_persist.d
@@ -0,0 +1,547 @@
+/**
+	COPYRIGHT © 2024 JOHN PEARCEY
+	Distributed under the Boost Software License, Version 1.0.
+		(See accompanying file LICENSE.txt or copy at
+		https://www.boost.org/LICENSE_1_0.txt)
+*/
+module dom_persist;
+
+//import std.algorithm; //https://dlang.org/phobos/std_algorithm_mutation.html
+//import std.exception : enforce;
+
+import std.stdio;
+import std.file;
+import std.format;
+import std.array;	//https://dlang.org/phobos/std_array.html
+import std.conv;
+
+
+import nodecode;
+
+// https://d2sqlite3.dpldocs.info/v1.0.0/d2sqlite3.database.Database.this.html
+// https://d2sqlite3.dpldocs.info/v1.0.0/source/tests.d.d.html
+// https://dlang-community.github.io/d2sqlite3/d2sqlite3.html
+// https://code.dlang.org/packages/d2sqlite3
+import d2sqlite3;	
+
+
+/**
+ * Return true if the database exists.
+ */
+bool db_exists( string sqlite_filename ){
+	return sqlite_filename.exists;
+}
+
+/**
+ * Drop the database and remove the DB file
+ */
+void db_drop( string sqlite_filename ){
+	if( sqlite_filename.exists ){
+		sqlite_filename.remove();
+	}	
+}
+
+/**
+ * Create the database file and the params table with the DB version number.
+ */
+Database db_create( string sqlite_filename, int db_ver ){
+	
+	auto db = Database( sqlite_filename );
+	db.run("CREATE TABLE \"Params\"(\"ID\" INTEGER, \"Name\"	TEXT NOT NULL UNIQUE, \"Val\"	TEXT,	PRIMARY KEY(\"ID\" AUTOINCREMENT))");
+	db.run("insert into params(Name, Val) values('DB_VERSION','"~to!string(db_ver)~"')");
+	return db;
+}
+
+
+
+struct TreeNameID {
+	long tree_id;
+	string name;
+}
+
+/**
+ * An instance of this class contains access to a single tree. Tree operations are cached in RAM and only written to
+ * disk when flush is called. This can be done safely because of the single user access to Sqlite.
+ * 
+ * Multiple database connections have not been tested. 
+ * Multiple threads not yet supported.
+ * 
+ */
+class Tree_Db {
+
+
+	protected:
+		
+		long tree_id;
+		Database* db;
+		long nnid = 0;		
+		
+		TreeNode[long]	all_nodes;  //https://dlang.org/spec/hash-map.html
+		TreeNode[long]	nodes_to_delete;
+
+		long getNextNodeId(){
+			nnid -= 1;
+			return nnid;
+		}
+		
+	// end protected
+
+	private:
+
+		this( Database* db, long tid, string tree_name = null ){
+			
+			this.db = db;
+			
+			if(tid==0){
+				//new tree
+				tree_id = getNextNodeId();
+				TreeNode tn = new TreeNode( 
+					this, 
+					NodeData( tree_id, tree_name, 0, TreeNodeType.tree)
+				);
+				this.all_nodes[ tree_id ] = tn;
+				return;
+			}
+			
+			tree_id = tid;
+				
+			//load the tree in one hit using the tree_id
+			//also order by the parent_id so that we know all siblings are grouped together
+			//and then by child order
+		
+			auto results = db.execute( format("select ID, e_data, p_id, t_id from doctree where tree_id=%d or id=%d order by p_id,c_order", tid, tid) );
+			foreach (row; results){
+				
+				long id = row.peek!long(0);
+				long p_id = row.peek!long(2);
+				TreeNode tn = new TreeNode( this, NodeData(
+					id,
+					row.peek!string(1),
+					p_id,
+					getTreeNodeType( row.peek!int(3) )
+				));
+				all_nodes[id] = tn;
+				if(p_id==0) continue;
+				all_nodes[p_id].child_nodes ~= all_nodes[id];
+			}
+		}
+	
+	// end private
+	
+
+	public:
+	
+	/**
+	 * Create the Database schema for the trees.
+	 */
+	static void db_create_schema( ref Database db ){		
+		db.run("CREATE TABLE IF NOT EXISTS doctree (ID INTEGER, e_data	TEXT,p_id INTEGER,t_id INTEGER NOT NULL,tree_id INTEGER NOT NULL,	c_order INTEGER, PRIMARY KEY( ID AUTOINCREMENT))");
+	}
+
+	/**
+	 * Return a list of all trees in the database with their ID's and names.
+	 */
+	static TreeNameID[] getTreeList( ref Database db ){
+
+		TreeNameID[] tree_list;
+		auto results = db.execute( format("select ID, e_data from doctree where p_id=0") );
+		foreach (row; results){
+			
+			tree_list ~= TreeNameID (
+				row.peek!long(0),
+				row.peek!string(1)
+			);			
+		}
+		return tree_list;		
+	}
+	
+	/**
+	 * Create a new tree in RAM. No database activity takes place at this time.
+	 */
+	static Tree_Db createTree( ref Database db, string tree_name ){
+		return new Tree_Db( &db, 0, tree_name );		
+	}
+
+	/**
+	 * Load a tree into RAM from database given the tree ID. Reads the complete tree and involves only one database select.
+	 */
+	static Tree_Db loadTree( ref Database db, long tree_id ){
+		return new Tree_Db( &db, tree_id );		
+	}	
+	
+	/**
+	 * Returns the root node of this tree. This is special node holds the tree name and ID and is not
+	 * usually part of the document but rather the parent container.
+	 */
+	TreeNode getTreeRoot(){
+		return all_nodes[tree_id];
+	}
+
+	/**
+	 * Return any node given its ID. 
+	 * 
+	 * Note about IDs:
+	 * 	positive IDs indicate that the record exists on the database and the ID is the database ID of that node.
+	 * 	negative IDs indicate that the record is a new one existing in RAM only until such times as 'flush' is called.
+	 * 
+	 */
+	TreeNode getTreeNodeById( long id ){
+		
+		TreeNode* ps = id in all_nodes;
+		if(ps) return all_nodes[id];
+		debug_out("getTreeNodeById: did not find key ", id );
+		return null;
+	}
+
+	/**
+	 * Return the tree as html text. This is the cached tree with all changes and not from the database.
+	 */
+	string getTreeAsText( ){
+		return getTreeAsText_r( all_nodes[tree_id] );
+	}
+
+
+	/**
+	 * Create and insert a new child into the parent node (p_node) at the position (pos) indicated.
+	 */
+	TreeNode insertChild( TreeNode p_node, TreeNodeType n_type, string e_data, int pos ){
+				
+		/* Algorithm:
+		add into the correct place in ram, assign a new id <=-1. 
+		An ID is required to add to the map. Using negative IDs indicates that it is not a DB ID.
+		Mark the TreeNode parent as dirty indicating that children need adding and re-ordering
+		flush: insert (into db) all nodes first then set c_order column for those with dirty parents(!)
+		*/
+	
+		long id = getNextNodeId();
+		TreeNode tn = new TreeNode( 
+			this, 
+			NodeData( id, e_data, p_node.node_data.ID, n_type)
+		);
+		
+		this.all_nodes[ id ] = tn;		
+		p_node.child_nodes.insertInPlace( pos, this.all_nodes[ id ]);
+		p_node.dirty = true;
+		return tn;
+	}
+
+	/**
+	 * Move the given node (nodeToMove) to the new parent (nodeDestParent) inserting at position pos.
+	 * Currently only works for node relocation within the same tree.
+	 * 
+	 */
+	void moveNode( TreeNode nodeToMove, TreeNode nodeDestParent, int pos ){
+		/* Algorithm:
+		Move the node and all children into new parent (same parent also works)
+		Mark old parent TreeNode as dirty indicating a re-order is necessary
+		Mark new parent TreeNode as dirty indicating a re-order is necessary
+		update parent id of moved child
+		flush: locate the node using it's original id except if negative
+				update the db with the new ID and set orig_id=0;
+		*/
+		
+		// 1st remove node
+		auto old_p = nodeToMove.parentNode();
+		if(nodeDestParent == old_p){
+			// same parent, nothing to do except move in-place and re-order
+			old_p.cutChild( nodeToMove );
+			old_p.child_nodes.insertInPlace( pos, nodeToMove );
+			old_p.dirty = true;
+			return;
+		}
+		
+		old_p.cutChild( nodeToMove );
+				
+		// add node to new parent
+		nodeDestParent.child_nodes.insertInPlace( pos, nodeToMove );
+		nodeDestParent.dirty = true;
+		nodeToMove.node_data.pid = nodeDestParent.node_data.ID;
+		nodeToMove.node_data.dirty = true;	//dirty data will suffice for storing pid too
+	}
+
+	void deleteNode( TreeNode nodeToDelete ){
+		/* Algorithm:
+			If the id<=-1, then it was a new node, unsaved, can be removed entirely
+			Otherwise, move the node and all children into a delete-map.	
+			Mark the TreeNode parent as dirty indicating that children need removing. Re-ordering is
+			not required but may be advantageous
+			flush: Delete entries using the delete-map and clear the delete-map.
+		 */ 
+		
+		nodeToDelete.parentNode().cutChild( nodeToDelete );
+		if(nodeToDelete.node_data.ID>0){
+			//a persisted node, move to a delete map
+			nodes_to_delete[ nodeToDelete.node_data.ID ] = nodeToDelete;
+		}
+
+		//remove the node (and all its descendents) from the all_nodes map
+		DocOrderIterator it = new DocOrderIterator( nodeToDelete );
+		TreeNode tnode;
+		while( (tnode=it.nextNode) !is null ){
+			long key = tnode.node_data.ID;
+			all_nodes.remove(key);
+		}
+		
+	}
+
+	
+	/**
+	 * Save all edits to the tree to the database. After this call, the database values will be in sync
+	 * with the memory tree.
+	 */
+	void flush(){		
+		
+		// nodes must be written in document order so that a valid database ID is always available as a parent
+		//ID for subsequent child writes. This is because the child update will write
+
+		debug_out("flush():");
+
+		long new_tree = tree_id<0;
+
+		DocOrderIterator it = new DocOrderIterator( all_nodes[tree_id] );
+		TreeNode tnode;
+		while( (tnode=it.nextNode) !is null ){
+			
+			NodeData* nd = &tnode.node_data;
+			debug_out("next node:", *nd );
+				
+			//first we check the ID<0 which implies it is a new node	
+			if( nd.ID<0 ){
+
+				if(new_tree) tree_id=0;
+				
+				db.run( format("insert into doctree(e_data, p_id, t_id, tree_id ) values( '%s', %d, %d, %d )", nd.e_data, nd.pid, nd.type, tree_id ) );
+
+				//update the node id
+				long oldid = tnode.node_data.ID;
+				long nnid = db.lastInsertRowid;
+				
+				long newID = tnode.setNodeId( nnid );
+				all_nodes[nnid] = tnode;
+				all_nodes.remove( oldid );
+			
+				if(new_tree) tree_id = newID;
+				
+			}else if( nd.dirty ){
+				//dirty data and possibly pid too
+				db.run( format("update doctree set e_data='%s', p_id=%d where id=%d", nd.e_data, nd.pid, nd.ID ) );
+				nd.dirty = false;
+			}
+		}
+
+		//collect together all nodes and their children specified in the nodes_to_delete map which have a database ID
+		long[] del_all;
+		foreach( key; nodes_to_delete.keys() ){
+			
+			if(key>0)	del_all ~= key;
+			
+			TreeNode nodeToDelete = nodes_to_delete[key];
+			
+			DocOrderIterator it2 = new DocOrderIterator( nodeToDelete );
+			TreeNode tnode2;
+			while( (tnode2=it2.nextNode) !is null ){
+				if(tnode2.node_data.ID>0)	del_all ~= tnode2.node_data.ID;
+			}
+		}
+		
+		{	//now delete all children from the DB (all have positive keys)
+			int i=0;
+			string sql = "delete from doctree";
+			foreach( key; del_all ){
+				if(i==0){
+					sql ~= " where";
+				}else{
+					sql ~= " and";			
+				}
+				sql ~= " id=" ~ to!(string)(key);
+				i += 1;
+			}
+			if(i>0){
+				db.run( sql );
+			}
+		}
+		nodes_to_delete.clear();
+
+		//Re-enumerate any children that have shifted positions (or are new) according to their array positions
+		it.reset();
+		while( (tnode=it.nextNode) !is null ){
+			if( tnode.dirty ){
+				foreach( i, cNode; tnode.child_nodes){
+					db.run( format("update doctree set c_order=%d where id=%d", i, cNode.node_data.ID ) );
+				}
+				tnode.dirty = false;
+			}
+		}
+	}
+
+	protected:
+	
+	string getTreeAsText_r( ref TreeNode tn ){
+		
+		string strRtn = "";
+
+		TreeNode[] children = tn.child_nodes;
+		foreach( child; children){
+			NodeData nd = child.node_data;
+			strRtn ~= get_openTag_commence( nd.type, nd.e_data );
+			// --> add attributes if required
+			strRtn ~= get_openTag_end( nd.type, nd.e_data );
+			strRtn ~= getTreeAsText_r( child );
+			strRtn ~= get_closeTag( nd.type, nd.e_data );
+		}
+		
+		return strRtn;
+	}
+	
+}
+
+private string get_openTag_commence( TreeNodeType nt, string e_data ){
+	
+	switch( nt ){
+	
+	case TreeNodeType.text:
+		return e_data;
+		
+	case TreeNodeType.comment:
+		return "<!--"~e_data;
+		
+	case TreeNodeType.docType:
+		return "<DOCTYPE "~e_data;
+
+	default:
+		return "<"~e_data;
+	}
+}
+
+private string get_openTag_end( TreeNodeType nt, string e_data ){
+
+	switch( nt ){
+		
+	case TreeNodeType.comment:
+	case TreeNodeType.text:
+		return "";
+			
+	default:
+		switch(e_data){
+		case "input":
+		case "br":
+			return "/>";
+		default:
+		}
+		
+		return ">";
+	}
+	
+}
+
+private string get_closeTag( TreeNodeType nt, string e_data ){
+
+	switch( nt ){
+		
+	case TreeNodeType.docType:
+	case TreeNodeType.text:
+		return "";
+		
+	case TreeNodeType.comment:
+		return "-->";
+		
+	default:
+		switch(e_data){
+		case "input":
+		case "br":
+			return "";
+		default:
+		}
+
+		return format("</%s>", e_data);
+	}
+	
+}
+
+/**
+ * Iterator starting at any given TreeNode, traversing each of the descendent nodes, depth first and increasing child index.
+ */
+class DocOrderIterator {
+	
+	TreeNode start_node;
+	TreeNode next_node;
+	
+	this( TreeNode n ){
+		start_node = n;
+		next_node = n;
+	}
+	
+	void reset(){
+		next_node = start_node;		
+	}
+	
+	/**
+	 * The initial TreeNode is the first node to be returned.
+	 */
+	TreeNode nextNode(){
+	
+		//the node we will return this time
+		TreeNode rtnNode = next_node;
+		if(rtnNode is null) return null;
+			
+		//now work out the node for the next call
+				
+		if( rtnNode.hasChildNodes() ){
+			next_node = rtnNode.firstChild();			
+			return rtnNode;
+		}
+		
+		TreeNode anc_node = rtnNode;
+		while( anc_node !is null && anc_node.nextSibling() is null){
+			anc_node = anc_node.parentNode();
+			if( anc_node == start_node ){
+				anc_node=null;
+				break;
+			}
+		}
+		if(anc_node is null) {
+			next_node=null;
+			return rtnNode;
+		}
+		
+		next_node = anc_node.nextSibling();
+		return rtnNode;
+	
+	}
+	
+}
+
+void removeAt(T)( ref T[] t, int pos ){
+	
+	// tests on a 10000 item array
+
+	//I really don't like these re-assignments but the ref makes it stay in-place
+	
+	// by far the fastest
+	// 15290 cpu cycles	
+	t = t[0..pos] ~ t[pos+1..$];
+	
+	// my implementation cpu 116100 cycles
+	/*for( int i=pos; i<t.length-1; i++){
+		t[i] = t[i+1];
+	}
+	t.length -= 1;
+	*/
+
+	// by far the slowest 154000 cpu cycles
+	//import std.algorithm;
+	//t = t.remove(pos);					
+
+}
+
+
+bool bDebug_out = false;
+void debug_out(){ writeln(); }
+
+void debug_out(T, A...)(T t, A a){
+    if(!bDebug_out) return;
+    import std.stdio;
+    write(t);
+    debug_out(a);
+}
+
diff --git a/source/dom_persist_tests.d b/source/dom_persist_tests.d
new file mode 100644
index 0000000..04d84a3
--- /dev/null
+++ b/source/dom_persist_tests.d
@@ -0,0 +1,321 @@
+/**
+	COPYRIGHT © 2024 JOHN PEARCEY
+	Distributed under the Boost Software License, Version 1.0.
+		See accompanying file LICENSE.txt or copy at
+		https://www.boost.org/LICENSE_1_0.txt
+*/
+module dom_persist_tests;
+
+import std.stdio;
+
+import dom_persist;
+import nodecode;
+import consolecolors; //https://code.dlang.org/packages/console-colors/1.1.2
+
+import d2sqlite3;	// https://d2sqlite3.dpldocs.info/v1.0.0/d2sqlite3.database.Database.this.html
+						// https://dlang-community.github.io/d2sqlite3/d2sqlite3.html
+
+
+version(unittest){	
+
+	//stuff only compiled for unittests
+	string sqlite_filename = "dom_persist_test.db";
+
+	void assertNDRecord( Row row, long id, string e_data, long pid, TreeNodeType tnt ){
+	
+		assert( id == row.peek!long(0) );
+		assert( e_data == row.peek!string(1) );
+		assert( pid == row.peek!long(2) );
+		assert( tnt == getTreeNodeType( row.peek!int(3) ) );
+	
+	}
+
+	class Timer{
+		
+		static ulong getCount(){
+			asm{
+				naked	;
+				rdtsc	;
+				ret	;
+			}
+		}
+
+		ulong starttime;
+
+		this() { starttime = getCount(); }
+		
+		~this(){
+			ulong endtime = getCount();
+			writefln("elapsed time ( %d to %d ) = %d", starttime, endtime, endtime - starttime);
+		}
+	}
+
+}
+
+unittest {
+	
+	writeln( "Testing tree creation" );
+	
+	db_drop( sqlite_filename );
+	assert( !db_exists( sqlite_filename ) );
+
+	Database db = db_create( sqlite_filename, 1 );
+
+	assert( db_exists( sqlite_filename ) );	
+	assert(db.tableColumnMetadata("params", "ID") == TableColumnMetadata("INTEGER", "BINARY", false, true, true));
+
+	Tree_Db.db_create_schema( db );
+	assert(db.tableColumnMetadata("doctree", "ID") == TableColumnMetadata("INTEGER", "BINARY", false, true, true));
+
+	db.close();
+
+}
+
+unittest{
+	
+	auto db = Database( sqlite_filename );
+	Tree_Db tree = Tree_Db.createTree( db, "mytree" );
+
+	TreeNode tree_node = tree.getTreeRoot();
+	NodeData nd = tree_node.node_data;
+	
+	assert( nd.pid == 0);
+	assert( nd.e_data == "mytree");
+	
+	//bDebug_out = true;
+	
+	debug_out("tree_node-1: ", &tree_node);
+
+	// flush the empty tree
+	tree.flush();
+
+	ResultRange results = db.execute( "select ID, e_data, p_id, t_id from doctree where id=1" );
+	Row row = results.front();
+
+	assertNDRecord( row, 1, "mytree", 0, TreeNodeType.tree );
+
+	//bDebug_out = true;
+	
+	debug_out("tree_node-2: ", &tree_node);
+	
+	tree_node.appendChild( TreeNodeType.docType, "html" );
+	auto tn_html = tree_node.appendChild( TreeNodeType.element, "html" );
+	
+	auto tn_head = tn_html.appendChild( TreeNodeType.element, "head" );
+	tn_head.appendChild( TreeNodeType.comment, "This is my comment" );
+	
+	auto tn_body = tn_html.appendChild( TreeNodeType.element, "body" );
+	
+	tn_body.appendChild( TreeNodeType.text, "This is some text" );
+	tn_body.appendChild( TreeNodeType.text, " with more text" );
+	tn_body.appendChild( TreeNodeType.element, "input" );
+	
+	
+	tree.flush();
+
+	//bDebug_out = false;
+
+	string html_out = tree.getTreeAsText( );	
+	//writeln( html_out );
+	assert( html_out == "<DOCTYPE html><html><head><!--This is my comment--></head><body>This is some text with more text<input/></body></html>");
+	
+
+}
+
+
+unittest{
+
+	writeln( "Testing DocOrderIterator" );
+
+	auto db = Database( sqlite_filename );
+	TreeNameID[] tree_list = Tree_Db.getTreeList( db );	
+	Tree_Db tree = Tree_Db.loadTree( db, tree_list[0].tree_id );
+	
+	TreeNode tree_node = tree.getTreeRoot();
+	
+	DocOrderIterator it = new DocOrderIterator( tree_node );
+	int i=0;
+	TreeNode nxt;
+	while( (nxt=it.nextNode) !is null ){		
+		switch(i){
+		case 0:
+			assert( nxt.node_data.type == TreeNodeType.tree );
+			break;
+			
+		case 1:
+			assert( nxt.node_data.type == TreeNodeType.docType );
+			break;
+
+		case 2,3,5,8:
+			assert( nxt.node_data.type == TreeNodeType.element );
+			break;
+
+		case 4:
+			assert( nxt.node_data.type == TreeNodeType.comment );
+			break;
+
+		case 6,7:
+			assert( nxt.node_data.type == TreeNodeType.text );
+			break;
+
+		default:
+		}
+		i+=1;
+	}
+}
+
+unittest{
+
+	writeln( "Testing tree loading" );
+
+	auto db = Database( sqlite_filename );
+		
+	auto tree2 = Tree_Db.createTree( db, "AnotherTree" );
+	tree2.flush();
+	
+	TreeNameID[] tree_list = Tree_Db.getTreeList( db );
+	assert( tree_list.length==2 );
+	
+	Tree_Db tree = Tree_Db.loadTree( db, tree_list[0].tree_id );
+	
+	TreeNode tree_node = tree.getTreeRoot();
+	NodeData nd_t = tree_node.node_data;
+	assert( nd_t.ID == tree_list[0].tree_id );
+	assert( nd_t.e_data == tree_list[0].name );
+	assert( nd_t.pid == 0 );
+	assert( nd_t.type == TreeNodeType.tree );
+
+	TreeNode html_node;
+	
+	int i=0;
+	foreach( node_ptr; tree_node.child_nodes ){		
+
+		NodeData c_node = node_ptr.node_data;
+		
+		switch(i){
+		case 0:
+			assert( c_node.ID == 2 );
+			assert( c_node.e_data == "html" );
+			assert( c_node.pid == tree_list[0].tree_id );
+			assert( c_node.type == TreeNodeType.docType );
+			break;
+
+		case 1:
+			html_node = node_ptr;
+			assert( c_node.ID == 3 );
+			assert( c_node.e_data == "html" );
+			assert( c_node.pid == tree_list[0].tree_id );
+			assert( c_node.type == TreeNodeType.element );
+			break;
+		
+		default:
+		}
+	
+		i+=1;
+	}
+	
+	string html_out = tree.getTreeAsText( );	
+	assert( html_out == "<DOCTYPE html><html><head><!--This is my comment--></head><body>This is some text with more text<input/></body></html>");
+
+	writeln( "Testing tree element insertion" );
+
+	//get head element
+	TreeNode tn_head = html_node.child_nodes[0];	
+	
+	//add an element to the head at position zero
+	tn_head.insertChild( TreeNodeType.element, "script", 0 );	
+	
+	html_out = tree.getTreeAsText( );	
+	assert( html_out == "<DOCTYPE html><html><head><script></script><!--This is my comment--></head><body>This is some text with more text<input/></body></html>");
+
+	writeln( "Testing tree editing" );
+
+	//edit the comment node (id=5)
+	TreeNode e_comment = tree.getTreeNodeById( 5 );	
+	e_comment.setData( "An edit took place" );
+	
+	html_out = tree.getTreeAsText( );	
+	assert( html_out == "<DOCTYPE html><html><head><script></script><!--An edit took place--></head><body>This is some text with more text<input/></body></html>");
+
+	//check that the database entry is unchanged
+	auto results = db.execute( "select e_data from doctree where id=5" );
+	foreach (row; results){		
+		assert( "This is my comment" == row.peek!string(0) );
+	}
+	
+	// save to database	
+	tree.flush();
+		
+	//check db contents using a new tree
+	Tree_Db tree3 = Tree_Db.loadTree( db, tree_list[0].tree_id );
+	html_out = tree3.getTreeAsText( );	
+	assert( html_out == "<DOCTYPE html><html><head><script></script><!--An edit took place--></head><body>This is some text with more text<input/></body></html>");
+
+	writeln("Testing test element move");
+	
+	//use the original tree to test a move the comment node	
+	auto tn_body = tn_head.nextSibling();
+	e_comment.moveNode( tn_body, 0 );
+	html_out = tree.getTreeAsText( );	
+	assert( html_out == "<DOCTYPE html><html><head><script></script></head><body><!--An edit took place-->This is some text with more text<input/></body></html>");
+	
+	//test that it flushes correctly
+	tree.flush();
+	auto result = db.execute( "select id, e_data, p_id, t_id from doctree where id=5" );		
+	assertNDRecord( result.front(), 5, "An edit took place", tn_body.node_data.ID, TreeNodeType.comment );
+	
+	cwriteln("<red>TODO:</red> Test multiple moveNode");		
+}
+
+unittest{
+	
+	writeln( "Testing tree element deletion" );
+
+
+	auto db = Database( sqlite_filename );
+	
+	TreeNameID[] tree_list = Tree_Db.getTreeList( db );
+	assert( tree_list.length==2 );
+	
+	Tree_Db tree = Tree_Db.loadTree( db, tree_list[0].tree_id );
+	string html_out = tree.getTreeAsText( );	
+	//writeln( html_out );
+	assert( html_out == "<DOCTYPE html><html><head><script></script></head><body><!--An edit took place-->This is some text with more text<input/></body></html>");
+	
+	TreeNode tn_head = tree.getTreeRoot().getChildAt(1).getChildAt(0);
+	tn_head.getChildAt(0).deleteNode();	//delete the script node
+	
+	html_out = tree.getTreeAsText( );	
+	assert( html_out == "<DOCTYPE html><html><head></head><body><!--An edit took place-->This is some text with more text<input/></body></html>");
+	
+	//check that the database record still exists
+	auto result = db.execute( "select id, e_data, p_id, t_id from doctree where id=11" );		
+	assertNDRecord( result.front(), 11, "script", tn_head.node_data.ID, TreeNodeType.element );
+	
+	tree.flush();
+	
+	//reload and check
+	tree = Tree_Db.loadTree( db, tree_list[0].tree_id );
+	html_out = tree.getTreeAsText( );	
+	assert( html_out == "<DOCTYPE html><html><head></head><body><!--An edit took place-->This is some text with more text<input/></body></html>");
+	
+			
+}
+
+/*unittest{
+
+
+	int[] a1;
+	
+	for(int i=0; i<10000; i+=1){
+		a1 ~= i;
+	}
+	
+	{
+		scope t = new Timer();
+		
+		for(int i=0; i<10000; i+=1){
+			removeAt!int( a1, 0 );
+		}
+	}
+}*/
diff --git a/source/nodecode.d b/source/nodecode.d
new file mode 100644
index 0000000..79c54e7
--- /dev/null
+++ b/source/nodecode.d
@@ -0,0 +1,185 @@
+/**
+	COPYRIGHT © 2024 JOHN PEARCEY
+	Distributed under the Boost Software License, Version 1.0.
+		(See accompanying file LICENSE.txt or copy at
+		https://www.boost.org/LICENSE_1_0.txt)
+*/
+module nodecode;
+
+import std.traits;
+import std.format;
+
+import dom_persist;
+
+
+enum TreeNodeType {
+	nulltype=-2, // indicates a type read from the database which is not one of the recognised types
+	tree=-1, docType, element, text, comment
+}
+
+TreeNodeType getTreeNodeType( int tip ){
+	
+	auto tnts = [EnumMembers!TreeNodeType];
+	foreach( tnt; tnts ){
+		if( tnt==tip ) return tnt;
+	}
+	return TreeNodeType.nulltype;
+}
+
+/**
+ * Node data held by each TreeNode.
+ */
+struct NodeData {
+	
+	long ID;			// The (database) ID of this node. negative IDs are new nodes not yet flushed
+	string e_data;	// Data specific to the node. e.g. element name, or comment text etc..
+	long pid;		// Parent node ID. If not connected then zero
+	TreeNodeType type;
+	bool dirty = false;	// true when any node data changes indicating a DB write is required.	
+	
+	this( long ID, string e_data, long pid, TreeNodeType type){
+		this.ID = ID;
+		this.e_data = e_data;
+		this.pid = pid;
+		this.type = type;
+	}
+}
+
+/**
+ * Each element in the tree is represented by an instance of TreeNode.
+ * 
+ * This class contains node specific operations such as reading, mutation, relocation etc..
+ */
+class TreeNode {
+	
+	private:
+	
+		Tree_Db owner_tree;
+	
+	// end private
+	
+	public:
+	
+		NodeData 		node_data;
+		TreeNode[] 		child_nodes;
+		bool				dirty;	// true indicates a change in child_nodes ordering
+
+		this( Tree_Db owner_tree, NodeData node_data){
+			this.owner_tree = owner_tree;
+			this.node_data = node_data;
+		}
+		
+		/**
+		 * Returns the parent node of this node or null if no parent exists (i.e. tree-root)
+		 */
+		TreeNode parentNode(){
+			if(node_data.pid==0) return null;
+			return owner_tree.getTreeNodeById( node_data.pid );
+		}
+		
+		/**
+		 * Returns the next sibling of this node or null if none exists
+		 */
+		TreeNode nextSibling(){
+			if(node_data.pid==0) return null;
+			
+			//bDebug_out = true;
+			TreeNode p_node = owner_tree.getTreeNodeById( node_data.pid );
+			if(p_node is null){
+				debug_out("(ID,e_data) = ", node_data.ID, node_data.e_data );
+				throw new Exception("oops");
+			}
+			
+			foreach( i, c_node; p_node.child_nodes){
+				if(c_node==this){
+					if( i == p_node.child_nodes.length-1) return null;
+					return p_node.child_nodes[i+1];
+				}
+			}
+			throw new Exception("Damaged tree, possibly incorrect parent id for a child.");
+		}
+
+		bool hasChildNodes(){
+			return child_nodes.length>0;
+		}
+
+		TreeNode firstChild(){
+			if( child_nodes.length==0 ) return null;
+			return child_nodes[0];
+		}
+
+		TreeNode getChildAt( int pos ){
+			if( child_nodes.length<=pos ) return null;
+			return child_nodes[pos];
+		}
+
+		/**
+		 * Set the data for this node.
+		 * 
+		 * The data is interpreted using the type of node. For example, the text content of a text node is
+		 * the data whereas for element types, the data is used to hold the element name.
+		 */
+		void setData( string nData ){
+			node_data.e_data = nData;
+			node_data.dirty = true;
+		}
+		
+		/**
+		 * Set the node ID of this treenode. Also sets the parent IDs of all child nodes.
+		 */
+		long setNodeId( long nnid ){
+			
+			long oldid = node_data.ID;
+			
+			node_data.ID = nnid;
+			foreach(child; child_nodes ){
+				child.node_data.pid = nnid;
+			}
+			return nnid;
+		}
+
+		/**
+		 * Insert a new child node at the position indicated.
+		 */
+		TreeNode insertChild( TreeNodeType n_type, string e_data, int pos ){		
+			return owner_tree.insertChild( this, n_type, e_data, pos );		
+		}
+
+		/**
+		 * Append a new child node.
+		 */
+		TreeNode appendChild( TreeNodeType n_type, string e_data ){
+			return owner_tree.insertChild( this, n_type, e_data, cast(int)(child_nodes.length) );
+		}
+		
+		void moveNode( TreeNode new_p_node, int pos ){
+			owner_tree.moveNode( this, new_p_node, pos );
+		}
+	
+		/**
+		 * Delete this node and all it's descendents from the the tree.
+		 */
+		void deleteNode( ){
+			owner_tree.deleteNode( this );
+		}
+
+		/**
+		 * Internal use only.
+		 * 
+		 * Locate the child node (c_node) and snip it off.
+		 */
+		void cutChild( TreeNode c_node ){
+			foreach( i, child; child_nodes ){
+				if(child == c_node ){
+					removeAt!TreeNode( child_nodes, cast(int)(i) );
+					c_node.node_data.pid = 0;	//it has no parent now
+					dirty = true;
+					return;
+				}
+			}
+			throw new Exception( format("Node %d is not a child of node %d ", c_node.node_data.ID, node_data.ID) );
+		}
+				
+	// end public
+	
+}