rdflib 0.0.1 → 0.0.2

package/dist/{node-rdflib.js → rdflib.js}

@@ -1,4 +1,4 @@
-module.exports = $rdf = function() {
+(function(root, undef) {
 /**
 * Utility functions for $rdf and the $rdf object itself
  */
@@ -482,17 +482,6 @@ $rdf.uri = (function() {
     return base.slice(0, baseSingle) + path;
   };
 
-  uri.join2 = function(given, base) {
-    var baseURI, tIOService;
-    if (typeof tabulator !== "undefined" && tabulator !== null ? tabulator.isExtension : void 0) {
-      tIOService = Components.classes['@mozilla.org/network/io-service;1'].getService(Components.interfaces.nsIIOService);
-      baseURI = tIOService.newURI(base, null, null);
-      return tIOService.newURI(baseURI.resolve(given), null, null).spec;
-    } else {
-      return this.join(given, base);
-    }
-  };
-
   uri.commonHost = new RegExp('^[-_a-zA-Z0-9.]+:(//[^/]*)?/[^/]*$');
 
   uri.hostpart = function(u) {
@@ -653,8 +642,10 @@ $rdf.Empty = (function() {
 })();
 
 /*
-   an RDF URI
-    todo: badly named.
+   A named node in an RDF graph
+    todo: badly named. 
+    No, formally a URI is a string, this is a node whose name is a URI.
+    Connolly pointed out it isa symbol on the language.
     @param uri the uri as string
 */
 
@@ -1446,10 +1437,9 @@ if ((typeof module !== "undefined" && module !== null ? module.exports : void 0)
     module.exports[k] = v;
   }
 }
-/* vim: set ts=2 sts=2 sw=2 et: */
 /**
  * @fileoverview
- * TABULATOR RDF PARSER
+ *  RDF/XML PARSER
  *
  * Version 0.1
  *  Parser believed to be in full positive RDF/XML parsing compliance
@@ -1458,7 +1448,6 @@ if ((typeof module !== "undefined" && module !== null ? module.exports : void 0)
  *  and industry standards where appropriate (DOM, ECMAScript, &c.)
  *
  *  Author: David Sheets <dsheets@mit.edu>
- *  SVN ID: $Id$
  *
  * W3C® SOFTWARE NOTICE AND LICENSE
  * http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
@@ -1467,13 +1456,13 @@ if ((typeof module !== "undefined" && module !== null ? module.exports : void 0)
  * the following license. By obtaining, using and/or copying this work,
  * you (the licensee) agree that you have read, understood, and will
  * comply with the following terms and conditions.
- *
+ * 
  * Permission to copy, modify, and distribute this software and its
  * documentation, with or without modification, for any purpose and
  * without fee or royalty is hereby granted, provided that you include
  * the following on ALL copies of the software and documentation or
  * portions thereof, including modifications:
- *
+ * 
  * 1. The full text of this NOTICE in a location viewable to users of
  * the redistributed or derivative work.
  * 2. Any pre-existing intellectual property disclaimers, notices, or terms and
@@ -1483,18 +1472,18 @@ if ((typeof module !== "undefined" && module !== null ? module.exports : void 0)
  * 3. Notice of any changes or modifications to the files, including the
  * date changes were made. (We recommend you provide URIs to the location
  * from which the code is derived.)
- *
+ * 
  * THIS SOFTWARE AND DOCUMENTATION IS PROVIDED "AS IS," AND COPYRIGHT
  * HOLDERS MAKE NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED,
  * INCLUDING BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY OR FITNESS
  * FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF THE SOFTWARE OR
  * DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY PATENTS, COPYRIGHTS,
  * TRADEMARKS OR OTHER RIGHTS.
- *
+ * 
  * COPYRIGHT HOLDERS WILL NOT BE LIABLE FOR ANY DIRECT, INDIRECT, SPECIAL
  * OR CONSEQUENTIAL DAMAGES ARISING OUT OF ANY USE OF THE SOFTWARE OR
  * DOCUMENTATION.
- *
+ * 
  * The name and trademarks of copyright holders may NOT be used in
  * advertising or publicity pertaining to the software without specific,
  * written prior permission. Title to copyright in this software and any
@@ -1503,567 +1492,436 @@ if ((typeof module !== "undefined" && module !== null ? module.exports : void 0)
  */
 /**
  * @class Class defining an RDFParser resource object tied to an RDFStore
- *
+ *  
  * @author David Sheets <dsheets@mit.edu>
  * @version 0.1
- *
+ * 
  * @constructor
  * @param {RDFStore} store An RDFStore object
  */
-$rdf.RDFParser = function (store) {
-  var RDFParser = {};
-
-  /** Standard namespaces that we know how to handle @final
-   *  @member RDFParser
-   */
-  RDFParser['ns'] = {
-    'RDF': "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
-    'RDFS': "http://www.w3.org/2000/01/rdf-schema#"
-  };
-  /** DOM Level 2 node type magic numbers @final
-   *  @member RDFParser
-   */
-  RDFParser['nodeType'] = {
-    'ELEMENT': 1, 'ATTRIBUTE': 2, 'TEXT': 3,
-    'CDATA_SECTION': 4, 'ENTITY_REFERENCE': 5,
-    'ENTITY': 6, 'PROCESSING_INSTRUCTION': 7,
-    'COMMENT': 8, 'DOCUMENT': 9, 'DOCUMENT_TYPE': 10,
-    'DOCUMENT_FRAGMENT': 11, 'NOTATION': 12
-  };
+ 
+ $rdf.RDFParser = function(store){
+    var RDFParser = {};
+    
+    /** Standard namespaces that we know how to handle @final
+     *  @member RDFParser
+     */
+    RDFParser.ns = {'RDF': "http://www.w3.org/1999/02/22-rdf-syntax-ns#", 'RDFS': "http://www.w3.org/2000/01/rdf-schema#"};
+    
+    /** DOM Level 2 node type magic numbers @final
+     *  @member RDFParser
+     */
+    RDFParser.nodeType = {'ELEMENT': 1, 'ATTRIBUTE': 2, 'TEXT': 3,
+			     'CDATA_SECTION': 4, 'ENTITY_REFERENCE': 5,
+			     'ENTITY': 6, 'PROCESSING_INSTRUCTION': 7,
+			     'COMMENT': 8, 'DOCUMENT': 9, 'DOCUMENT_TYPE': 10,
+			     'DOCUMENT_FRAGMENT': 11, 'NOTATION': 12};
 
-  /**
-   * Frame class for namespace and base URI lookups
-   * Base lookups will always resolve because the parser knows
-   * the default base.
-   *
-   * @private
-   */
-  this['frameFactory'] = function (parser, parent, element) {
-    return {
-      'NODE': 1,
-      'ARC': 2,
-      'parent': parent,
-      'parser': parser,
-      'store': parser['store'],
-      'element': element,
-      'lastChild': 0,
-      'base': null,
-      'lang': null,
-      'node': null,
-      'nodeType': null,
-      'listIndex': 1,
-      'rdfid': null,
-      'datatype': null,
-      'collection': false,
-
-      /** Terminate the frame and notify the store that we're done */
-      'terminateFrame': function () {
-        if (this['collection']) {
-          this['node']['close']();
-        }
-      },
-
-      /** Add a symbol of a certain type to the this frame */
-      'addSymbol': function (type, uri) {
-        uri = $rdf.Util.uri.join(uri, this['base']);
-        this['node'] = this['store']['sym'](uri);
-        this['nodeType'] = type;
-      },
-
-      /** Load any constructed triples into the store */
-      'loadTriple': function () {
-        if (this['parent']['parent']['collection']) {
-          this['parent']['parent']['node']['append'](this['node']);
+    /**
+     * Frame class for namespace and base URI lookups
+     * Base lookups will always resolve because the parser knows
+     * the default base.
+     *
+     * @private
+     */
+    
+    this.frameFactory = function(parser, parent, element){
+        return {'NODE': 1, 'ARC': 2, 'parent': parent, 'parser': parser, 'store': parser.store, 'element': element, 
+           'lastChild': 0, 'base': null, 'lang': null, 'node': null, 'nodeType': null, 'listIndex': 1, 'rdfid': null, 'datatype': null, 'collection': false, /** Terminate the frame and notify the store that we're done */
+           'terminateFrame': function(){
+            if (this.collection){
+                
+                this.node.close();
+            }
         }
-        else {
-          this['store']['add'](
-                this['parent']['parent']['node'],
-                this['parent']['node'],
-                this['node'],
-                this['parser']['why']
-              );
-        }
-        if (this['parent']['rdfid']) { // reify
-          var triple = this['store']['sym'](
-                $rdf.Util.uri.join("#"+this['parent']['rdfid'],
-                this['base'])
-              );
-          this['store']['add'](triple,
-                this['store']['sym'](
-                      RDFParser['ns']['RDF'] + "type"
-                    ),
-                this['store']['sym'](
-                      RDFParser['ns']['RDF'] + "Statement"
-                    ),
-                this['parser']['why']
-              );
-          this['store']['add'](triple,
-                this['store']['sym'](
-                      RDFParser['ns']['RDF'] + "subject"
-                    ),
-                this['parent']['parent']['node'],
-                this['parser']['why']
-              );
-          this['store']['add'](triple,
-                this['store']['sym'](
-                      RDFParser['ns']['RDF'] + "predicate"
-                    ),
-                this['parent']['node'],
-                this['parser']['why']
-              );
-          this['store']['add'](triple,
-                this['store']['sym'](
-                      RDFParser['ns']['RDF'] + "object"),
-                this['node'],
-                this['parser']['why']
-              );
-        }
-      },
-
-      /** Check if it's OK to load a triple */
-      'isTripleToLoad': function () {
-        return ((this['parent']) &&
-                (this['parent']['parent']) &&
-                (this['nodeType'] === this['NODE']) &&
-                (this['parent']['nodeType'] === this['ARC']) &&
-                (this['parent']['parent']['nodeType'] === this['NODE']));
-      },
-
-      /** Add a symbolic node to this frame */
-      'addNode': function (uri) {
-        this['addSymbol'](this['NODE'],uri);
-        if (this['isTripleToLoad']()) {
-          this['loadTriple']();
-        }
-      },
-
-      /** Add a collection node to this frame */
-      'addCollection': function () {
-        this['nodeType'] = this['NODE'];
-        this['node'] = this['store']['collection']();
-        this['collection'] = true;
-        if (this['isTripleToLoad']()) {
-          this['loadTriple']();
-        }
-      },
-
-      /** Add a collection arc to this frame */
-      'addCollectionArc': function () {
-        this['nodeType'] = this['ARC'];
-      },
-
-      /** Add a bnode to this frame */
-      'addBNode': function (id) {
-        if (id) {
-          if (this['parser']['bnodes'][id]) {
-            this['node'] = this['parser']['bnodes'][id];
-          } else {
-            this['node'] = this['parser']['bnodes'][id] = this['store']['bnode']();
-          }
-        } else {
-          this['node'] = this['store']['bnode']();
+        , /** Add a symbol of a certain type to the this frame */'addSymbol': function(type, uri){
+            uri = $rdf.Util.uri.join(uri, this.base);
+            this.node = this.store.sym(uri);
+            
+            this.nodeType = type;
         }
-
-        this['nodeType'] = this['NODE'];
-        if (this['isTripleToLoad']()) {
-          this['loadTriple']();
+        , /** Load any constructed triples into the store */'loadTriple': function(){
+            if (this.parent.parent.collection){
+                this.parent.parent.node.append(this.node);
+            }
+            else {
+                this.store.add(this.parent.parent.node, this.parent.node, this.node, this.parser.why);
+            }
+            if (this.parent.rdfid != null){
+                  // reify
+                var triple = this.store.sym($rdf.Util.uri.join("#" + this.parent.rdfid, this.base));
+                this.store.add(triple, this.store.sym(RDFParser.ns.RDF + "type"), this.store.sym(RDFParser.ns.RDF + "Statement"), this.parser.why);
+                this.store.add(triple, this.store.sym(RDFParser.ns.RDF + "subject"), this.parent.parent.node, this.parser.why);
+                this.store.add(triple, this.store.sym(RDFParser.ns.RDF + "predicate"), this.parent.node, this.parser.why);
+                
+                this.store.add(triple, this.store.sym(RDFParser.ns.RDF + "object"), this.node, this.parser.why);
+            }
         }
-      },
-
-      /** Add an arc or property to this frame */
-      'addArc': function (uri) {
-        if (uri === RDFParser['ns']['RDF']+"li") {
-          uri = RDFParser['ns']['RDF'] + "_" + this['parent']['listIndex']++;
+        , /** Check if it's OK to load a triple */'isTripleToLoad': function(){
+            
+            return (this.parent != null && this.parent.parent != null && this.nodeType === this.NODE && this.parent.nodeType === 
+               this.ARC && this.parent.parent.nodeType === this.NODE);
         }
-        this['addSymbol'](this['ARC'], uri);
-      },
-
-      /** Add a literal to this frame */
-      'addLiteral': function (value) {
-        if (this['parent']['datatype']) {
-          this['node'] = this['store']['literal'](
-                value, "",
-                this['store']['sym'](this['parent']['datatype'])
-              );
-        } else {
-          this['node'] = this['store']['literal'](value, this['lang']);
+        , /** Add a symbolic node to this frame */'addNode': function(uri){
+            this.addSymbol(this.NODE, uri);
+            if (this.isTripleToLoad()){
+                
+                this.loadTriple();
+            }
         }
-        this['nodeType'] = this['NODE'];
-        if (this['isTripleToLoad']()) {
-          this['loadTriple']();
+        , /** Add a collection node to this frame */'addCollection': function(){
+            this.nodeType = this.NODE;
+            this.node = this.store.collection();
+            this.collection = true;
+            if (this.isTripleToLoad()){
+                
+                this.loadTriple();
+            }
         }
-      }
-    };
-  };
-
-  // from the OpenLayers source .. needed to get around IE problems.
-  this['getAttributeNodeNS'] = function(node, uri, name) {
-    var attributeNode = null;
-    if(node.getAttributeNodeNS) {
-      attributeNode = node.getAttributeNodeNS(uri, name);
-    } else {
-      var attributes = node.attributes;
-      var potentialNode, fullName;
-      for (var i = 0, len = attributes.length; i < len; i = i + i) {
-        potentialNode = attributes[i];
-        if (potentialNode.namespaceURI === uri) {
-          fullName = (potentialNode.prefix) ?
-                     (potentialNode.prefix + ":" + name) : name;
-          if (fullName === potentialNode.nodeName) {
-            attributeNode = potentialNode;
-            break;
-          }
+        , /** Add a collection arc to this frame */'addCollectionArc': function(){
+            
+            this.nodeType = this.ARC;
         }
-      }
-    }
-    return attributeNode;
-  };
-
-  /** Our triple store reference @private */
-  this['store'] = store;
-  /** Our identified blank nodes @private */
-  this['bnodes'] = {};
-  /** A context for context-aware stores @private */
-  this['why'] = null;
-  /** Reification flag */
-  this['reify'] = false;
-
-  /**
-   * Build our initial scope frame and parse the DOM into triples
-   * @param {DOMTree} document The DOM to parse
-   * @param {String} base The base URL to use
-   * @param {Object} why The context to which this resource belongs
-   */
-  this['parse'] = function (document, base, why) {
-    var children = document['childNodes'];
-
-    // clean up for the next run
-    this['cleanParser']();
-
-    var root;
-    // figure out the root element
-    //var root = document.documentElement; //this is faster, I think, cross-browser issue? well, DOM 2
-    if (document['nodeType'] === RDFParser['nodeType']['DOCUMENT']) {
-      for (var c = 0, len = children['length']; c < len; c = c + 1) {
-        if (children[c]['nodeType'] === RDFParser['nodeType']['ELEMENT']) {
-          root = children[c];
-          break;
+        , /** Add a bnode to this frame */'addBNode': function(id){
+            if (id != null){
+                if (this.parser.bnodes[id] != null){
+                    this.node = this.parser.bnodes[id];
+                }
+                else {
+                    this.node = this.parser.bnodes[id] = this.store.bnode();
+                }
+            }
+            else {
+                this.node = this.store.bnode();
+            }
+            this.nodeType = this.NODE;
+            if (this.isTripleToLoad()){
+                
+                this.loadTriple();
+            }
         }
-      }
-    }
-    else if (document['nodeType'] === RDFParser['nodeType']['ELEMENT']) {
-      root = document;
-    }
-    else {
-      throw new Error("RDFParser: can't find root in " + base + ". Halting. ");
-    }
-
-    this['why'] = why;
-
-    // our topmost frame
-    var f = this['frameFactory'](this);
-    this['base'] = base;
-    f['base'] = base;
-    f['lang'] = '';
-
-    this['parseDOM'](this['buildFrame'](f,root));
-    return true;
-  };
-
-  this['parseDOM'] = function (frame) {
-    // a DOM utility function used in parsing
-    var elementURI = function (el) {
-      var result = "";
-      if (!el['namespaceURI']) {
-        throw new Error("RDF/XML syntax error: No namespace for " +
-                         el['localName'] + " in " + this.base);
-      } else if( el['localName'] ) {
-        result = result + el['localName'];
-      } else if( el['nodeName'] ) {
-        if (el['nodeName'].indexOf(":") >= 0) {
-          result = result + el['nodeName'].split(":")[1];
-        } else {
-          result = result + el['nodeName'];
+        , /** Add an arc or property to this frame */'addArc': function(uri){
+            if (uri === RDFParser.ns.RDF + "li"){
+                uri = RDFParser.ns.RDF + "_" + this.parent.listIndex;
+                this.parent.listIndex++;
+            }
+            
+            this.addSymbol(this.ARC, uri);
         }
-      } else {
-        result = result + el['namespaceURI'];
-      }
-      return result;
-    }.bind(this);
-
-    var dig = true; // if we'll dig down in the tree on the next iter
-
-    while (frame['parent']) {
-      var dom = frame['element'];
-      var attrs = dom['attributes'];
-      var rdfid, bnid;
-
-      if ((dom['nodeType'] === RDFParser['nodeType']['TEXT']) ||
-          (dom['nodeType'] === RDFParser['nodeType']['CDATA_SECTION'])) {//we have a literal
-        frame['addLiteral'](dom['nodeValue']);
-      } else if (elementURI(dom) !== RDFParser['ns']['RDF'] + "RDF") { // not root
-        if (frame['parent'] && frame['parent']['collection']) {
-          // we're a collection element
-          frame['addCollectionArc']();
-          frame = this['buildFrame'](frame,frame['element']);
-          frame['parent']['element'] = null;
-        }
-
-        if ((!frame['parent']) ||
-            (!frame['parent']['nodeType']) ||
-            (frame['parent']['nodeType'] === frame['ARC'])) {
-          // we need a node
-          var about = this['getAttributeNodeNS'](dom,
-                RDFParser['ns']['RDF'],
-                "about"
-              );
-          rdfid = this['getAttributeNodeNS'](dom,
-                RDFParser['ns']['RDF'],
-                "ID"
-              );
-          if (about && rdfid) {
-            throw new Error("RDFParser: " + dom['nodeName'] +
-                            " has both rdf:id and rdf:about." +
-                            " Halting. Only one of these" +
-                            " properties may be specified on a" +
-                            " node.");
-          }
-
-          if ((!about) && (rdfid)) {
-            frame['addNode']("#" + rdfid['nodeValue']);
-            dom['removeAttributeNode'](rdfid);
-          } else if ((!about) && (!rdfid)) {
-            bnid = this['getAttributeNodeNS'](dom,
-                  RDFParser['ns']['RDF'],
-                  "nodeID"
-                );
-            if (bnid) {
-              frame['addBNode'](bnid['nodeValue']);
-              dom['removeAttributeNode'](bnid);
-            } else {
-              frame['addBNode']();
+        , /** Add a literal to this frame */'addLiteral': function(value){
+            if (this.parent.datatype){
+                this.node = this.store.literal(value, "", this.store.sym(this.parent.datatype));
             }
-          } else {
-            frame['addNode'](about['nodeValue']);
-            dom['removeAttributeNode'](about);
-          }
-
-          // Typed nodes
-          var rdftype = this['getAttributeNodeNS'](dom,
-                RDFParser['ns']['RDF'],
-                "type"
-              );
-          if (RDFParser['ns']['RDF'] + "Description" !== elementURI(dom)) {
-            rdftype = {'nodeValue': elementURI(dom)};
-          }
-
-          if (rdftype) {
-            this['store']['add'](
-                  frame['node'],
-                  this['store']['sym'](
-                        RDFParser['ns']['RDF'] + "type"
-                      ),
-                  this['store']['sym'](
-                        $rdf.Util.uri.join(
-                              rdftype['nodeValue'],
-                              frame['base']
-                            )
-                      ),
-                  this['why']
-                );
-            if (rdftype['nodeName']) {
-              dom['removeAttributeNode'](rdftype);
+            else {
+                this.node = this.store.literal(value, this.lang);
             }
-          }
-
-          // Property Attributes
-          for (var x = attrs['length']-1; x >= 0; x--) {
-            this['store']['add'](
-                  frame['node'],
-                  this['store']['sym'](elementURI(attrs[x])),
-                  this['store']['literal'](
-                        attrs[x]['nodeValue'],
-                        frame['lang']
-                      ),
-                  this['why']
-                );
-          }
-        } else { // we should add an arc (or implicit bnode+arc)
-          frame['addArc'](elementURI(dom));
-
-          // save the arc's rdf:ID if it has one
-          if (this['reify']) {
-            rdfid = this['getAttributeNodeNS'](dom,
-                  RDFParser['ns']['RDF'],
-                  "ID"
-                );
-            if (rdfid) {
-              frame['rdfid'] = rdfid['nodeValue'];
-              dom['removeAttributeNode'](rdfid);
+            this.nodeType = this.NODE;
+            if (this.isTripleToLoad()){
+                this.loadTriple();
             }
-          }
-
-          var parsetype = this['getAttributeNodeNS'](dom,
-                RDFParser['ns']['RDF'],
-                "parseType"
-              );
-          var datatype = this['getAttributeNodeNS'](dom,
-                RDFParser['ns']['RDF'],
-                "datatype"
-              );
-          if (datatype) {
-            frame['datatype'] = datatype['nodeValue'];
-            dom['removeAttributeNode'](datatype);
-          }
-
-          if (parsetype) {
-            var nv = parsetype['nodeValue'];
-            if (nv === "Literal") {
-              frame['datatype'] = RDFParser['ns']['RDF'] + "XMLLiteral";
-              // (this.buildFrame(frame)).addLiteral(dom)
-              // should work but doesn't
-              frame = this['buildFrame'](frame);
-              frame['addLiteral'](dom);
-              dig = false;
-            } else if (nv === "Resource") {
-              frame = this['buildFrame'](frame,frame['element']);
-              frame['parent']['element'] = null;
-              frame['addBNode']();
-            } else if (nv == "Collection") {
-              frame = this['buildFrame'](frame,frame['element']);
-              frame['parent']['element'] = null;
-              frame['addCollection']();
-            }
-            dom['removeAttributeNode'](parsetype);
-          }
-
-          if (attrs['length'] !== 0) {
-            var resource = this['getAttributeNodeNS'](dom,
-                  RDFParser['ns']['RDF'],
-                  "resource"
-                );
-            bnid = this['getAttributeNodeNS'](dom,
-                  RDFParser['ns']['RDF'],
-                  "nodeID"
-                );
-
-            frame = this['buildFrame'](frame);
-            if (resource) {
-              frame['addNode'](resource['nodeValue']);
-              dom['removeAttributeNode'](resource);
-            } else {
-              if (bnid) {
-                frame['addBNode'](bnid['nodeValue']);
-                dom['removeAttributeNode'](bnid);
-              } else {
-                frame['addBNode']();
-              }
-            }
-
-            for (var y = attrs['length']-1; y >= 0; y--) {
-              var f = this['buildFrame'](frame);
-              f['addArc'](elementURI(attrs[y]));
-              if (elementURI(attrs[y]) === RDFParser['ns']['RDF'] + "type") {
-                (this['buildFrame'](f))['addNode'](attrs[y]['nodeValue']);
-              } else {
-                (this['buildFrame'](f))['addLiteral'](attrs[y]['nodeValue']);
-              }
-            }
-          } else if (dom['childNodes']['length'] === 0) {
-            (this['buildFrame'](frame))['addLiteral']("");
-          }
         }
-      } // rdf:RDF
-
-      // dig dug
-      dom = frame['element'];
-      while (frame['parent']) {
-        var pframe = frame;
-        while (!dom) {
-          frame = frame['parent'];
-          dom = frame['element'];
-        }
-        var candidate = dom['childNodes'][frame['lastChild']];
-        if ((!candidate) || (!dig)) {
-          frame['terminateFrame']();
-          if (!(frame = frame['parent'])) { break; } // done
-          dom = frame['element'];
-          dig = true;
-        } else if (((candidate['nodeType'] !== RDFParser['nodeType']['ELEMENT']) &&
-                    (candidate['nodeType'] !== RDFParser['nodeType']['TEXT']) &&
-                    (candidate['nodeType'] !== RDFParser['nodeType']['CDATA_SECTION'])) ||
-                   ((candidate['nodeType'] === RDFParser['nodeType']['TEXT']) ||
-                    (candidate['nodeType'] === RDFParser['nodeType']['CDATA_SECTION'])) &&
-                   (dom['childNodes']['length'] != 1)) {
-          frame['lastChild']++;
-        } else { // not a leaf
-          frame['lastChild']++;
-          frame = this['buildFrame'](
-                pframe,
-                dom['childNodes'][frame['lastChild'] - 1]
-              );
-          break;
+        };
+    };
+    
+    //from the OpenLayers source .. needed to get around IE problems.
+    this.getAttributeNodeNS = function(node, uri, name){
+        var attributeNode = null;
+        if (node.getAttributeNodeNS){
+            attributeNode = node.getAttributeNodeNS(uri, name);
         }
-      } // while
-    } // while
-
+        else {
+            var attributes = node.attributes;
+            var potentialNode, fullName;
+            for (var i = 0;i < attributes.length; ++ i){
+                potentialNode = attributes[i];
+                if (potentialNode.namespaceURI === uri){
+                    fullName = (potentialNode.prefix) ? (potentialNode.prefix +":" + name): name;
+                    if (fullName === potentialNode.nodeName){
+                        attributeNode = potentialNode;
+                        break;
+                    }
+                }
+            }
+        }
+        return attributeNode;
+    };
+    
+    
+    /** Our triple store reference @private */
+    
+    this.store = store;/** Our identified blank nodes @private */
+    this.bnodes = {};/** A context for context-aware stores @private */
+    this.why = null;/** Reification flag */
+    this.reify = false;
+    
+    /**
+     * Build our initial scope frame and parse the DOM into triples
+     * @param {DOMTree} document The DOM to parse
+     * @param {String} base The base URL to use 
+     * @param {Object} why The context to which this resource belongs
+     */
+    
+    this.parse = function(document, base, why){
+        var children = document.childNodes;// clean up for the next run
+        this.cleanParser();// figure out the root element
+        var root;
+        if (document.nodeType === RDFParser.nodeType.DOCUMENT){
+            for (var c = 0;c < children.length;c++){
+                if (children[c].nodeType === RDFParser.nodeType.ELEMENT){
+                    root = children[c];
+                    break;
+                }
+            }
+        }
+        else if (document.nodeType === RDFParser.nodeType.ELEMENT){
+            root = document;
+        }
+        else {
+            throw new Error("RDFParser: can't find root in " + base +". Halting. ");
+            // return false;
+        }
+        this.why = why;// our topmost frame
+        var f = this.frameFactory(this);
+        this.base = base;
+        f.base = base;
+        f.lang = '';
+        this.parseDOM(this.buildFrame(f, root));
+        return true;
+    };
+    
+    this.parseDOM = function(frame){
+         // a DOM utility function used in parsing
+        var rdfid;
+        var elementURI = function(el){
+            var result = "";
+            if (el.namespaceURI == null){
+                throw new Error("RDF/XML syntax error: No namespace for " + el.localName + " in " + this.base);
+            }
+            if (el.namespaceURI){
+                result = result + el.namespaceURI;
+            }
+            if (el.localName){
+                result = result + el.localName;
+            }
+            else if (el.nodeName){
+                if (el.nodeName.indexOf(":") >= 0)result = result + el.nodeName.split(":")[1];
+                else result = result + el.nodeName;
+            }
+            return result;
+        }.bind(this);
+        var dig = true;// if we'll dig down in the tree on the next iter
+        while (frame.parent){
+            var dom = frame.element;
+            var attrs = dom.attributes;
+            if (dom.nodeType === RDFParser.nodeType.TEXT || dom.nodeType === RDFParser.nodeType.CDATA_SECTION){
+                  //we have a literal
+                frame.addLiteral(dom.nodeValue);
+            }
+            else if (elementURI(dom)!== RDFParser.ns.RDF + "RDF"){
+                  // not root
+                if (frame.parent && frame.parent.collection){
+                     // we're a collection element
+                    frame.addCollectionArc();
+                    frame = this.buildFrame(frame, frame.element);
+                    frame.parent.element = null;
+                }
+                if ( ! frame.parent || ! frame.parent.nodeType || frame.parent.nodeType === frame.ARC){
+                     // we need a node
+                    var about = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, "about");
+                    rdfid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, "ID");
+                    if (about && rdfid){
+                        throw new Error("RDFParser: " + dom.nodeName + " has both rdf:id and rdf:about." + 
+                           " Halting. Only one of these" + " properties may be specified on a" + " node.");
+                    }
+                    if (!about && rdfid){
+                        frame.addNode("#" + rdfid.nodeValue);
+                        dom.removeAttributeNode(rdfid);
+                    }
+                    else if (about == null && rdfid == null){
+                        var bnid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, "nodeID");
+                        if (bnid){
+                            frame.addBNode(bnid.nodeValue);
+                            dom.removeAttributeNode(bnid);
+                        }
+                        else {
+                            frame.addBNode();
+                        }
+                    }
+                    else {
+                        frame.addNode(about.nodeValue);
+                        dom.removeAttributeNode(about);
+                    }
+                    // Typed nodes
+                    var rdftype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, "type");
+                    if (RDFParser.ns.RDF + "Description" !== elementURI(dom)){
+                        rdftype = {'nodeValue': elementURI(dom)};
+                    }
+                    if (rdftype != null){
+                        this.store.add(frame.node, this.store.sym(RDFParser.ns.RDF + "type"), this.store.sym($rdf.Util.uri.join(rdftype.nodeValue, 
+                           frame.base)), this.why);
+                        if (rdftype.nodeName){
+                            dom.removeAttributeNode(rdftype);
+                        }
+                    }
+                    // Property Attributes
+                    for (var x = attrs.length - 1;x >= 0;x--){
+                        this.store.add(frame.node, this.store.sym(elementURI(attrs[x])), this.store.literal(attrs[x].nodeValue, 
+                           frame.lang), this.why);
+                    }
+                }
+                else {
+                      // we should add an arc (or implicit bnode+arc)
+                    frame.addArc(elementURI(dom));// save the arc's rdf:ID if it has one
+                    if (this.reify){
+                        rdfid = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, "ID");
+                        if (rdfid){
+                            frame.rdfid = rdfid.nodeValue;
+                            dom.removeAttributeNode(rdfid);
+                        }
+                    }
+                    var parsetype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, "parseType");
+                    var datatype = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, "datatype");
+                    if (datatype){
+                        frame.datatype = datatype.nodeValue;
+                        dom.removeAttributeNode(datatype);
+                    }
+                    if (parsetype){
+                        var nv = parsetype.nodeValue;
+                        if (nv === "Literal"){
+                            frame.datatype = RDFParser.ns.RDF + "XMLLiteral";// (this.buildFrame(frame)).addLiteral(dom)
+                               // should work but doesn't
+                            frame = this.buildFrame(frame);
+                            frame.addLiteral(dom);
+                            dig = false;
+                        }
+                        else if (nv === "Resource"){
+                            frame = this.buildFrame(frame, frame.element);
+                            frame.parent.element = null;
+                            frame.addBNode();
+                        }
+                        else if (nv === "Collection"){
+                            frame = this.buildFrame(frame, frame.element);
+                            frame.parent.element = null;
+                            frame.addCollection();
+                        }
+                        dom.removeAttributeNode(parsetype);
+                    }
+                    if (attrs.length !== 0){
+                        var resource = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, "resource");
+                        var bnid2 = this.getAttributeNodeNS(dom, RDFParser.ns.RDF, "nodeID");
+                        frame = this.buildFrame(frame);
+                        if (resource){
+                            frame.addNode(resource.nodeValue);
+                            dom.removeAttributeNode(resource);
+                        }
+                        else {
+                            if (bnid2){
+                                frame.addBNode(bnid2.nodeValue);
+                                dom.removeAttributeNode(bnid2);
+                            }
+                            else {
+                                frame.addBNode();
+                            }
+                        }
+                        for (var x1 = attrs.length - 1; x1 >= 0; x1--){
+                            var f = this.buildFrame(frame);
+                            f.addArc(elementURI(attrs[x1]));
+                            if (elementURI(attrs[x1])=== RDFParser.ns.RDF + "type"){
+                                (this.buildFrame(f)).addNode(attrs[x1].nodeValue);
+                            }
+                            else {
+                                (this.buildFrame(f)).addLiteral(attrs[x1].nodeValue);
+                            }
+                        }
+                    }
+                    else if (dom.childNodes.length === 0){
+                        (this.buildFrame(frame)).addLiteral("");
+                    }
+                }
+            }// rdf:RDF
+               // dig dug
+            dom = frame.element;
+            while (frame.parent){
+                var pframe = frame;
+                while (dom == null){
+                    frame = frame.parent;
+                    dom = frame.element;
+                }
+                var candidate = dom.childNodes && dom.childNodes[frame.lastChild];
+                if (!candidate || ! dig){
+                    frame.terminateFrame();
+                    if ( ! (frame = frame.parent)){
+                        break;
+                    }// done
+                    dom = frame.element;
+                    dig = true;
+                }
+                else if ((candidate.nodeType !== RDFParser.nodeType.ELEMENT &&
+                        candidate.nodeType !== RDFParser.nodeType.TEXT && 
+                        candidate.nodeType !== RDFParser.nodeType.CDATA_SECTION) ||
+                    ((candidate.nodeType === RDFParser.nodeType.TEXT ||
+                        candidate.nodeType === RDFParser.nodeType.CDATA_SECTION) && 
+                        dom.childNodes.length !== 1)){
+                    frame.lastChild++;
+                }
+                else {
+                      // not a leaf
+                    frame.lastChild++;
+                    frame = this.buildFrame(pframe, dom.childNodes[frame.lastChild - 1]);
+                    break;
+                }
+            }
+        }// while
+    };
+    
     /**
      * Cleans out state from a previous parse run
      * @private
      */
-    this['cleanParser'] = function () {
-      this['bnodes'] = {};
-      this['why'] = null;
+    this.cleanParser = function(){
+        this.bnodes = {};
+        this.why = null;
     };
-
+    
     /**
-     * Builds scope frame
+     * Builds scope frame 
      * @private
      */
-    this['buildFrame'] = function (parent, element) {
-      var frame = this['frameFactory'](this,parent,element);
-      if (parent) {
-        frame['base'] = parent['base'];
-        frame['lang'] = parent['lang'];
-      }
-
-      if ((!element) ||
-          (element['nodeType'] === RDFParser['nodeType']['TEXT']) ||
-          (element['nodeType'] === RDFParser['nodeType']['CDATA_SECTION'])) {
-        return frame;
-      }
-
-      var attrs = element['attributes'];
-
-      var base = element['getAttributeNode']("xml:base");
-      if (base) {
-        frame['base'] = base['nodeValue'];
-        element['removeAttribute']("xml:base");
-      }
-      var lang = element['getAttributeNode']("xml:lang");
-      if (lang) {
-        frame['lang'] = lang['nodeValue'];
-        element['removeAttribute']("xml:lang");
-      }
-
-      // remove all extraneous xml and xmlns attributes
-      for (var x = attrs['length']-1; x >= 0; x--) {
-        if (attrs[x]['nodeName']['substr'](0,3) === "xml") {
-          if (attrs[x].name.slice(0,6) === 'xmlns:') {
-            var uri = attrs[x].nodeValue;
-            // alert('base for namespac attr:'+this.base);
-            if (this.base) {
-              uri = $rdf.Util.uri.join(uri, this.base);
+    this.buildFrame = function(parent, element){
+        var frame = this.frameFactory(this, parent, element);
+        if (parent){
+            frame.base = parent.base;
+            frame.lang = parent.lang;
+        }
+        if (!element || element.nodeType === RDFParser.nodeType.TEXT ||
+                element.nodeType === RDFParser.nodeType.CDATA_SECTION){
+            return frame;
+        }
+        var attrs = element.attributes;
+        var base = element.getAttributeNode("xml:base");
+        if (base != null){
+            frame.base = base.nodeValue;
+            element.removeAttribute("xml:base");
+        }
+        var lang = element.getAttributeNode("xml:lang");
+        if (lang != null){
+            frame.lang = lang.nodeValue;
+            element.removeAttribute("xml:lang");
+        }
+        // remove all extraneous xml and xmlns attributes
+        for (var x = attrs.length - 1;x >= 0;x--){
+            if (attrs[x].nodeName.substr(0, 3) === "xml"){
+                if (attrs[x].name.slice(0, 6) === 'xmlns:'){
+                    var uri = attrs[x].nodeValue;// alert('base for namespac attr:'+this.base);
+                    if (this.base) uri = $rdf.Util.uri.join(uri, this.base);
+                    this.store.setPrefixForURI(attrs[x].name.slice(6), uri);
+                }
+                //		alert('rdfparser: xml atribute: '+attrs[x].name) //@@
+                element.removeAttributeNode(attrs[x]);
             }
-            this.store.setPrefixForURI(attrs[x].name.slice(6), uri);
-          }
-          //alert('rdfparser: xml atribute: '+attrs[x].name) //@@
-          element['removeAttributeNode'](attrs[x]);
         }
-      }
-      return frame;
+        return frame;
     };
-  };
 };
 /**
 *
@@ -2265,6 +2123,8 @@ var LOG_implies_URI = "http://www.w3.org/2000/10/swap/log#implies";
 var INTEGER_DATATYPE = "http://www.w3.org/2001/XMLSchema#integer";
 var FLOAT_DATATYPE = "http://www.w3.org/2001/XMLSchema#double";
 var DECIMAL_DATATYPE = "http://www.w3.org/2001/XMLSchema#decimal";
+var DATE_DATATYPE = "http://www.w3.org/2001/XMLSchema#date";
+var DATETIME_DATATYPE = "http://www.w3.org/2001/XMLSchema#dateTime";
 var BOOLEAN_DATATYPE = "http://www.w3.org/2001/XMLSchema#boolean";
 var option_noregen = 0;
 var _notQNameChars = "\t\r\n !\"#$%&'()*.,+/;<=>?@[\\]^`{|}~";
@@ -2276,6 +2136,8 @@ var eof = new RegExp("^[ \\t]*(#[^\\n]*)?$", 'g');
 var ws = new RegExp("^[ \\t]*", 'g');
 var signed_integer = new RegExp("^[-+]?[0-9]+", 'g');
 var number_syntax = new RegExp("^([-+]?[0-9]+)(\\.[0-9]+)?(e[-+]?[0-9]+)?", 'g');
+var datetime_syntax = new RegExp('[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9](T[0-9][0-9]:[0-9][0-9](:[0-9][0-9](\\.[0-9]*)?)?)?Z?');
+
 var digitstring = new RegExp("^[0-9]+", 'g');
 var interesting = new RegExp("[\\\\\\r\\n\\\"]", 'g');
 var langcode = new RegExp("^[a-zA-Z0-9]+(-[a-zA-Z0-9]+)?", 'g');
@@ -3355,23 +3217,38 @@ __SinkParser.prototype.nodeOrLiteral = function(str, i, res) {
         }
         var ch = str.charAt(i);
         if (("-+0987654321".indexOf(ch) >= 0)) {
-            number_syntax.lastIndex = 0;
-            var m = number_syntax.exec(str.slice(i));
-            if ((m == null)) {
-                throw BadSyntax(this._thisDoc, this.lines, str, i, "Bad number syntax");
-            }
-            var j =  ( i + number_syntax.lastIndex ) ;
-            var val = pyjslib_slice(str, i, j);
-            if ((val.indexOf("e") >= 0)) {
-                res.push(this._store.literal(parseFloat(val), undefined, this._store.sym(FLOAT_DATATYPE)));
-            }
-            else if ((pyjslib_slice(str, i, j).indexOf(".") >= 0)) {
-                res.push(this._store.literal(parseFloat(val), undefined, this._store.sym(DECIMAL_DATATYPE)));
-            }
-            else {
-                res.push(this._store.literal(parseInt(val), undefined, this._store.sym(INTEGER_DATATYPE)));
-            }
-            return j;
+	
+	    datetime_syntax.lastIndex = 0;
+            var m = datetime_syntax.exec(str.slice(i));
+            if ((m != null)) {
+		// j =  ( i + datetime_syntax.lastIndex ) ;
+		var val = m[0];
+		j = i + val.length;
+		if ((val.indexOf("T") >= 0)) {
+		    res.push(this._store.literal(val, undefined, this._store.sym(DATETIME_DATATYPE)));
+		} else {
+		    res.push(this._store.literal(val, undefined, this._store.sym(DATE_DATATYPE)));
+		}	
+	
+	    } else {
+		number_syntax.lastIndex = 0;
+		var m = number_syntax.exec(str.slice(i));
+		if ((m == null)) {
+		    throw BadSyntax(this._thisDoc, this.lines, str, i, "Bad number or date syntax");
+		}
+		j =  ( i + number_syntax.lastIndex ) ;
+		var val = pyjslib_slice(str, i, j);
+		if ((val.indexOf("e") >= 0)) {
+		    res.push(this._store.literal(parseFloat(val), undefined, this._store.sym(FLOAT_DATATYPE)));
+		}
+		else if ((pyjslib_slice(str, i, j).indexOf(".") >= 0)) {
+		    res.push(this._store.literal(parseFloat(val), undefined, this._store.sym(DECIMAL_DATATYPE)));
+		}
+		else {
+		    res.push(this._store.literal(parseInt(val), undefined, this._store.sym(INTEGER_DATATYPE)));
+		}
+	    };
+	    return j; // Where we have got up to
         }
         if ((str.charAt(i) == "\"")) {
             if ((pyjslib_slice(str, i,  ( i + 3 ) ) == "\"\"\"")) {
@@ -3727,8 +3604,11 @@ $rdf.IndexedFormula.prototype.setPrefixForURI = function(prefix, nsuri) {
     //See http://dig.csail.mit.edu/cgi-bin/roundup.cgi/$rdf/issue227
     if(prefix=="tab" && this.namespaces["tab"]) {
         return;
-    }
-    this.namespaces[prefix] = nsuri
+    } // There are files around with long badly generated prefixes like this
+    if (prefix.slice(0,2) === 'ns' || prefix.slice(0,7) === 'default') {
+        return;
+    };
+    this.namespaces[prefix] = nsuri;
 }
 
 // Deprocated ... name too generic
@@ -5315,495 +5195,546 @@ $rdf.SPARQLResultsInterpreter = function (xml, callback, doneCallback)
 	return bindingList;
 	//****END OF MAIN CODE*****
 }
-// Joe Presbrey <presbrey@mit.edu>
-// 2007-07-15
-// 2010-08-08 TimBL folded in Kenny's WEBDAV 
-// 2010-12-07 TimBL addred local file write code
-
-$rdf.sparqlUpdate = function() {
-
-    var anonymize = function (obj) {
-        return (obj.toNT().substr(0,2) == "_:")
-        ? "?" + obj.toNT().substr(2)
-        : obj.toNT();
-    }
-
-    var anonymizeNT = function(stmt) {
-        return anonymize(stmt.subject) + " " +
-        anonymize(stmt.predicate) + " " +
-        anonymize(stmt.object) + " .";
-    }
-
-    var sparql = function(store) {
-        this.store = store;
-        this.ifps = {};
-        this.fps = {};
-        this.ns = {};
-        this.ns.link = $rdf.Namespace("http://www.w3.org/2007/ont/link#");
-        this.ns.http = $rdf.Namespace("http://www.w3.org/2007/ont/http#");
-        this.ns.httph = $rdf.Namespace("http://www.w3.org/2007/ont/httph#");
-        this.ns.rdf =  $rdf.Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
-        this.ns.rdfs = $rdf.Namespace("http://www.w3.org/2000/01/rdf-schema#");
-        this.ns.rdf = $rdf.Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
-        this.ns.owl = $rdf.Namespace("http://www.w3.org/2002/07/owl#");
-    }
-
-
-    // Returns The method string SPARQL or DAV or LOCALFILE or false if known, undefined if not known.
-    //
-    // Files have to have a specific annotaton that they are machine written, for safety.
-    // We don't actually check for write access on files.
-    //
-    sparql.prototype.editable = function(uri, kb) {
-        if (!uri) return false; // Eg subject is bnode, no known doc to write to
-        if (!kb) kb = tabulator.kb;
-
-        if (uri.slice(0,8) == 'file:///') {
-            if (kb.holds(kb.sym(uri), tabulator.ns.rdf('type'), tabulator.ns.link('MachineEditableDocument')))
-                return 'LOCALFILE';
-            var sts = kb.statementsMatching(kb.sym(uri),undefined,undefined);
-            
-            tabulator.log.warn("sparql.editable: Not MachineEditableDocument file "+uri+"\n");
-            tabulator.log.warn(sts.map(function(x){return x.toNT();}).join('\n'))
-            return false;
-        //@@ Would be nifty of course to see whether we actually have write acess first.
-        }
-
-        var request;
-        var definitive = false;
-        var requests = kb.each(undefined, this.ns.link("requestedURI"), $rdf.Util.uri.docpart(uri));
-        for (var r=0; r<requests.length; r++) {
-            request = requests[r];
-            if (request !== undefined) {
-                var response = kb.any(request, this.ns.link("response"));
-                if (request !== undefined) {
-                    var author_via = kb.each(response, this.ns.httph("ms-author-via"));
-                    if (author_via.length) {
-                        for (var i = 0; i < author_via.length; i++) {
-                            var method = author_via[i].value.trim();
-                            if (method.indexOf('SPARQL') >=0 ) return 'SPARQL';
-                            if (method.indexOf('DAV') >=0 ) return 'DAV';
-//                            if (author_via[i].value == "SPARQL" || author_via[i].value == "DAV")
-                                // dump("sparql.editable: Success for "+uri+": "+author_via[i] +"\n");
-                                //return author_via[i].value;
-                                
-                        }
-                    }
-                    var status = kb.each(response, this.ns.http("status"));
-                    if (status.length) {
-                        for (var i = 0; i < status.length; i++) {
-                            if (status[i] == 200 || status[i] == 404) {
-                                definitive = true;
-                                // return false; // A definitive answer
-                            }
-                        }
-                    }
-                } else {
-                    tabulator.log.warn("sparql.editable: No response for "+uri+"\n");
-                }
-            }
-        }
-        if (requests.length == 0) {
-            tabulator.log.warn("sparql.editable: No request for "+uri+"\n");
-        } else {
-            if (definitive) return false;  // We have got a request and it did NOT say editable => not editable
-        };
-
-        tabulator.log.warn("sparql.editable: inconclusive for "+uri+"\n");
-        return undefined; // We don't know (yet) as we haven't had a response (yet)
-    }
-
-    ///////////  The identification of bnodes
-
-    sparql.prototype._statement_bnodes = function(st) {
-        return [st.subject, st.predicate, st.object].filter(function(x){return x.isBlank});
-    }
-
-    sparql.prototype._statement_array_bnodes = function(sts) {
-        var bnodes = [];
-        for (var i=0; i<sts.length;i++) bnodes = bnodes.concat(this._statement_bnodes(sts[i]));
-        bnodes.sort(); // in place sort - result may have duplicates
-        bnodes2 = [];
-        for (var j=0; j<bnodes.length; j++)
-            if (j==0 || !bnodes[j].sameTermAs(bnodes[j-1])) bnodes2.push(bnodes[j]);
-        return bnodes2;
-    }
-
-    sparql.prototype._cache_ifps = function() {
-        // Make a cached list of [Inverse-]Functional properties
-        // Call this once before calling context_statements
-        this.ifps = {};
-        var a = this.store.each(undefined, this.ns.rdf('type'), this.ns.owl('InverseFunctionalProperty'))
-        for (var i=0; i<a.length; i++) {
-            this.ifps[a[i].uri] = true;
-        }
-        this.fps = {};
-        var a = this.store.each(undefined, this.ns.rdf('type'), this.ns.owl('FunctionalProperty'))
-        for (var i=0; i<a.length; i++) {
-            this.fps[a[i].uri] = true;
-        }
-    }
-
-    sparql.prototype._bnode_context2 = function(x, source, depth) {
-        // Return a list of statements which indirectly identify a node
-        //  Depth > 1 if try further indirection.
-        //  Return array of statements (possibly empty), or null if failure
-        var sts = this.store.statementsMatching(undefined, undefined, x, source); // incoming links
-        for (var i=0; i<sts.length; i++) {
-            if (this.fps[sts[i].predicate.uri]) {
-                var y = sts[i].subject;
-                if (!y.isBlank)
-                    return [ sts[i] ];
-                if (depth) {
-                    var res = this._bnode_context2(y, source, depth-1);
-                    if (res != null)
-                        return res.concat([ sts[i] ]);
-                }
-            }        
-        }
-        var sts = this.store.statementsMatching(x, undefined, undefined, source); // outgoing links
-        for (var i=0; i<sts.length; i++) {
-            if (this.ifps[sts[i].predicate.uri]) {
-                var y = sts[i].object;
-                if (!y.isBlank)
-                    return [ sts[i] ];
-                if (depth) {
-                    var res = this._bnode_context2(y, source, depth-1);
-                    if (res != undefined)
-                        return res.concat([ sts[i] ]);
-                }
-            }        
-        }
-        return null; // Failure
-    }
-
-
-    sparql.prototype._bnode_context = function(x, source) {
-        // Return a list of statements which indirectly identify a node
-        //   Breadth-first
-        for (var depth = 0; depth < 3; depth++) { // Try simple first 
-            var con = this._bnode_context2(x, source, depth);
-            if (con != null) return con;
-        }
-        throw ('Unable to uniquely identify bnode: '+ x.toNT());
-    }
-
-    sparql.prototype._bnode_context = function(bnodes) {
-        var context = [];
-        if (bnodes.length) {
-            if (this.store.statementsMatching(st.subject.isBlank?undefined:st.subject,
-                                      st.predicate.isBlank?undefined:st.predicate,
-                                      st.object.isBlank?undefined:st.object,
-                                      st.why).length <= 1) {
-                context = context.concat(st);
-            } else {
-                this._cache_ifps();
-                for (x in bnodes) {
-                    context = context.concat(this._bnode_context(bnodes[x], st.why));
-                }
-            }
-        }
-        return context;
-    }
-
-    sparql.prototype._statement_context = function(st) {
-        var bnodes = this._statement_bnodes(st);
-        return this._bnode_context(bnodes);
-    }
-
-    sparql.prototype._context_where = function(context) {
-            return (context == undefined || context.length == 0)
-            ? ""
-            : "WHERE { " + context.map(anonymizeNT).join("\n") + " }\n";
-    }
-
-    sparql.prototype._fire = function(uri, query, callback) {
-        if (!uri) throw "No URI given for remote editing operation: "+query;
-        tabulator.log.info("sparql: sending update to <"+uri+">\n   query="+query+"\n");
-        var xhr = $rdf.Util.XMLHTTPFactory();
-
-        xhr.onreadystatechange = function() {
-            //dump("SPARQL update ready state for <"+uri+"> readyState="+xhr.readyState+"\n"+query+"\n");
-            if (xhr.readyState == 4) {
-                var success = (!xhr.status || (xhr.status >= 200 && xhr.status < 300));
-                if (!success) tabulator.log.error("sparql: update failed for <"+uri+"> status="+
-                    xhr.status+", "+xhr.statusText+", body length="+xhr.responseText.length+"\n   for query: "+query);
-                else  tabulator.log.debug("sparql: update Ok for <"+uri+">");
-                callback(uri, success, xhr.responseText);
-            }
-        }
-
-        if(!tabulator.isExtension) {
-            try {
-                $rdf.Util.enablePrivilege("UniversalBrowserRead")
-            } catch(e) {
-                alert("Failed to get privileges: " + e)
-            }
-        }
-        
-        xhr.open('POST', uri, true);  // async=true
-        xhr.setRequestHeader('Content-type', 'application/sparql-update');
-        xhr.send(query);
-    }
-
-    // This does NOT update the statement.
-    // It returns an object whcih includes
-    //  function which can be used to change the object of the statement.
-    //
-    sparql.prototype.update_statement = function(statement) {
-        if (statement && statement.why == undefined) return;
-
-        var sparql = this;
-        var context = this._statement_context(statement);
-
-        return {
-            statement: statement?[statement.subject, statement.predicate, statement.object, statement.why]:undefined,
-            statementNT: statement?anonymizeNT(statement):undefined,
-            where: sparql._context_where(context),
-
-            set_object: function(obj, callback) {
-                query = this.where;
-                query += "DELETE DATA { " + this.statementNT + " } ;\n";
-                query += "INSERT DATA { " +
-                    anonymize(this.statement[0]) + " " +
-                    anonymize(this.statement[1]) + " " +
-                    anonymize(obj) + " " + " . }\n";
-     
-                sparql._fire(this.statement[3].uri, query, callback);
-            }
-        }
-    }
-
-    sparql.prototype.insert_statement = function(st, callback) {
-        var st0 = st instanceof Array ? st[0] : st;
-        var query = this._context_where(this._statement_context(st0));
-        
-        if (st instanceof Array) {
-            var stText="";
-            for (var i=0;i<st.length;i++) stText+=st[i]+'\n';
-            query += "INSERT DATA { " + stText + " }\n";
-        } else {
-            query += "INSERT DATA { " +
-                anonymize(st.subject) + " " +
-                anonymize(st.predicate) + " " +
-                anonymize(st.object) + " " + " . }\n";
-        }
-        
-        this._fire(st0.why.uri, query, callback);
-    }
-
-    sparql.prototype.delete_statement = function(st, callback) {
-        var query = this._context_where(this._statement_context(st));
-        
-        query += "DELETE DATA { " + anonymizeNT(st) + " }\n";
-        
-        this._fire(st instanceof Array?st[0].why.uri:st.why.uri, query, callback);
-    }
-
-    // This high-level function updates the local store iff the web is changed successfully. 
-    //
-    //  - deletions, insertions may be undefined or single statements or lists or formulae.
-    //
-    //  - callback is called as callback(uri, success, errorbody)
-    //
-    sparql.prototype.update = function(deletions, insertions, callback) {
-        var kb = this.store;
-        tabulator.log.info("update called")
-        var ds =  deletions == undefined ? []
-                    : deletions instanceof $rdf.IndexedFormula ? deletions.statements
-                    : deletions instanceof Array ? deletions : [ deletions ];
-        var is =  insertions == undefined? []
-                    : insertions instanceof $rdf.IndexedFormula ? insertions.statements
-                    : insertions instanceof Array ? insertions : [ insertions ];
-        if (! (ds instanceof Array)) throw "Type Error "+(typeof ds)+": "+ds;
-        if (! (is instanceof Array)) throw "Type Error "+(typeof is)+": "+is;
-        var doc = ds.length ? ds[0].why : is[0].why;
-        
-        ds.map(function(st){if (!doc.sameTerm(st.why)) throw "sparql update: destination "+doc+" inconsistent with ds "+st.why;});
-        is.map(function(st){if (!doc.sameTerm(st.why)) throw "sparql update: destination = "+doc+" inconsistent with st.why ="+st.why;});
-
-        var protocol = this.editable(doc.uri, kb);
-        if (!protocol) throw "Can't make changes in uneditable "+doc;
-
-        if (protocol.indexOf('SPARQL') >=0) {
-            var bnodes = []
-            if (ds.length) bnodes = this._statement_array_bnodes(ds);
-            if (is.length) bnodes = bnodes.concat(this._statement_array_bnodes(is));
-            var context = this._bnode_context(bnodes);
-            var whereClause = this._context_where(context);
-            var query = ""
-            if (whereClause.length) { // Is there a WHERE clause?
-                if (ds.length) {
-                    query += "DELETE { ";
-                    for (var i=0; i<ds.length;i++) query+= anonymizeNT(ds[i])+"\n";
-                    query += " }\n";
-                }
-                if (is.length) {
-                    query += "INSERT { ";
-                    for (var i=0; i<is.length;i++) query+= anonymizeNT(is[i])+"\n";
-                    query += " }\n";
-                }
-                query += whereClause;
-            } else { // no where clause
-                if (ds.length) {
-                    query += "DELETE DATA { ";
-                    for (var i=0; i<ds.length;i++) query+= anonymizeNT(ds[i])+"\n";
-                    query += " } \n";
-                }
-                if (is.length) {
-                    if (ds.length) query += " ; ";
-                    query += "INSERT DATA { ";
-                    for (var i=0; i<is.length;i++) query+= anonymizeNT(is[i])+"\n";
-                    query += " }\n";
-                }
-            }
-            this._fire(doc.uri, query,
-                function(uri, success, body) {
-                    tabulator.log.info("\t sparql: Return success="+success+" for query "+query+"\n");
-                    if (success) {
-                        for (var i=0; i<ds.length;i++)
-                            try { kb.remove(ds[i]) } catch(e) {
-                                callback(uri, false,
-                                "sparqlUpdate: Remote OK but error deleting statemmnt "+
-                                    ds[i] + " from local store:\n" + e)
-                            }
-                        for (var i=0; i<is.length;i++)
-                            kb.add(is[i].subject, is[i].predicate, is[i].object, doc); 
-                    }
-                    callback(uri, success, body);
-                });
-            
-        } else if (protocol.indexOf('DAV') >=0) {
-
-            // The code below is derived from Kenny's UpdateCenter.js
-            var documentString;
-            var request = kb.any(doc, this.ns.link("request"));
-            if (!request) throw "No record of our HTTP GET request for document: "+doc; //should not happen
-            var response =  kb.any(request, this.ns.link("response"));
-            if (!response)  return null; // throw "No record HTTP GET response for document: "+doc;
-            var content_type = kb.the(response, this.ns.httph("content-type")).value;            
-
-            //prepare contents of revised document
-            var newSts = kb.statementsMatching(undefined, undefined, undefined, doc).slice(); // copy!
-            for (var i=0;i<ds.length;i++) $rdf.Util.RDFArrayRemove(newSts, ds[i]);
-            for (var i=0;i<is.length;i++) newSts.push(is[i]);                                     
-            
-            //serialize to te appropriate format
-            var sz = $rdf.Serializer(kb);
-            sz.suggestNamespaces(kb.namespaces);
-            sz.setBase(doc.uri);//?? beware of this - kenny (why? tim)                   
-            switch(content_type){
-                case 'application/rdf+xml': 
-                    documentString = sz.statementsToXML(newSts);
-                    break;
-                case 'text/n3':
-                case 'text/turtle':
-                case 'application/x-turtle': // Legacy
-                case 'application/n3': // Legacy
-                    documentString = sz.statementsToN3(newSts);
-                    break;
-                default:
-                    throw "Content-type "+content_type +" not supported for data write";                                                                            
-            }
-            
-            // Write the new version back
-            
-            var candidateTarget = kb.the(response, this.ns.httph("content-location"));
-            if (candidateTarget) targetURI = Util.uri.join(candidateTarget.value, targetURI);
-            var xhr = Util.XMLHTTPFactory();
-            xhr.onreadystatechange = function (){
-                if (xhr.readyState == 4){
-                    //formula from sparqlUpdate.js, what about redirects?
-                    var success = (!xhr.status || (xhr.status >= 200 && xhr.status < 300));
-                    if (success) {
-                        for (var i=0; i<ds.length;i++) kb.remove(ds[i]);
-                        for (var i=0; i<is.length;i++)
-                            kb.add(is[i].subject, is[i].predicate, is[i].object, doc);                
-                    }
-                    callback(doc.uri, success, xhr.responseText);
-                }
-            };
-            xhr.open('PUT', targetURI, true);
-            //assume the server does PUT content-negotiation.
-            xhr.setRequestHeader('Content-type', content_type);//OK?
-            xhr.send(documentString);
-
-        } else if (protocol.indexOf('LOCALFILE') >=0) {
-            try {
-                tabulator.log.info("Writing back to local file\n");
-                // See http://simon-jung.blogspot.com/2007/10/firefox-extension-file-io.html
-                //prepare contents of revised document
-                var newSts = kb.statementsMatching(undefined, undefined, undefined, doc).slice(); // copy!
-                for (var i=0;i<ds.length;i++) $rdf.Util.RDFArrayRemove(newSts, ds[i]);
-                for (var i=0;i<is.length;i++) newSts.push(is[i]);                                     
-                
-                //serialize to the appropriate format
-                var documentString;
-                var sz = $rdf.Serializer(kb);
-                sz.suggestNamespaces(kb.namespaces);
-                sz.setBase(doc.uri);//?? beware of this - kenny (why? tim)
-                var dot = doc.uri.lastIndexOf('.');
-                if (dot < 1) throw "Rewriting file: No filename extension: "+doc.uri;
-                var ext = doc.uri.slice(dot+1);                  
-                switch(ext){
-                    case 'rdf': 
-                    case 'owl':  // Just my experence   ...@@ we should keep the format in which it was parsed
-                    case 'xml': 
-                        documentString = sz.statementsToXML(newSts);
-                        break;
-                    case 'n3':
-                    case 'nt':
-                    case 'ttl':
-                        documentString = sz.statementsToN3(newSts);
-                        break;
-                    default:
-                        throw "File extension ."+ext +" not supported for data write";                                                                            
-                }
-                
-                // Write the new version back
-                
-                //create component for file writing
-                dump("Writing back: <<<"+documentString+">>>\n")
-                var filename = doc.uri.slice(7); // chop off   file://  leaving /path
-                //tabulator.log.warn("Writeback: Filename: "+filename+"\n")
-                var file = Components.classes["@mozilla.org/file/local;1"]
-                    .createInstance(Components.interfaces.nsILocalFile);
-                file.initWithPath(filename);
-                if(!file.exists()) throw "Rewriting file <"+doc.uri+"> but it does not exist!";
-                    
-                //{
-                //file.create( Components.interfaces.nsIFile.NORMAL_FILE_TYPE, 420);
-                //}
-                    //create file output stream and use write/create/truncate mode
-                //0x02 writing, 0x08 create file, 0x20 truncate length if exist
-                var stream = Components.classes["@mozilla.org/network/file-output-stream;1"]
-                .createInstance(Components.interfaces.nsIFileOutputStream);
-
-                stream.init(file, 0x02 | 0x08 | 0x20, 0666, 0);
-
-                //write data to file then close output stream
-                stream.write(documentString, documentString.length);
-                stream.close();
-
-                for (var i=0; i<ds.length;i++) kb.remove(ds[i]);
-                for (var i=0; i<is.length;i++)
-                    kb.add(is[i].subject, is[i].predicate, is[i].object, doc); 
-                                
-                callback(doc.uri, true, ""); // success!
-            } catch(e) {
-                callback(doc.uri, false, 
-                "Exception trying to write back file <"+doc.uri+">\n"+
-                        tabulator.Util.stackString(e))
-            }
-            
-        } else throw "Unhandled edit method: '"+protocol+"' for "+doc;
-    };
-
-
-
-    return sparql;
-
-}();
+// Joe Presbrey <presbrey@mit.edu>
+// 2007-07-15
+// 2010-08-08 TimBL folded in Kenny's WEBDAV 
+// 2010-12-07 TimBL addred local file write code
+
+$rdf.sparqlUpdate = function() {
+
+    var anonymize = function (obj) {
+        return (obj.toNT().substr(0,2) == "_:")
+        ? "?" + obj.toNT().substr(2)
+        : obj.toNT();
+    }
+
+    var anonymizeNT = function(stmt) {
+        return anonymize(stmt.subject) + " " +
+        anonymize(stmt.predicate) + " " +
+        anonymize(stmt.object) + " .";
+    }
+
+    var sparql = function(store) {
+        this.store = store;
+        this.ifps = {};
+        this.fps = {};
+        this.ns = {};
+        this.ns.link = $rdf.Namespace("http://www.w3.org/2007/ont/link#");
+        this.ns.http = $rdf.Namespace("http://www.w3.org/2007/ont/http#");
+        this.ns.httph = $rdf.Namespace("http://www.w3.org/2007/ont/httph#");
+        this.ns.rdf =  $rdf.Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
+        this.ns.rdfs = $rdf.Namespace("http://www.w3.org/2000/01/rdf-schema#");
+        this.ns.rdf = $rdf.Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
+        this.ns.owl = $rdf.Namespace("http://www.w3.org/2002/07/owl#");
+    }
+
+
+    // Returns The method string SPARQL or DAV or LOCALFILE or false if known, undefined if not known.
+    //
+    // Files have to have a specific annotaton that they are machine written, for safety.
+    // We don't actually check for write access on files.
+    //
+    sparql.prototype.editable = function(uri, kb) {
+        if (!uri) return false; // Eg subject is bnode, no known doc to write to
+        if (!kb) kb = tabulator.kb;
+
+        if (uri.slice(0,8) == 'file:///') {
+            if (kb.holds(kb.sym(uri), tabulator.ns.rdf('type'), tabulator.ns.link('MachineEditableDocument')))
+                return 'LOCALFILE';
+            var sts = kb.statementsMatching(kb.sym(uri),undefined,undefined);
+            
+            tabulator.log.warn("sparql.editable: Not MachineEditableDocument file "+uri+"\n");
+            tabulator.log.warn(sts.map(function(x){return x.toNT();}).join('\n'))
+            return false;
+        //@@ Would be nifty of course to see whether we actually have write acess first.
+        }
+
+        var request;
+        var definitive = false;
+        var requests = kb.each(undefined, this.ns.link("requestedURI"), $rdf.uri.docpart(uri));
+        for (var r=0; r<requests.length; r++) {
+            request = requests[r];
+            if (request !== undefined) {
+                var response = kb.any(request, this.ns.link("response"));
+                if (request !== undefined) {
+                    var author_via = kb.each(response, this.ns.httph("ms-author-via"));
+                    if (author_via.length) {
+                        for (var i = 0; i < author_via.length; i++) {
+                            var method = author_via[i].value.trim();
+                            if (method.indexOf('SPARQL') >=0 ) return 'SPARQL';
+                            if (method.indexOf('DAV') >=0 ) return 'DAV';
+//                            if (author_via[i].value == "SPARQL" || author_via[i].value == "DAV")
+                                // dump("sparql.editable: Success for "+uri+": "+author_via[i] +"\n");
+                                //return author_via[i].value;
+                                
+                        }
+                    }
+                    var status = kb.each(response, this.ns.http("status"));
+                    if (status.length) {
+                        for (var i = 0; i < status.length; i++) {
+                            if (status[i] == 200 || status[i] == 404) {
+                                definitive = true;
+                                // return false; // A definitive answer
+                            }
+                        }
+                    }
+                } else {
+                    tabulator.log.warn("sparql.editable: No response for "+uri+"\n");
+                }
+            }
+        }
+        if (requests.length == 0) {
+            tabulator.log.warn("sparql.editable: No request for "+uri+"\n");
+        } else {
+            if (definitive) return false;  // We have got a request and it did NOT say editable => not editable
+        };
+
+        tabulator.log.warn("sparql.editable: inconclusive for "+uri+"\n");
+        return undefined; // We don't know (yet) as we haven't had a response (yet)
+    }
+
+    ///////////  The identification of bnodes
+
+    sparql.prototype._statement_bnodes = function(st) {
+        return [st.subject, st.predicate, st.object].filter(function(x){return x.isBlank});
+    }
+
+    sparql.prototype._statement_array_bnodes = function(sts) {
+        var bnodes = [];
+        for (var i=0; i<sts.length;i++) bnodes = bnodes.concat(this._statement_bnodes(sts[i]));
+        bnodes.sort(); // in place sort - result may have duplicates
+        bnodes2 = [];
+        for (var j=0; j<bnodes.length; j++)
+            if (j==0 || !bnodes[j].sameTermAs(bnodes[j-1])) bnodes2.push(bnodes[j]);
+        return bnodes2;
+    }
+
+    sparql.prototype._cache_ifps = function() {
+        // Make a cached list of [Inverse-]Functional properties
+        // Call this once before calling context_statements
+        this.ifps = {};
+        var a = this.store.each(undefined, this.ns.rdf('type'), this.ns.owl('InverseFunctionalProperty'))
+        for (var i=0; i<a.length; i++) {
+            this.ifps[a[i].uri] = true;
+        }
+        this.fps = {};
+        var a = this.store.each(undefined, this.ns.rdf('type'), this.ns.owl('FunctionalProperty'))
+        for (var i=0; i<a.length; i++) {
+            this.fps[a[i].uri] = true;
+        }
+    }
+
+    sparql.prototype._bnode_context2 = function(x, source, depth) {
+        // Return a list of statements which indirectly identify a node
+        //  Depth > 1 if try further indirection.
+        //  Return array of statements (possibly empty), or null if failure
+        var sts = this.store.statementsMatching(undefined, undefined, x, source); // incoming links
+        for (var i=0; i<sts.length; i++) {
+            if (this.fps[sts[i].predicate.uri]) {
+                var y = sts[i].subject;
+                if (!y.isBlank)
+                    return [ sts[i] ];
+                if (depth) {
+                    var res = this._bnode_context2(y, source, depth-1);
+                    if (res != null)
+                        return res.concat([ sts[i] ]);
+                }
+            }        
+        }
+        var sts = this.store.statementsMatching(x, undefined, undefined, source); // outgoing links
+        for (var i=0; i<sts.length; i++) {
+            if (this.ifps[sts[i].predicate.uri]) {
+                var y = sts[i].object;
+                if (!y.isBlank)
+                    return [ sts[i] ];
+                if (depth) {
+                    var res = this._bnode_context2(y, source, depth-1);
+                    if (res != undefined)
+                        return res.concat([ sts[i] ]);
+                }
+            }        
+        }
+        return null; // Failure
+    }
+
+
+    sparql.prototype._bnode_context = function(x, source) {
+        // Return a list of statements which indirectly identify a node
+        //   Breadth-first
+        for (var depth = 0; depth < 3; depth++) { // Try simple first 
+            var con = this._bnode_context2(x, source, depth);
+            if (con != null) return con;
+        }
+        throw ('Unable to uniquely identify bnode: '+ x.toNT());
+    }
+
+    sparql.prototype._bnode_context = function(bnodes) {
+        var context = [];
+        if (bnodes.length) {
+            if (this.store.statementsMatching(st.subject.isBlank?undefined:st.subject,
+                                      st.predicate.isBlank?undefined:st.predicate,
+                                      st.object.isBlank?undefined:st.object,
+                                      st.why).length <= 1) {
+                context = context.concat(st);
+            } else {
+                this._cache_ifps();
+                for (x in bnodes) {
+                    context = context.concat(this._bnode_context(bnodes[x], st.why));
+                }
+            }
+        }
+        return context;
+    }
+
+    sparql.prototype._statement_context = function(st) {
+        var bnodes = this._statement_bnodes(st);
+        return this._bnode_context(bnodes);
+    }
+
+    sparql.prototype._context_where = function(context) {
+            return (context == undefined || context.length == 0)
+            ? ""
+            : "WHERE { " + context.map(anonymizeNT).join("\n") + " }\n";
+    }
+
+    sparql.prototype._fire = function(uri, query, callback) {
+        if (!uri) throw "No URI given for remote editing operation: "+query;
+        tabulator.log.info("sparql: sending update to <"+uri+">\n   query="+query+"\n");
+        var xhr = $rdf.Util.XMLHTTPFactory();
+
+        xhr.onreadystatechange = function() {
+            //dump("SPARQL update ready state for <"+uri+"> readyState="+xhr.readyState+"\n"+query+"\n");
+            if (xhr.readyState == 4) {
+                var success = (!xhr.status || (xhr.status >= 200 && xhr.status < 300));
+                if (!success) tabulator.log.error("sparql: update failed for <"+uri+"> status="+
+                    xhr.status+", "+xhr.statusText+", body length="+xhr.responseText.length+"\n   for query: "+query);
+                else  tabulator.log.debug("sparql: update Ok for <"+uri+">");
+                callback(uri, success, xhr.responseText);
+            }
+        }
+
+        if(!tabulator.isExtension) {
+            try {
+                $rdf.Util.enablePrivilege("UniversalBrowserRead")
+            } catch(e) {
+                alert("Failed to get privileges: " + e)
+            }
+        }
+        
+        xhr.open('POST', uri, true);  // async=true
+        xhr.setRequestHeader('Content-type', 'application/sparql-update');
+        xhr.send(query);
+    }
+
+    // This does NOT update the statement.
+    // It returns an object whcih includes
+    //  function which can be used to change the object of the statement.
+    //
+    sparql.prototype.update_statement = function(statement) {
+        if (statement && statement.why == undefined) return;
+
+        var sparql = this;
+        var context = this._statement_context(statement);
+
+        return {
+            statement: statement?[statement.subject, statement.predicate, statement.object, statement.why]:undefined,
+            statementNT: statement?anonymizeNT(statement):undefined,
+            where: sparql._context_where(context),
+
+            set_object: function(obj, callback) {
+                query = this.where;
+                query += "DELETE DATA { " + this.statementNT + " } ;\n";
+                query += "INSERT DATA { " +
+                    anonymize(this.statement[0]) + " " +
+                    anonymize(this.statement[1]) + " " +
+                    anonymize(obj) + " " + " . }\n";
+     
+                sparql._fire(this.statement[3].uri, query, callback);
+            }
+        }
+    }
+
+    sparql.prototype.insert_statement = function(st, callback) {
+        var st0 = st instanceof Array ? st[0] : st;
+        var query = this._context_where(this._statement_context(st0));
+        
+        if (st instanceof Array) {
+            var stText="";
+            for (var i=0;i<st.length;i++) stText+=st[i]+'\n';
+            query += "INSERT DATA { " + stText + " }\n";
+        } else {
+            query += "INSERT DATA { " +
+                anonymize(st.subject) + " " +
+                anonymize(st.predicate) + " " +
+                anonymize(st.object) + " " + " . }\n";
+        }
+        
+        this._fire(st0.why.uri, query, callback);
+    }
+
+    sparql.prototype.delete_statement = function(st, callback) {
+
+        var st0 = st instanceof Array ? st[0] : st;
+        var query = this._context_where(this._statement_context(st0));
+        
+        if (st instanceof Array) {
+            var stText="";
+            for (var i=0;i<st.length;i++) stText+=st[i]+'\n';
+            query += "DELETE DATA { " + stText + " }\n";
+        } else {
+            query += "DELETE DATA { " +
+                anonymize(st.subject) + " " +
+                anonymize(st.predicate) + " " +
+                anonymize(st.object) + " " + " . }\n";
+        }
+        
+        this._fire(st0.why.uri, query, callback);
+    }
+
+    // This high-level function updates the local store iff the web is changed successfully. 
+    //
+    //  - deletions, insertions may be undefined or single statements or lists or formulae.
+    //
+    //  - callback is called as callback(uri, success, errorbody)
+    //
+    sparql.prototype.update = function(deletions, insertions, callback) {
+        var kb = this.store;
+        tabulator.log.info("update called")
+        var ds =  deletions == undefined ? []
+                    : deletions instanceof $rdf.IndexedFormula ? deletions.statements
+                    : deletions instanceof Array ? deletions : [ deletions ];
+        var is =  insertions == undefined? []
+                    : insertions instanceof $rdf.IndexedFormula ? insertions.statements
+                    : insertions instanceof Array ? insertions : [ insertions ];
+        if (! (ds instanceof Array)) throw "Type Error "+(typeof ds)+": "+ds;
+        if (! (is instanceof Array)) throw "Type Error "+(typeof is)+": "+is;
+        var doc = ds.length ? ds[0].why : is[0].why;
+        
+        ds.map(function(st){if (!doc.sameTerm(st.why)) throw "sparql update: destination "+doc+" inconsistent with ds "+st.why;});
+        is.map(function(st){if (!doc.sameTerm(st.why)) throw "sparql update: destination = "+doc+" inconsistent with st.why ="+st.why;});
+
+        var protocol = this.editable(doc.uri, kb);
+        if (!protocol) throw "Can't make changes in uneditable "+doc;
+
+        if (protocol.indexOf('SPARQL') >=0) {
+            var bnodes = []
+            if (ds.length) bnodes = this._statement_array_bnodes(ds);
+            if (is.length) bnodes = bnodes.concat(this._statement_array_bnodes(is));
+            var context = this._bnode_context(bnodes);
+            var whereClause = this._context_where(context);
+            var query = ""
+            if (whereClause.length) { // Is there a WHERE clause?
+                if (ds.length) {
+                    query += "DELETE { ";
+                    for (var i=0; i<ds.length;i++) query+= anonymizeNT(ds[i])+"\n";
+                    query += " }\n";
+                }
+                if (is.length) {
+                    query += "INSERT { ";
+                    for (var i=0; i<is.length;i++) query+= anonymizeNT(is[i])+"\n";
+                    query += " }\n";
+                }
+                query += whereClause;
+            } else { // no where clause
+                if (ds.length) {
+                    query += "DELETE DATA { ";
+                    for (var i=0; i<ds.length;i++) query+= anonymizeNT(ds[i])+"\n";
+                    query += " } \n";
+                }
+                if (is.length) {
+                    if (ds.length) query += " ; ";
+                    query += "INSERT DATA { ";
+                    for (var i=0; i<is.length;i++) query+= anonymizeNT(is[i])+"\n";
+                    query += " }\n";
+                }
+            }
+            this._fire(doc.uri, query,
+                function(uri, success, body) {
+                    tabulator.log.info("\t sparql: Return success="+success+" for query "+query+"\n");
+                    if (success) {
+                        for (var i=0; i<ds.length;i++)
+                            try { kb.remove(ds[i]) } catch(e) {
+                                callback(uri, false,
+                                "sparqlUpdate: Remote OK but error deleting statemmnt "+
+                                    ds[i] + " from local store:\n" + e)
+                            }
+                        for (var i=0; i<is.length;i++)
+                            kb.add(is[i].subject, is[i].predicate, is[i].object, doc); 
+                    }
+                    callback(uri, success, body);
+                });
+            
+        } else if (protocol.indexOf('DAV') >=0) {
+
+            // The code below is derived from Kenny's UpdateCenter.js
+            var documentString;
+            var request = kb.any(doc, this.ns.link("request"));
+            if (!request) throw "No record of our HTTP GET request for document: "+doc; //should not happen
+            var response =  kb.any(request, this.ns.link("response"));
+            if (!response)  return null; // throw "No record HTTP GET response for document: "+doc;
+            var content_type = kb.the(response, this.ns.httph("content-type")).value;            
+
+            //prepare contents of revised document
+            var newSts = kb.statementsMatching(undefined, undefined, undefined, doc).slice(); // copy!
+            for (var i=0;i<ds.length;i++) $rdf.Util.RDFArrayRemove(newSts, ds[i]);
+            for (var i=0;i<is.length;i++) newSts.push(is[i]);                                     
+            
+            //serialize to te appropriate format
+            var sz = $rdf.Serializer(kb);
+            sz.suggestNamespaces(kb.namespaces);
+            sz.setBase(doc.uri);//?? beware of this - kenny (why? tim)                   
+            switch(content_type){
+                case 'application/rdf+xml': 
+                    documentString = sz.statementsToXML(newSts);
+                    break;
+                case 'text/n3':
+                case 'text/turtle':
+                case 'application/x-turtle': // Legacy
+                case 'application/n3': // Legacy
+                    documentString = sz.statementsToN3(newSts);
+                    break;
+                default:
+                    throw "Content-type "+content_type +" not supported for data write";                                                                            
+            }
+            
+            // Write the new version back
+            
+            var candidateTarget = kb.the(response, this.ns.httph("content-location"));
+            if (candidateTarget) targetURI = $rdf.uri.join(candidateTarget.value, targetURI);
+            var xhr = $rdf.Util.XMLHTTPFactory();
+            xhr.onreadystatechange = function (){
+                if (xhr.readyState == 4){
+                    //formula from sparqlUpdate.js, what about redirects?
+                    var success = (!xhr.status || (xhr.status >= 200 && xhr.status < 300));
+                    if (success) {
+                        for (var i=0; i<ds.length;i++) kb.remove(ds[i]);
+                        for (var i=0; i<is.length;i++)
+                            kb.add(is[i].subject, is[i].predicate, is[i].object, doc);                
+                    }
+                    callback(doc.uri, success, xhr.responseText);
+                }
+            };
+            xhr.open('PUT', targetURI, true);
+            //assume the server does PUT content-negotiation.
+            xhr.setRequestHeader('Content-type', content_type);//OK?
+            xhr.send(documentString);
+
+        } else if (protocol.indexOf('LOCALFILE') >=0) {
+            try {
+                tabulator.log.info("Writing back to local file\n");
+                // See http://simon-jung.blogspot.com/2007/10/firefox-extension-file-io.html
+                //prepare contents of revised document
+                var newSts = kb.statementsMatching(undefined, undefined, undefined, doc).slice(); // copy!
+                for (var i=0;i<ds.length;i++) $rdf.Util.RDFArrayRemove(newSts, ds[i]);
+                for (var i=0;i<is.length;i++) newSts.push(is[i]);                                     
+                
+                //serialize to the appropriate format
+                var documentString;
+                var sz = $rdf.Serializer(kb);
+                sz.suggestNamespaces(kb.namespaces);
+                sz.setBase(doc.uri);//?? beware of this - kenny (why? tim)
+                var dot = doc.uri.lastIndexOf('.');
+                if (dot < 1) throw "Rewriting file: No filename extension: "+doc.uri;
+                var ext = doc.uri.slice(dot+1);                  
+                switch(ext){
+                    case 'rdf': 
+                    case 'owl':  // Just my experence   ...@@ we should keep the format in which it was parsed
+                    case 'xml': 
+                        documentString = sz.statementsToXML(newSts);
+                        break;
+                    case 'n3':
+                    case 'nt':
+                    case 'ttl':
+                        documentString = sz.statementsToN3(newSts);
+                        break;
+                    default:
+                        throw "File extension ."+ext +" not supported for data write";                                                                            
+                }
+                
+                // Write the new version back
+                
+                //create component for file writing
+                dump("Writing back: <<<"+documentString+">>>\n")
+                var filename = doc.uri.slice(7); // chop off   file://  leaving /path
+                //tabulator.log.warn("Writeback: Filename: "+filename+"\n")
+                var file = Components.classes["@mozilla.org/file/local;1"]
+                    .createInstance(Components.interfaces.nsILocalFile);
+                file.initWithPath(filename);
+                if(!file.exists()) throw "Rewriting file <"+doc.uri+"> but it does not exist!";
+                    
+                //{
+                //file.create( Components.interfaces.nsIFile.NORMAL_FILE_TYPE, 420);
+                //}
+                    //create file output stream and use write/create/truncate mode
+                //0x02 writing, 0x08 create file, 0x20 truncate length if exist
+                var stream = Components.classes["@mozilla.org/network/file-output-stream;1"]
+                .createInstance(Components.interfaces.nsIFileOutputStream);
+
+                stream.init(file, 0x02 | 0x08 | 0x20, 0666, 0);
+
+                //write data to file then close output stream
+                stream.write(documentString, documentString.length);
+                stream.close();
+
+                for (var i=0; i<ds.length;i++) kb.remove(ds[i]);
+                for (var i=0; i<is.length;i++)
+                    kb.add(is[i].subject, is[i].predicate, is[i].object, doc); 
+                                
+                callback(doc.uri, true, ""); // success!
+            } catch(e) {
+                callback(doc.uri, false, 
+                "Exception trying to write back file <"+doc.uri+">\n"+
+                        tabulator.Util.stackString(e))
+            }
+            
+        } else throw "Unhandled edit method: '"+protocol+"' for "+doc;
+    };
+
+    // This suitable for an inital creation of a document
+    //
+    sparql.prototype.put = function(doc, newSts, content_type, callback) {
+
+        var documentString;
+        var kb = this.store;
+       
+        //serialize to te appropriate format
+        var sz = $rdf.Serializer(kb);
+        sz.suggestNamespaces(kb.namespaces);
+        sz.setBase(doc.uri);//?? beware of this - kenny (why? tim)                   
+        switch(content_type){
+            case 'application/rdf+xml': 
+                documentString = sz.statementsToXML(newSts);
+                break;
+            case 'text/n3':
+            case 'text/turtle':
+            case 'application/x-turtle': // Legacy
+            case 'application/n3': // Legacy
+                documentString = sz.statementsToN3(newSts);
+                break;
+            default:
+                throw "Content-type "+content_type +" not supported for data PUT";                                                                            
+        }
+        
+        var xhr = $rdf.Util.XMLHTTPFactory();
+        xhr.onreadystatechange = function (){
+            if (xhr.readyState == 4){
+                //formula from sparqlUpdate.js, what about redirects?
+                var success = (!xhr.status || (xhr.status >= 200 && xhr.status < 300));
+                callback(doc.uri, success, xhr.responseText);
+            }
+        };
+        xhr.open('PUT', doc.uri, true);
+        //assume the server does PUT content-negotiation.
+        xhr.setRequestHeader('Content-type', content_type);//OK?
+        xhr.send(documentString);
+    
+    };
+    
+    
+
+    return sparql;
+
+}();
 $rdf.jsonParser = function() {
 
     return {
@@ -5858,950 +5789,952 @@ $rdf.jsonParser = function() {
         }
     }
 }();
-/*      Serialization of RDF Graphs
-**
-** Tim Berners-Lee 2006
-** This is or was http://dig.csail.mit.edu/2005/ajar/ajaw/js/rdf/serialize.js
-**
-** Bug: can't serialize  http://data.semanticweb.org/person/abraham-bernstein/rdf 
-** in XML (from mhausenblas)
-*/
-
-// @@@ Check the whole toStr thing tosee whetehr it still makes sense -- tbl
-// 
-$rdf.Serializer = function() {
-
-var __Serializer = function( store ){
-    this.flags = "";
-    this.base = null;
-    this.prefixes = [];
-    this.keywords = ['a']; // The only one we generate at the moment
-    this.prefixchars = "abcdefghijklmnopqustuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-    this.incoming = null;  // Array not calculated yet
-    this.formulas = [];  // remebering original formulae from hashes 
-    this.store = store;
-
-    /* pass */
-}
-
-__Serializer.prototype.setBase = function(base)
-    { this.base = base };
-
-__Serializer.prototype.setFlags = function(flags)
-    { this.flags = flags?flags: '' };
-
-
-__Serializer.prototype.toStr = function(x) {
-        var s = x.toNT();
-        if (x.termType == 'formula') {
-            this.formulas[s] = x; // remember as reverse does not work
-        }
-        return s;
-};
-    
-__Serializer.prototype.fromStr = function(s) {
-        if (s[0] == '{') {
-            var x = this.formulas[s];
-            if (!x) alert('No formula object for '+s)
-            return x;
-        }
-        return this.store.fromNT(s);
-};
-    
-
-
-
-
-/* Accumulate Namespaces
-** 
-** These are only hints.  If two overlap, only one gets used
-** There is therefore no guarantee in general.
-*/
-
-__Serializer.prototype.suggestPrefix = function(prefix, uri) {
-    this.prefixes[uri] = prefix;
-}
-
-// Takes a namespace -> prefix map
-__Serializer.prototype.suggestNamespaces = function(namespaces) {
-    for (var px in namespaces) {
-        this.prefixes[namespaces[px]] = px;
-    }
-}
-
-// Make up an unused prefix for a random namespace
-__Serializer.prototype.makeUpPrefix = function(uri) {
-    var p = uri;
-    var namespaces = [];
-    var pok;
-    
-    function canUse(pp) {
-        if (namespaces[pp]) return false; // already used
-        this.prefixes[uri] = pp;
-        pok = pp;
-        return true
-    }
-    canUse = canUse.bind(this);
-    for (var ns in this.prefixes) {
-        namespaces[this.prefixes[ns]] = ns; // reverse index
-    }
-    if ('#/'.indexOf(p[p.length-1]) >= 0) p = p.slice(0, -1);
-    var slash = p.lastIndexOf('/');
-    if (slash >= 0) p = p.slice(slash+1);
-    var i = 0;
-    while (i < p.length)
-        if (this.prefixchars.indexOf(p[i])) i++; else break;
-    p = p.slice(0,i);
-    if (p.length < 6 && canUse(p)) return pok; // exact i sbest
-    if (canUse(p.slice(0,3))) return pok;
-    if (canUse(p.slice(0,2))) return pok;
-    if (canUse(p.slice(0,4))) return pok;
-    if (canUse(p.slice(0,1))) return pok;
-    if (canUse(p.slice(0,5))) return pok;
-    for (var i=0;; i++) if (canUse(p.slice(0,3)+i)) return pok; 
-}
-
-
-
-// Todo:
-//  - Sort the statements by subject, pred, object
-//  - do stuff about the docu first and then (or first) about its primary topic.
-
-__Serializer.prototype.rootSubjects = function(sts) {
-    var incoming = {};
-    var subjects = {};
-    var allBnodes = {};
-
-/* This scan is to find out which nodes will have to be the roots of trees
-** in the serialized form. This will be any symbols, and any bnodes
-** which hve more or less than one incoming arc, and any bnodes which have
-** one incoming arc but it is an uninterrupted loop of such nodes back to itself.
-** This should be kept linear time with repect to the number of statements.
-** Note it does not use any indexing of the store.
-*/
-
-
-    // $rdf.log.debug('serialize.js Find bnodes with only one incoming arc\n')
-    for (var i = 0; i<sts.length; i++) {
-        var st = sts[i];
-        [ st.subject, st.predicate, st.object].map(function(y){
-            if (y.termType =='bnode'){allBnodes[y.toNT()] = true}});
-        var x = sts[i].object;
-        if (!incoming.hasOwnProperty(x)) incoming[x] = [];
-        incoming[x].push(st.subject) // List of things which will cause this to be printed
-        var ss =  subjects[this.toStr(st.subject)]; // Statements with this as subject
-        if (!ss) ss = [];
-        ss.push(st);
-        subjects[this.toStr(st.subject)] = ss; // Make hash. @@ too slow for formula?
-        // $rdf.log.debug(' sz potential subject: '+sts[i].subject)
-    }
-
-    var roots = [];
-    for (var xNT in subjects) {
-        if (!subjects.hasOwnProperty(xNT)) continue;
-        var x = this.fromStr(xNT);
-        if ((x.termType != 'bnode') || !incoming[x] || (incoming[x].length != 1)){
-            roots.push(x);
-            //$rdf.log.debug(' sz actual subject -: ' + x)
-            continue;
-        }
-    }
-    this.incoming = incoming; // Keep for serializing @@ Bug for nested formulas
-    
-//////////// New bit for CONNECTED bnode loops:frootshash
-
-// This scans to see whether the serialization is gpoing to lead to a bnode loop
-// and at the same time accumulates a list of all bnodes mentioned.
-// This is in fact a cut down N3 serialization
-/*
-    // $rdf.log.debug('serialize.js Looking for connected bnode loops\n')
-    for (var i=0; i<sts.length; i++) { // @@TBL
-        // dump('\t'+sts[i]+'\n');
-    }
-    var doneBnodesNT = {};
-    function dummyPropertyTree(subject, subjects, rootsHash) {
-        // dump('dummyPropertyTree('+subject+'...)\n');
-        var sts = subjects[sz.toStr(subject)]; // relevant statements
-        for (var i=0; i<sts.length; i++) {
-            dummyObjectTree(sts[i].object, subjects, rootsHash);
-        }
-    }
-
-    // Convert a set of statements into a nested tree of lists and strings
-    // @param force,    "we know this is a root, do it anyway. It isn't a loop."
-    function dummyObjectTree(obj, subjects, rootsHash, force) { 
-        // dump('dummyObjectTree('+obj+'...)\n');
-        if (obj.termType == 'bnode' && (subjects[sz.toStr(obj)]  &&
-            (force || (rootsHash[obj.toNT()] == undefined )))) {// and there are statements
-            if (doneBnodesNT[obj.toNT()]) { // Ah-ha! a loop
-                throw "Serializer: Should be no loops "+obj;
-            }
-            doneBnodesNT[obj.toNT()] = true;
-            return  dummyPropertyTree(obj, subjects, rootsHash);
-        }
-        return dummyTermToN3(obj, subjects, rootsHash);
-    }
-    
-    // Scan for bnodes nested inside lists too
-    function dummyTermToN3(expr, subjects, rootsHash) {
-        if (expr.termType == 'bnode') doneBnodesNT[expr.toNT()] = true;
-        // $rdf.log.debug('serialize: seen '+expr);
-        if (expr.termType == 'collection') {
-            for (i=0; i<expr.elements.length; i++) {
-                if (expr.elements[i].termType == 'bnode')
-                    dummyObjectTree(expr.elements[i], subjects, rootsHash);
-            }
-        return;             
-        }
-    }
-
-    // The tree for a subject
-    function dummySubjectTree(subject, subjects, rootsHash) {
-        // dump('dummySubjectTree('+subject+'...)\n');
-        if (subject.termType == 'bnode' && !incoming[subject])
-            return dummyObjectTree(subject, subjects, rootsHash, true); // Anonymous bnode subject
-        dummyTermToN3(subject, subjects, rootsHash);
-        dummyPropertyTree(subject, subjects, rootsHash);
-    }
-*/    
-    // Now do the scan using existing roots
-    // $rdf.log.debug('serialize.js Dummy serialize to check for missing nodes')
-    var rootsHash = {};
-    for (var i = 0; i< roots.length; i++) rootsHash[roots[i].toNT()] = true;
-/*
-    for (var i=0; i<roots.length; i++) {
-        var root = roots[i];
-        dummySubjectTree(root, subjects, rootsHash);
-    }
-    // dump('Looking for mising bnodes...\n')
-    
-// Now in new roots for anythig not acccounted for
-// Now we check for any bndoes which have not been covered.
-// Such bnodes must be in isolated rings of pure bnodes.
-// They each have incoming link of 1.
-
-    // $rdf.log.debug('serialize.js Looking for connected bnode loops\n')
-    for (;;) {
-        var bnt;
-        var found = null;
-        for (bnt in allBnodes) { // @@ Note: not repeatable. No canonicalisation
-            if (doneBnodesNT[bnt]) continue;
-            found = bnt; // Ah-ha! not covered
-            break;
-        }
-        if (found == null) break; // All done - no bnodes left out/
-        // dump('Found isolated bnode:'+found+'\n');
-        doneBnodesNT[bnt] = true;
-        var root = this.store.fromNT(found);
-        roots.push(root); // Add a new root
-        rootsHash[found] = true;
-        // $rdf.log.debug('isolated bnode:'+found+', subjects[found]:'+subjects[found]+'\n');
-        if (subjects[found] == undefined) {
-            for (var i=0; i<sts.length; i++) {
-                // dump('\t'+sts[i]+'\n');
-            }
-            throw "Isolated node should be a subject" +found;
-        }
-        dummySubjectTree(root, subjects, rootsHash); // trace out the ring
-    }
-    // dump('Done bnode adjustments.\n')
-*/
-    return {'roots':roots, 'subjects':subjects, 
-                'rootsHash': rootsHash, 'incoming': incoming};
-}
-
-////////////////////////////////////////////////////////
-
-__Serializer.prototype.toN3 = function(f) {
-    return this.statementsToN3(f.statements);
-}
-
-__Serializer.prototype._notQNameChars = "\t\r\n !\"#$%&'()*.,+/;<=>?@[\\]^`{|}~";
-__Serializer.prototype._notNameChars = 
-                    ( __Serializer.prototype._notQNameChars + ":" ) ;
-
-    
-__Serializer.prototype.statementsToN3 = function(sts) {
-    var indent = 4;
-    var width = 80;
-
-    var namespaceCounts = []; // which have been used
-
-    var predMap = {
-        'http://www.w3.org/2002/07/owl#sameAs': '=',
-        'http://www.w3.org/2000/10/swap/log#implies': '=>',
-        'http://www.w3.org/1999/02/22-rdf-syntax-ns#type': 'a'
-    }
-    
-
-    
-    
-    ////////////////////////// Arrange the bits of text 
-
-    var spaces=function(n) {
-        var s='';
-        for(var i=0; i<n; i++) s+=' ';
-        return s
-    }
-
-    var treeToLine = function(tree) {
-        var str = '';
-        for (var i=0; i<tree.length; i++) {
-            var branch = tree[i];
-            var s2 = (typeof branch == 'string') ? branch : treeToLine(branch);
-            if (i!=0 && s2 != ',' && s2 != ';' && s2 != '.') str += ' ';
-            str += s2;
-        }
-        return str;
-    }
-    
-    // Convert a nested tree of lists and strings to a string
-    var treeToString = function(tree, level) {
-        var str = '';
-        var lastLength = 100000;
-        if (!level) level = 0;
-        for (var i=0; i<tree.length; i++) {
-            var branch = tree[i];
-            if (typeof branch != 'string') {
-                var substr = treeToString(branch, level +1);
-                if (
-                    substr.length < 10*(width-indent*level)
-                    && substr.indexOf('"""') < 0) {// Don't mess up multiline strings
-                    var line = treeToLine(branch);
-                    if (line.length < (width-indent*level)) {
-                        branch = '   '+line; //   @@ Hack: treat as string below
-                        substr = ''
-                    }
-                }
-                if (substr) lastLength = 10000;
-                str += substr;
-            }
-            if (typeof branch == 'string') {
-                if (branch.length == '1' && str.slice(-1) == '\n') {
-                    if (",.;".indexOf(branch) >=0) {
-                        str = str.slice(0,-1) + branch + '\n'; //  slip punct'n on end
-                        lastLength += 1;
-                        continue;
-                    } else if ("])}".indexOf(branch) >=0) {
-                        str = str.slice(0,-1) + ' ' + branch + '\n';
-                        lastLength += 2;
-                        continue;
-                    }
-                }
-                if (lastLength < (indent*level+4)) { // continue
-                    str = str.slice(0,-1) + ' ' + branch + '\n';
-                    lastLength += branch.length + 1;
-                } else {
-                    var line = spaces(indent*level) +branch;
-                    str += line +'\n'; 
-                    lastLength = line.length;
-                }
- 
-            } else { // not string
-            }
-        }
-        return str;
-    };
-
-    ////////////////////////////////////////////// Structure for N3
-    
-    
-    // Convert a set of statements into a nested tree of lists and strings
-    function statementListToTree(statements) {
-        // print('Statement tree for '+statements.length);
-        var res = [];
-        var stats = this.rootSubjects(statements);
-        var roots = stats.roots;
-        var results = []
-        for (var i=0; i<roots.length; i++) {
-            var root = roots[i];
-            results.push(subjectTree(root, stats))
-        }
-        return results;
-    }
-    statementListToTree = statementListToTree.bind(this);
-    
-    // The tree for a subject
-    function subjectTree(subject, stats) {
-        if (subject.termType == 'bnode' && !stats.incoming[subject])
-            return objectTree(subject, stats, true).concat(["."]); // Anonymous bnode subject
-        return [ termToN3(subject, stats) ].concat([propertyTree(subject, stats)]).concat(["."]);
-    }
-    
-
-    // The property tree for a single subject or anonymous node
-    function propertyTree(subject, stats) {
-        // print('Proprty tree for '+subject);
-        var results = []
-        var lastPred = null;
-        var sts = stats.subjects[this.toStr(subject)]; // relevant statements
-        if (typeof sts == 'undefined') {
-            throw('Cant find statements for '+subject);
-        }
-        sts.sort();
-        var objects = [];
-        for (var i=0; i<sts.length; i++) {
-            var st = sts[i];
-            if (st.predicate.uri == lastPred) {
-                objects.push(',');
-            } else {
-                if (lastPred) {
-                    results=results.concat([objects]).concat([';']);
-                    objects = [];
-                }
-                results.push(predMap[st.predicate.uri] ?
-                            predMap[st.predicate.uri] : termToN3(st.predicate, stats));
-            }
-            lastPred = st.predicate.uri;
-            objects.push(objectTree(st.object, stats));
-        }
-        results=results.concat([objects]);
-        return results;
-    }
-    propertyTree = propertyTree.bind(this);
-
-    function objectTree(obj, stats, force) {
-        if (obj.termType == 'bnode' &&
-                stats.subjects[this.toStr(obj)] && // and there are statements
-                (force || stats.rootsHash[obj.toNT()] == undefined)) // and not a root
-            return  ['['].concat(propertyTree(obj, stats)).concat([']']);
-        return termToN3(obj, stats);
-    }
-    objectTree = objectTree.bind(this);
-    
-    function termToN3(expr, stats) {
-        switch(expr.termType) {
-        
-            case 'formula':
-                var res = ['{'];
-                res = res.concat(statementListToTree(expr.statements));
-                return  res.concat(['}']);
-
-            case 'collection':
-                var res = ['('];
-                for (i=0; i<expr.elements.length; i++) {
-                    res.push(   [ objectTree(expr.elements[i], stats) ]);
-                }
-                res.push(')');
-                return res;
-                
-           default:
-                return this.atomicTermToN3(expr);
-        }
-    }
-    __Serializer.prototype.termToN3 = termToN3;
-    termToN3 = termToN3.bind(this);
-
-    function prefixDirectives() {
-        var str = '';
-        if (this.defaultNamespace)
-          str += '@prefix : <'+this.defaultNamespace+'>.\n';
-        for (var ns in namespaceCounts) {
-            if (!namespaceCounts.hasOwnProperty(ns)) continue;
-            str += '@prefix ' + this.prefixes[ns] + ': <'+ns+'>.\n';
-        }
-        return str + '\n';
-    }
-    prefixDirectives = prefixDirectives.bind(this);
-
-    // Body of statementsToN3:
-    
-    var tree = statementListToTree(sts);
-    return prefixDirectives() + treeToString(tree, -1);
-    
-}
-
-
-////////////////////////////////////////////// Atomic Terms
-
-//  Deal with term level things and nesting with no bnode structure
-
-
-__Serializer.prototype.atomicTermToN3 = function atomicTermToN3(expr, stats) {
-    switch(expr.termType) {
-        case 'bnode':
-        case 'variable':  return expr.toNT();
-        case 'literal':
-            if (expr.datatype) {
-                switch (expr.datatype.uri) {
-                case 'http://www.w3.org/2001/XMLSchema#integer':
-                    return expr.value.toString();
-                    
-                //case 'http://www.w3.org/2001/XMLSchema#double': // Must force use of 'e'
-                
-                case 'http://www.w3.org/2001/XMLSchema#boolean':
-                    return expr.value? 'true' : 'false';
-                }
-            }
-            var str = this.stringToN3(expr.value);
-            if (expr.lang) str+= '@' + expr.lang;
-            if (expr.datatype) str+= '^^' + this.termToN3(expr.datatype, stats);
-            return str;
-        case 'symbol':
-            return this.symbolToN3(expr);
-       default:
-            throw "Internal: atomicTermToN3 cannot handle "+expr+" of termType+"+expr.termType
-            return ''+expr;
-    }
-};
-
-    //  stringToN3:  String escaping for N3
-
-__Serializer.prototype.forbidden1 = new RegExp(/[\\"\b\f\r\v\t\n\u0080-\uffff]/gm);
-__Serializer.prototype.forbidden3 = new RegExp(/[\\"\b\f\r\v\u0080-\uffff]/gm);
-__Serializer.prototype.stringToN3 = function stringToN3(str, flags) {
-    if (!flags) flags = "e";
-    var res = '', i=0, j=0;
-    var delim;
-    var forbidden;
-    if (str.length > 20 // Long enough to make sense
-            && str.slice(-1) != '"'  // corner case'
-            && flags.indexOf('n') <0  // Force single line
-            && (str.indexOf('\n') >0 || str.indexOf('"') > 0)) {
-        delim = '"""';
-        forbidden =  __Serializer.prototype.forbidden3;
-    } else {
-        delim = '"';
-        forbidden = __Serializer.prototype.forbidden1;
-    }
-    for(i=0; i<str.length;) {
-        forbidden.lastIndex = 0;
-        var m = forbidden.exec(str.slice(i));
-        if (m == null) break;
-        j = i + forbidden.lastIndex -1;
-        res += str.slice(i,j);
-        var ch = str[j];
-        if (ch=='"' && delim == '"""' &&  str.slice(j,j+3) != '"""') {
-            res += ch;
-
-
-
-        } else {
-
-            var k = '\b\f\r\t\v\n\\"'.indexOf(ch); // No escaping of bell (7)?
-            if (k >= 0) {
-                res += "\\" + 'bfrtvn\\"'[k];
-            } else  {
-                if (flags.indexOf('e')>=0) {
-                    res += '\\u' + ('000'+
-                     ch.charCodeAt(0).toString(16).toLowerCase()).slice(-4)
-                } else { // no 'e' flag
-                    res += ch;
-
-                }
-            }
-        }
-        i = j+1;
-    }
-    return delim + res + str.slice(i) + delim
-}
-
-
-
-//  A single symbol, either in  <> or namespace notation
-
-
-__Serializer.prototype.symbolToN3 = function symbolToN3(x) {  // c.f. symbolString() in notation3.py
-    var uri = x.uri;
-    var j = uri.indexOf('#');
-    if (j<0 && this.flags.indexOf('/') < 0) {
-        j = uri.lastIndexOf('/');
-    }
-    if (j >= 0 && this.flags.indexOf('p') < 0)  { // Can split at namespace
-        var canSplit = true;
-        for (var k=j+1; k<uri.length; k++) {
-            if (__Serializer.prototype._notNameChars.indexOf(uri[k]) >=0) {
-                canSplit = false; break;
-            }
-        }
-        if (canSplit) {
-            var localid = uri.slice(j+1);
-            var namesp = uri.slice(0,j+1);
-            if (this.defaultNamespace && this.defaultNamespace == namesp
-                && this.flags.indexOf('d') < 0) {// d -> suppress default
-                if (this.flags.indexOf('k') >= 0 &&
-                    this.keyords.indexOf(localid) <0)
-                    return localid; 
-                return ':' + localid;
-            }
-            var prefix = this.prefixes[namesp];
-            if (prefix) {
-                //namespaceCounts[namesp] = true;
-                return prefix + ':' + localid;
-            }
-            if (uri.slice(0, j) == this.base)
-                return '<#' + localid + '>';
-            // Fall though if can't do qname
-        }
-    }
-    if (this.flags.indexOf('r') < 0 && this.base)
-        uri = $rdf.Util.uri.refTo(this.base, uri);
-    else if (this.flags.indexOf('u') >= 0)
-        uri = backslashUify(uri);
-    else uri = hexify(uri);
-    return '<'+uri+'>';
-}
-
-
-// String ecaping utilities 
-
-
-function hexify(str) { // also used in parser
-  return encodeURI(str);
-}
-
-
-function backslashUify(str) {
-    var res = '', k;
-    for (var i=0; i<str.length; i++) {
-        k = str.charCodeAt(i);
-        if (k>65535)
-            res += '\\U' + ('00000000'+k.toString(16)).slice(-8); // convert to upper?
-        else if (k>126) 
-            res += '\\u' + ('0000'+k.toString(16)).slice(-4);
-        else
-            res += str[i];
-    }
-    return res;
-}
-
-
-///////////////////////////// Quad store serialization
-
- 
-// @para. write  - a function taking a single string to be output
-//
-__Serializer.prototype.writeStore = function(write) {
- 
-    var kb = this.store;
-    var fetcher = kb.fetcher;
-    var session = fetcher && fetcher.appNode;
-    
-    // Everything we know from experience just write out.
-    if (session) write(this.statementsToN3(kb.statementsMatching(
-                                undefined, undefined, undefined, session)));
-                                
-    var sources = this.store.index[3];
-    for (s in sources) {  // -> assume we can use -> as short for log:semantics
-        var source = kb.fromNT(s);
-        if (session && source.sameTerm(session)) continue;
-        write('\n'+ this.atomicTermToN3(source)+' -> { '+ this.statementsToN3(kb.statementsMatching(
-                            undefined, undefined, undefined, source)) + ' }.\n');
-    }
-}
- 
- 
-
-
-
-//////////////////////////////////////////////// XML serialization
-
-__Serializer.prototype.statementsToXML = function(sts) {
-    var indent = 4;
-    var width = 80;
-
-    var namespaceCounts = []; // which have been used
-    namespaceCounts['http://www.w3.org/1999/02/22-rdf-syntax-ns#'] = true;
-
-    var liPrefix = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#_';	//prefix for ordered list items
-
-    ////////////////////////// Arrange the bits of XML text 
-
-    var spaces=function(n) {
-        var s='';
-        for(var i=0; i<n; i++) s+=' ';
-        return s
-    }
-
-    var XMLtreeToLine = function(tree) {
-        var str = '';
-        for (var i=0; i<tree.length; i++) {
-            var branch = tree[i];
-            var s2 = (typeof branch == 'string') ? branch : XMLtreeToLine(branch);
-            str += s2;
-        }
-        return str;
-    }
-    
-    // Convert a nested tree of lists and strings to a string
-    var XMLtreeToString = function(tree, level) {
-        var str = '';
-        var lastLength = 100000;
-        if (!level) level = 0;
-        for (var i=0; i<tree.length; i++) {
-            var branch = tree[i];
-            if (typeof branch != 'string') {
-                var substr = XMLtreeToString(branch, level +1);
-                if (
-                    substr.length < 10*(width-indent*level)
-                    && substr.indexOf('"""') < 0) {// Don't mess up multiline strings
-                    var line = XMLtreeToLine(branch);
-                    if (line.length < (width-indent*level)) {
-                        branch = '   '+line; //   @@ Hack: treat as string below
-                        substr = ''
-                    }
-                }
-                if (substr) lastLength = 10000;
-                str += substr;
-            }
-            if (typeof branch == 'string') {
-                if (lastLength < (indent*level+4)) { // continue
-                    str = str.slice(0,-1) + ' ' + branch + '\n';
-                    lastLength += branch.length + 1;
-                } else {
-                    var line = spaces(indent*level) +branch;
-                    str += line +'\n'; 
-                    lastLength = line.length;
-                }
- 
-            } else { // not string
-            }
-        }
-        return str;
-    };
-
-    function statementListToXMLTree(statements) {
-        this.suggestPrefix('rdf', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#');
-        var stats = this.rootSubjects(statements);
-        var roots = stats.roots;
-        var results = []
-        for (var i=0; i<roots.length; i++) {
-            root = roots[i];
-            results.push(subjectXMLTree(root, stats))
-        }
-        return results;
-    }
-    statementListToXMLTree = statementListToXMLTree.bind(this);
-    
-    function escapeForXML(str) {
-        if (typeof str == 'undefined') return '@@@undefined@@@@';
-        return str.replace(/[&<"]/g, function(m) {
-          switch(m[0]) {
-            case '&':
-              return '&amp;';
-            case '<':
-              return '&lt;';
-            case '"':
-              return '&quot;';
-          }
-        });
-    }
-
-    function relURI(term) {
-        return escapeForXML((this.base) ? $rdf.Util.uri.refTo(this.base, term.uri) : term.uri);
-    }
-    relURI = relURI.bind(this);
-
-    // The tree for a subject
-    function subjectXMLTree(subject, stats) {
-      var results = [];
-      var type, t, st, pred;
-      var sts = stats.subjects[this.toStr(subject)]; // relevant statements
-      if (typeof sts == 'undefined') {
-        throw('Cant find statements for '+subject);
-      }
-
-
-      // Sort only on the predicate, leave the order at object
-      // level undisturbed.  This leaves multilingual content in
-      // the order of entry (for partner literals), which helps
-      // readability.
-      //
-      // For the predicate sort, we attempt to split the uri
-      // as a hint to the sequence
-      sts.sort(function(a,b) {
-        var ap = a.predicate.uri;
-        var bp = b.predicate.uri;
-        if(ap.substring(0,liPrefix.length) == liPrefix || bp.substring(0,liPrefix.length) == liPrefix) {	//we're only interested in sorting list items
-          return ap.localeCompare(bp);
-        }
-
-        var as = ap.substring(liPrefix.length);
-        var bs = bp.substring(liPrefix.length);
-        var an = parseInt(as);
-        var bn = parseInt(bs);
-        if(isNaN(an) || isNaN(bn) ||
-            an != as || bn != bs) {	//we only care about integers
-          return ap.localeCompare(bp);
-        }
-
-        return an - bn;
-      });
-
-
-      for (var i=0; i<sts.length; i++) {
-        st = sts[i];
-        // look for a type
-        if(st.predicate.uri == 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' && !type && st.object.termType == "symbol") {
-          type = st.object;
-          continue;	//don't include it as a child element
-        }
-
-        // see whether predicate can be replaced with "li"
-        pred = st.predicate;
-        if(pred.uri.substr(0, liPrefix.length) == liPrefix) {
-          var number = pred.uri.substr(liPrefix.length);
-          // make sure these are actually numeric list items
-          var intNumber = parseInt(number);
-          if(number == intNumber.toString()) {
-            // was numeric; don't need to worry about ordering since we've already
-            // sorted the statements
-            pred = new $rdf.Symbol('http://www.w3.org/1999/02/22-rdf-syntax-ns#li');
-          }
-        }
-
-        t = qname(pred);
-        switch (st.object.termType) {
-          case 'bnode':
-            if(stats.incoming[st.object].length == 1) {	//there should always be something in the incoming array for a bnode
-              results = results.concat(['<'+ t +'>', 
-                subjectXMLTree(st.object, stats),
-                '</'+ t +'>']);
-            } else {
-              results = results.concat(['<'+ t +' rdf:nodeID="'
-                +st.object.toNT().slice(2)+'"/>']);
-            }
-          break;
-          case 'symbol':
-            results = results.concat(['<'+ t +' rdf:resource="'
-              + relURI(st.object)+'"/>']); 
-          break;
-          case 'literal':
-            results = results.concat(['<'+ t
-              + (st.object.dt ? ' rdf:datatype="'+escapeForXML(st.object.dt.uri)+'"' : '') 
-              + (st.object.lang ? ' xml:lang="'+st.object.lang+'"' : '') 
-              + '>' + escapeForXML(st.object.value)
-              + '</'+ t +'>']);
-          break;
-          case 'collection':
-            results = results.concat(['<'+ t +' rdf:parseType="Collection">', 
-              collectionXMLTree(st.object, stats),
-              '</'+ t +'>']);
-          break;
-          default:
-            throw "Can't serialize object of type "+st.object.termType +" into XML";
-        } // switch
-      }
-
-      var tag = type ? qname(type) : 'rdf:Description';
-
-      var attrs = '';
-      if (subject.termType == 'bnode') {
-          if(!stats.incoming[subject] || stats.incoming[subject].length != 1) { // not an anonymous bnode
-              attrs = ' rdf:nodeID="'+subject.toNT().slice(2)+'"';
-          }
-      } else {
-          attrs = ' rdf:about="'+ relURI(subject)+'"';
-      }
-
-      return [ '<' + tag + attrs + '>' ].concat([results]).concat(["</"+ tag +">"]);
-    }
-
-    subjectXMLTree = subjectXMLTree.bind(this);
-
-    function collectionXMLTree(subject, stats) {
-        var res = []
-        for (var i=0; i< subject.elements.length; i++) {
-            res.push(subjectXMLTree(subject.elements[i], stats));
-         }
-         return res;
-    }   
-
-    // The property tree for a single subject or anonymos node
-    function propertyXMLTree(subject, stats) {
-        var results = []
-        var sts = stats.subjects[this.toStr(subject)]; // relevant statements
-        if (sts == undefined) return results;  // No relevant statements
-        sts.sort();
-        for (var i=0; i<sts.length; i++) {
-            var st = sts[i];
-            switch (st.object.termType) {
-                case 'bnode':
-                    if(stats.rootsHash[st.object.toNT()]) { // This bnode has been done as a root -- no content here @@ what bout first time
-                        results = results.concat(['<'+qname(st.predicate)+' rdf:nodeID="'+st.object.toNT().slice(2)+'">',
-                        '</'+qname(st.predicate)+'>']);
-                    } else { 
-                    results = results.concat(['<'+qname(st.predicate)+' rdf:parseType="Resource">', 
-                        propertyXMLTree(st.object, stats),
-                        '</'+qname(st.predicate)+'>']);
-                    }
-                    break;
-                case 'symbol':
-                    results = results.concat(['<'+qname(st.predicate)+' rdf:resource="'
-                            + relURI(st.object)+'"/>']); 
-                    break;
-                case 'literal':
-                    results = results.concat(['<'+qname(st.predicate)
-                        + (st.object.datatype ? ' rdf:datatype="'+escapeForXML(st.object.datatype.uri)+'"' : '') 
-                        + (st.object.lang ? ' xml:lang="'+st.object.lang+'"' : '') 
-                        + '>' + escapeForXML(st.object.value)
-                        + '</'+qname(st.predicate)+'>']);
-                    break;
-                case 'collection':
-                    results = results.concat(['<'+qname(st.predicate)+' rdf:parseType="Collection">', 
-                        collectionXMLTree(st.object, stats),
-                        '</'+qname(st.predicate)+'>']);
-                    break;
-                default:
-                    throw "Can't serialize object of type "+st.object.termType +" into XML";
-                
-            } // switch
-        }
-        return results;
-    }
-    propertyXMLTree = propertyXMLTree.bind(this);
-
-    function qname(term) {
-        var uri = term.uri;
-
-        var j = uri.indexOf('#');
-        if (j<0 && this.flags.indexOf('/') < 0) {
-            j = uri.lastIndexOf('/');
-        }
-        if (j < 0) throw ("Cannot make qname out of <"+uri+">")
-
-        var canSplit = true;
-        for (var k=j+1; k<uri.length; k++) {
-            if (__Serializer.prototype._notNameChars.indexOf(uri[k]) >=0) {
-                throw ('Invalid character "'+uri[k] +'" cannot be in XML qname for URI: '+uri); 
-            }
-        }
-        var localid = uri.slice(j+1);
-        var namesp = uri.slice(0,j+1);
-        if (this.defaultNamespace && this.defaultNamespace == namesp
-            && this.flags.indexOf('d') < 0) {// d -> suppress default
-            return localid;
-        }
-        var prefix = this.prefixes[namesp];
-        if (!prefix) prefix = this.makeUpPrefix(namesp);
-        namespaceCounts[namesp] = true;
-        return prefix + ':' + localid;
-//        throw ('No prefix for namespace "'+namesp +'" for XML qname for '+uri+', namespaces: '+sz.prefixes+' sz='+sz); 
-    }
-    qname = qname.bind(this);
-
-    // Body of toXML:
-    
-    var tree = statementListToXMLTree(sts);
-    var str = '<rdf:RDF';
-    if (this.defaultNamespace)
-      str += ' xmlns="'+escapeForXML(this.defaultNamespace)+'"';
-    for (var ns in namespaceCounts) {
-        if (!namespaceCounts.hasOwnProperty(ns)) continue;
-        str += '\n xmlns:' + this.prefixes[ns] + '="'+escapeForXML(ns)+'"';
-    }
-    str += '>';
-
-    var tree2 = [str, tree, '</rdf:RDF>'];  //@@ namespace declrations
-    return XMLtreeToString(tree2, -1);
-
-
-} // End @@ body
-
-var Serializer = function( store ) {return new __Serializer( store )}; 
-return Serializer;
-
-}();
+/*      Serialization of RDF Graphs
+**
+** Tim Berners-Lee 2006
+** This is or was http://dig.csail.mit.edu/2005/ajar/ajaw/js/rdf/serialize.js
+**
+** Bug: can't serialize  http://data.semanticweb.org/person/abraham-bernstein/rdf 
+** in XML (from mhausenblas)
+*/
+
+// @@@ Check the whole toStr thing tosee whetehr it still makes sense -- tbl
+// 
+$rdf.Serializer = function() {
+
+var __Serializer = function( store ){
+    this.flags = "";
+    this.base = null;
+    this.prefixes = [];
+    this.namespacesUsed = [];
+    this.keywords = ['a']; // The only one we generate at the moment
+    this.prefixchars = "abcdefghijklmnopqustuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
+    this.incoming = null;  // Array not calculated yet
+    this.formulas = [];  // remebering original formulae from hashes 
+    this.store = store;
+
+    /* pass */
+}
+
+__Serializer.prototype.setBase = function(base)
+    { this.base = base };
+
+__Serializer.prototype.setFlags = function(flags)
+    { this.flags = flags?flags: '' };
+
+
+__Serializer.prototype.toStr = function(x) {
+        var s = x.toNT();
+        if (x.termType == 'formula') {
+            this.formulas[s] = x; // remember as reverse does not work
+        }
+        return s;
+};
+    
+__Serializer.prototype.fromStr = function(s) {
+        if (s[0] == '{') {
+            var x = this.formulas[s];
+            if (!x) alert('No formula object for '+s)
+            return x;
+        }
+        return this.store.fromNT(s);
+};
+    
+
+
+
+
+/* Accumulate Namespaces
+** 
+** These are only hints.  If two overlap, only one gets used
+** There is therefore no guarantee in general.
+*/
+
+__Serializer.prototype.suggestPrefix = function(prefix, uri) {
+    if (prefix.slice(0,7) === 'default') return; // Try to weed these out
+    if (prefix.slice(0,2) === 'ns') return; //  From others inferior algos
+    this.prefixes[uri] = prefix;
+}
+
+// Takes a namespace -> prefix map
+__Serializer.prototype.suggestNamespaces = function(namespaces) {
+    for (var px in namespaces) {
+        this.prefixes[namespaces[px]] = px;
+    }
+}
+
+// Make up an unused prefix for a random namespace
+__Serializer.prototype.makeUpPrefix = function(uri) {
+    var p = uri;
+    var namespaces = [];
+    var pok;
+    
+    function canUse(pp) {
+        if (namespaces[pp]) return false; // already used
+        this.prefixes[uri] = pp;
+        pok = pp;
+        return true
+    }
+    canUse = canUse.bind(this);
+    for (var ns in this.prefixes) {
+        namespaces[this.prefixes[ns]] = ns; // reverse index
+    }
+    if ('#/'.indexOf(p[p.length-1]) >= 0) p = p.slice(0, -1);
+    var slash = p.lastIndexOf('/');
+    if (slash >= 0) p = p.slice(slash+1);
+    var i = 0;
+    while (i < p.length)
+        if (this.prefixchars.indexOf(p[i])) i++; else break;
+    p = p.slice(0,i);
+    if (p.length < 6 && canUse(p)) return pok; // exact i sbest
+    if (canUse(p.slice(0,3))) return pok;
+    if (canUse(p.slice(0,2))) return pok;
+    if (canUse(p.slice(0,4))) return pok;
+    if (canUse(p.slice(0,1))) return pok;
+    if (canUse(p.slice(0,5))) return pok;
+    for (var i=0;; i++) if (canUse(p.slice(0,3)+i)) return pok; 
+}
+
+
+
+// Todo:
+//  - Sort the statements by subject, pred, object
+//  - do stuff about the docu first and then (or first) about its primary topic.
+
+__Serializer.prototype.rootSubjects = function(sts) {
+    var incoming = {};
+    var subjects = {};
+    var allBnodes = {};
+
+/* This scan is to find out which nodes will have to be the roots of trees
+** in the serialized form. This will be any symbols, and any bnodes
+** which hve more or less than one incoming arc, and any bnodes which have
+** one incoming arc but it is an uninterrupted loop of such nodes back to itself.
+** This should be kept linear time with repect to the number of statements.
+** Note it does not use any indexing of the store.
+*/
+
+
+    // $rdf.log.debug('serialize.js Find bnodes with only one incoming arc\n')
+    for (var i = 0; i<sts.length; i++) {
+        var st = sts[i];
+        [ st.subject, st.predicate, st.object].map(function(y){
+            if (y.termType =='bnode'){allBnodes[y.toNT()] = true}});
+        var x = sts[i].object;
+        if (!incoming.hasOwnProperty(x)) incoming[x] = [];
+        incoming[x].push(st.subject) // List of things which will cause this to be printed
+        var ss =  subjects[this.toStr(st.subject)]; // Statements with this as subject
+        if (!ss) ss = [];
+        ss.push(st);
+        subjects[this.toStr(st.subject)] = ss; // Make hash. @@ too slow for formula?
+        // $rdf.log.debug(' sz potential subject: '+sts[i].subject)
+    }
+
+    var roots = [];
+    for (var xNT in subjects) {
+        if (!subjects.hasOwnProperty(xNT)) continue;
+        var x = this.fromStr(xNT);
+        if ((x.termType != 'bnode') || !incoming[x] || (incoming[x].length != 1)){
+            roots.push(x);
+            //$rdf.log.debug(' sz actual subject -: ' + x)
+            continue;
+        }
+    }
+    this.incoming = incoming; // Keep for serializing @@ Bug for nested formulas
+    
+//////////// New bit for CONNECTED bnode loops:frootshash
+
+// This scans to see whether the serialization is gpoing to lead to a bnode loop
+// and at the same time accumulates a list of all bnodes mentioned.
+// This is in fact a cut down N3 serialization
+/*
+    // $rdf.log.debug('serialize.js Looking for connected bnode loops\n')
+    for (var i=0; i<sts.length; i++) { // @@TBL
+        // dump('\t'+sts[i]+'\n');
+    }
+    var doneBnodesNT = {};
+    function dummyPropertyTree(subject, subjects, rootsHash) {
+        // dump('dummyPropertyTree('+subject+'...)\n');
+        var sts = subjects[sz.toStr(subject)]; // relevant statements
+        for (var i=0; i<sts.length; i++) {
+            dummyObjectTree(sts[i].object, subjects, rootsHash);
+        }
+    }
+
+    // Convert a set of statements into a nested tree of lists and strings
+    // @param force,    "we know this is a root, do it anyway. It isn't a loop."
+    function dummyObjectTree(obj, subjects, rootsHash, force) { 
+        // dump('dummyObjectTree('+obj+'...)\n');
+        if (obj.termType == 'bnode' && (subjects[sz.toStr(obj)]  &&
+            (force || (rootsHash[obj.toNT()] == undefined )))) {// and there are statements
+            if (doneBnodesNT[obj.toNT()]) { // Ah-ha! a loop
+                throw "Serializer: Should be no loops "+obj;
+            }
+            doneBnodesNT[obj.toNT()] = true;
+            return  dummyPropertyTree(obj, subjects, rootsHash);
+        }
+        return dummyTermToN3(obj, subjects, rootsHash);
+    }
+    
+    // Scan for bnodes nested inside lists too
+    function dummyTermToN3(expr, subjects, rootsHash) {
+        if (expr.termType == 'bnode') doneBnodesNT[expr.toNT()] = true;
+        // $rdf.log.debug('serialize: seen '+expr);
+        if (expr.termType == 'collection') {
+            for (i=0; i<expr.elements.length; i++) {
+                if (expr.elements[i].termType == 'bnode')
+                    dummyObjectTree(expr.elements[i], subjects, rootsHash);
+            }
+        return;             
+        }
+    }
+
+    // The tree for a subject
+    function dummySubjectTree(subject, subjects, rootsHash) {
+        // dump('dummySubjectTree('+subject+'...)\n');
+        if (subject.termType == 'bnode' && !incoming[subject])
+            return dummyObjectTree(subject, subjects, rootsHash, true); // Anonymous bnode subject
+        dummyTermToN3(subject, subjects, rootsHash);
+        dummyPropertyTree(subject, subjects, rootsHash);
+    }
+*/    
+    // Now do the scan using existing roots
+    // $rdf.log.debug('serialize.js Dummy serialize to check for missing nodes')
+    var rootsHash = {};
+    for (var i = 0; i< roots.length; i++) rootsHash[roots[i].toNT()] = true;
+/*
+    for (var i=0; i<roots.length; i++) {
+        var root = roots[i];
+        dummySubjectTree(root, subjects, rootsHash);
+    }
+    // dump('Looking for mising bnodes...\n')
+    
+// Now in new roots for anythig not acccounted for
+// Now we check for any bndoes which have not been covered.
+// Such bnodes must be in isolated rings of pure bnodes.
+// They each have incoming link of 1.
+
+    // $rdf.log.debug('serialize.js Looking for connected bnode loops\n')
+    for (;;) {
+        var bnt;
+        var found = null;
+        for (bnt in allBnodes) { // @@ Note: not repeatable. No canonicalisation
+            if (doneBnodesNT[bnt]) continue;
+            found = bnt; // Ah-ha! not covered
+            break;
+        }
+        if (found == null) break; // All done - no bnodes left out/
+        // dump('Found isolated bnode:'+found+'\n');
+        doneBnodesNT[bnt] = true;
+        var root = this.store.fromNT(found);
+        roots.push(root); // Add a new root
+        rootsHash[found] = true;
+        // $rdf.log.debug('isolated bnode:'+found+', subjects[found]:'+subjects[found]+'\n');
+        if (subjects[found] == undefined) {
+            for (var i=0; i<sts.length; i++) {
+                // dump('\t'+sts[i]+'\n');
+            }
+            throw "Isolated node should be a subject" +found;
+        }
+        dummySubjectTree(root, subjects, rootsHash); // trace out the ring
+    }
+    // dump('Done bnode adjustments.\n')
+*/
+    return {'roots':roots, 'subjects':subjects, 
+                'rootsHash': rootsHash, 'incoming': incoming};
+}
+
+////////////////////////////////////////////////////////
+
+__Serializer.prototype.toN3 = function(f) {
+    return this.statementsToN3(f.statements);
+}
+
+__Serializer.prototype._notQNameChars = "\t\r\n !\"#$%&'()*.,+/;<=>?@[\\]^`{|}~";
+__Serializer.prototype._notNameChars = 
+                    ( __Serializer.prototype._notQNameChars + ":" ) ;
+
+    
+__Serializer.prototype.statementsToN3 = function(sts) {
+    var indent = 4;
+    var width = 80;
+
+    var predMap = {
+        'http://www.w3.org/2002/07/owl#sameAs': '=',
+        'http://www.w3.org/2000/10/swap/log#implies': '=>',
+        'http://www.w3.org/1999/02/22-rdf-syntax-ns#type': 'a'
+    }
+    
+
+    
+    
+    ////////////////////////// Arrange the bits of text 
+
+    var spaces=function(n) {
+        var s='';
+        for(var i=0; i<n; i++) s+=' ';
+        return s
+    }
+
+    var treeToLine = function(tree) {
+        var str = '';
+        for (var i=0; i<tree.length; i++) {
+            var branch = tree[i];
+            var s2 = (typeof branch == 'string') ? branch : treeToLine(branch);
+            if (i!=0 && s2 != ',' && s2 != ';' && s2 != '.') str += ' ';
+            str += s2;
+        }
+        return str;
+    }
+    
+    // Convert a nested tree of lists and strings to a string
+    var treeToString = function(tree, level) {
+        var str = '';
+        var lastLength = 100000;
+        if (!level) level = 0;
+        for (var i=0; i<tree.length; i++) {
+            var branch = tree[i];
+            if (typeof branch != 'string') {
+                var substr = treeToString(branch, level +1);
+                if (
+                    substr.length < 10*(width-indent*level)
+                    && substr.indexOf('"""') < 0) {// Don't mess up multiline strings
+                    var line = treeToLine(branch);
+                    if (line.length < (width-indent*level)) {
+                        branch = '   '+line; //   @@ Hack: treat as string below
+                        substr = ''
+                    }
+                }
+                if (substr) lastLength = 10000;
+                str += substr;
+            }
+            if (typeof branch == 'string') {
+                if (branch.length == '1' && str.slice(-1) == '\n') {
+                    if (",.;".indexOf(branch) >=0) {
+                        str = str.slice(0,-1) + branch + '\n'; //  slip punct'n on end
+                        lastLength += 1;
+                        continue;
+                    } else if ("])}".indexOf(branch) >=0) {
+                        str = str.slice(0,-1) + ' ' + branch + '\n';
+                        lastLength += 2;
+                        continue;
+                    }
+                }
+                if (lastLength < (indent*level+4)) { // continue
+                    str = str.slice(0,-1) + ' ' + branch + '\n';
+                    lastLength += branch.length + 1;
+                } else {
+                    var line = spaces(indent*level) +branch;
+                    str += line +'\n'; 
+                    lastLength = line.length;
+                }
+ 
+            } else { // not string
+            }
+        }
+        return str;
+    };
+
+    ////////////////////////////////////////////// Structure for N3
+    
+    
+    // Convert a set of statements into a nested tree of lists and strings
+    function statementListToTree(statements) {
+        // print('Statement tree for '+statements.length);
+        var res = [];
+        var stats = this.rootSubjects(statements);
+        var roots = stats.roots;
+        var results = []
+        for (var i=0; i<roots.length; i++) {
+            var root = roots[i];
+            results.push(subjectTree(root, stats))
+        }
+        return results;
+    }
+    statementListToTree = statementListToTree.bind(this);
+    
+    // The tree for a subject
+    function subjectTree(subject, stats) {
+        if (subject.termType == 'bnode' && !stats.incoming[subject])
+            return objectTree(subject, stats, true).concat(["."]); // Anonymous bnode subject
+        return [ termToN3(subject, stats) ].concat([propertyTree(subject, stats)]).concat(["."]);
+    }
+    
+
+    // The property tree for a single subject or anonymous node
+    function propertyTree(subject, stats) {
+        // print('Proprty tree for '+subject);
+        var results = []
+        var lastPred = null;
+        var sts = stats.subjects[this.toStr(subject)]; // relevant statements
+        if (typeof sts == 'undefined') {
+            throw('Cant find statements for '+subject);
+        }
+        sts.sort();
+        var objects = [];
+        for (var i=0; i<sts.length; i++) {
+            var st = sts[i];
+            if (st.predicate.uri == lastPred) {
+                objects.push(',');
+            } else {
+                if (lastPred) {
+                    results=results.concat([objects]).concat([';']);
+                    objects = [];
+                }
+                results.push(predMap[st.predicate.uri] ?
+                            predMap[st.predicate.uri] : termToN3(st.predicate, stats));
+            }
+            lastPred = st.predicate.uri;
+            objects.push(objectTree(st.object, stats));
+        }
+        results=results.concat([objects]);
+        return results;
+    }
+    propertyTree = propertyTree.bind(this);
+
+    function objectTree(obj, stats, force) {
+        if (obj.termType == 'bnode' &&
+                stats.subjects[this.toStr(obj)] && // and there are statements
+                (force || stats.rootsHash[obj.toNT()] == undefined)) // and not a root
+            return  ['['].concat(propertyTree(obj, stats)).concat([']']);
+        return termToN3(obj, stats);
+    }
+    objectTree = objectTree.bind(this);
+    
+    function termToN3(expr, stats) {
+        switch(expr.termType) {
+        
+            case 'formula':
+                var res = ['{'];
+                res = res.concat(statementListToTree(expr.statements));
+                return  res.concat(['}']);
+
+            case 'collection':
+                var res = ['('];
+                for (i=0; i<expr.elements.length; i++) {
+                    res.push(   [ objectTree(expr.elements[i], stats) ]);
+                }
+                res.push(')');
+                return res;
+                
+           default:
+                return this.atomicTermToN3(expr);
+        }
+    }
+    __Serializer.prototype.termToN3 = termToN3;
+    termToN3 = termToN3.bind(this);
+
+    function prefixDirectives() {
+        var str = '';
+        if (this.defaultNamespace)
+          str += '@prefix : <'+this.defaultNamespace+'>.\n';
+        for (var ns in this.prefixes) {
+            if (!this.prefixes.hasOwnProperty(ns)) continue;
+            if (!this.namespacesUsed[ns]) continue;
+            str += '@prefix ' + this.prefixes[ns] + ': <'+ns+'>.\n';
+        }
+        return str + '\n';
+    }
+    prefixDirectives = prefixDirectives.bind(this);
+
+    // Body of statementsToN3:
+    
+    var tree = statementListToTree(sts);
+    return prefixDirectives() + treeToString(tree, -1);
+    
+}
+
+
+////////////////////////////////////////////// Atomic Terms
+
+//  Deal with term level things and nesting with no bnode structure
+
+
+__Serializer.prototype.atomicTermToN3 = function atomicTermToN3(expr, stats) {
+    switch(expr.termType) {
+        case 'bnode':
+        case 'variable':  return expr.toNT();
+        case 'literal':
+            if (expr.datatype) {
+                switch (expr.datatype.uri) {
+                case 'http://www.w3.org/2001/XMLSchema#integer':
+                    return expr.value.toString();
+                    
+                //case 'http://www.w3.org/2001/XMLSchema#double': // Must force use of 'e'
+                
+                case 'http://www.w3.org/2001/XMLSchema#boolean':
+                    return expr.value? 'true' : 'false';
+                }
+            }
+            var str = this.stringToN3(expr.value);
+            if (expr.lang) str+= '@' + expr.lang;
+            if (expr.datatype) str+= '^^' + this.termToN3(expr.datatype, stats);
+            return str;
+        case 'symbol':
+            return this.symbolToN3(expr);
+       default:
+            throw "Internal: atomicTermToN3 cannot handle "+expr+" of termType+"+expr.termType
+            return ''+expr;
+    }
+};
+
+    //  stringToN3:  String escaping for N3
+
+__Serializer.prototype.forbidden1 = new RegExp(/[\\"\b\f\r\v\t\n\u0080-\uffff]/gm);
+__Serializer.prototype.forbidden3 = new RegExp(/[\\"\b\f\r\v\u0080-\uffff]/gm);
+__Serializer.prototype.stringToN3 = function stringToN3(str, flags) {
+    if (!flags) flags = "e";
+    var res = '', i=0, j=0;
+    var delim;
+    var forbidden;
+    if (str.length > 20 // Long enough to make sense
+            && str.slice(-1) != '"'  // corner case'
+            && flags.indexOf('n') <0  // Force single line
+            && (str.indexOf('\n') >0 || str.indexOf('"') > 0)) {
+        delim = '"""';
+        forbidden =  __Serializer.prototype.forbidden3;
+    } else {
+        delim = '"';
+        forbidden = __Serializer.prototype.forbidden1;
+    }
+    for(i=0; i<str.length;) {
+        forbidden.lastIndex = 0;
+        var m = forbidden.exec(str.slice(i));
+        if (m == null) break;
+        j = i + forbidden.lastIndex -1;
+        res += str.slice(i,j);
+        var ch = str[j];
+        if (ch=='"' && delim == '"""' &&  str.slice(j,j+3) != '"""') {
+            res += ch;
+
+
+
+        } else {
+
+            var k = '\b\f\r\t\v\n\\"'.indexOf(ch); // No escaping of bell (7)?
+            if (k >= 0) {
+                res += "\\" + 'bfrtvn\\"'[k];
+            } else  {
+                if (flags.indexOf('e')>=0) {
+                    res += '\\u' + ('000'+
+                     ch.charCodeAt(0).toString(16).toLowerCase()).slice(-4)
+                } else { // no 'e' flag
+                    res += ch;
+
+                }
+            }
+        }
+        i = j+1;
+    }
+    return delim + res + str.slice(i) + delim
+}
+
+
+
+//  A single symbol, either in  <> or namespace notation
+
+
+__Serializer.prototype.symbolToN3 = function symbolToN3(x) {  // c.f. symbolString() in notation3.py
+    var uri = x.uri;
+    var j = uri.indexOf('#');
+    if (j<0 && this.flags.indexOf('/') < 0) {
+        j = uri.lastIndexOf('/');
+    }
+    if (j >= 0 && this.flags.indexOf('p') < 0)  { // Can split at namespace
+        var canSplit = true;
+        for (var k=j+1; k<uri.length; k++) {
+            if (__Serializer.prototype._notNameChars.indexOf(uri[k]) >=0) {
+                canSplit = false; break;
+            }
+        }
+        if (canSplit) {
+            var localid = uri.slice(j+1);
+            var namesp = uri.slice(0,j+1);
+            if (this.defaultNamespace && this.defaultNamespace == namesp
+                && this.flags.indexOf('d') < 0) {// d -> suppress default
+                if (this.flags.indexOf('k') >= 0 &&
+                    this.keyords.indexOf(localid) <0)
+                    return localid; 
+                return ':' + localid;
+            }
+            var prefix = this.prefixes[namesp];
+            if (prefix) {
+                this.namespacesUsed[namesp] = true;
+                return prefix + ':' + localid;
+            }
+            if (uri.slice(0, j) == this.base)
+                return '<#' + localid + '>';
+            // Fall though if can't do qname
+        }
+    }
+    if (this.flags.indexOf('r') < 0 && this.base)
+        uri = $rdf.Util.uri.refTo(this.base, uri);
+    else if (this.flags.indexOf('u') >= 0)
+        uri = backslashUify(uri);
+    else uri = hexify(uri);
+    return '<'+uri+'>';
+}
+
+
+// String ecaping utilities 
+
+
+function hexify(str) { // also used in parser
+  return encodeURI(str);
+}
+
+
+function backslashUify(str) {
+    var res = '', k;
+    for (var i=0; i<str.length; i++) {
+        k = str.charCodeAt(i);
+        if (k>65535)
+            res += '\\U' + ('00000000'+k.toString(16)).slice(-8); // convert to upper?
+        else if (k>126) 
+            res += '\\u' + ('0000'+k.toString(16)).slice(-4);
+        else
+            res += str[i];
+    }
+    return res;
+}
+
+
+///////////////////////////// Quad store serialization
+
+ 
+// @para. write  - a function taking a single string to be output
+//
+__Serializer.prototype.writeStore = function(write) {
+ 
+    var kb = this.store;
+    var fetcher = kb.fetcher;
+    var session = fetcher && fetcher.appNode;
+    
+    // Everything we know from experience just write out.
+    if (session) write(this.statementsToN3(kb.statementsMatching(
+                                undefined, undefined, undefined, session)));
+                                
+    var sources = this.store.index[3];
+    for (s in sources) {  // -> assume we can use -> as short for log:semantics
+        var source = kb.fromNT(s);
+        if (session && source.sameTerm(session)) continue;
+        write('\n'+ this.atomicTermToN3(source)+' -> { '+ this.statementsToN3(kb.statementsMatching(
+                            undefined, undefined, undefined, source)) + ' }.\n');
+    }
+}
+ 
+ 
+
+
+
+//////////////////////////////////////////////// XML serialization
+
+__Serializer.prototype.statementsToXML = function(sts) {
+    var indent = 4;
+    var width = 80;
+
+    var namespaceCounts = []; // which have been used
+    namespaceCounts['http://www.w3.org/1999/02/22-rdf-syntax-ns#'] = true;
+
+    var liPrefix = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#_';	//prefix for ordered list items
+
+    ////////////////////////// Arrange the bits of XML text 
+
+    var spaces=function(n) {
+        var s='';
+        for(var i=0; i<n; i++) s+=' ';
+        return s
+    }
+
+    var XMLtreeToLine = function(tree) {
+        var str = '';
+        for (var i=0; i<tree.length; i++) {
+            var branch = tree[i];
+            var s2 = (typeof branch == 'string') ? branch : XMLtreeToLine(branch);
+            str += s2;
+        }
+        return str;
+    }
+    
+    // Convert a nested tree of lists and strings to a string
+    var XMLtreeToString = function(tree, level) {
+        var str = '';
+        var lastLength = 100000;
+        if (!level) level = 0;
+        for (var i=0; i<tree.length; i++) {
+            var branch = tree[i];
+            if (typeof branch != 'string') {
+                var substr = XMLtreeToString(branch, level +1);
+                if (
+                    substr.length < 10*(width-indent*level)
+                    && substr.indexOf('"""') < 0) {// Don't mess up multiline strings
+                    var line = XMLtreeToLine(branch);
+                    if (line.length < (width-indent*level)) {
+                        branch = '   '+line; //   @@ Hack: treat as string below
+                        substr = ''
+                    }
+                }
+                if (substr) lastLength = 10000;
+                str += substr;
+            }
+            if (typeof branch == 'string') {
+                if (lastLength < (indent*level+4)) { // continue
+                    str = str.slice(0,-1) + ' ' + branch + '\n';
+                    lastLength += branch.length + 1;
+                } else {
+                    var line = spaces(indent*level) +branch;
+                    str += line +'\n'; 
+                    lastLength = line.length;
+                }
+ 
+            } else { // not string
+            }
+        }
+        return str;
+    };
+
+    function statementListToXMLTree(statements) {
+        this.suggestPrefix('rdf', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#');
+        var stats = this.rootSubjects(statements);
+        var roots = stats.roots;
+        var results = []
+        for (var i=0; i<roots.length; i++) {
+            root = roots[i];
+            results.push(subjectXMLTree(root, stats))
+        }
+        return results;
+    }
+    statementListToXMLTree = statementListToXMLTree.bind(this);
+    
+    function escapeForXML(str) {
+        if (typeof str == 'undefined') return '@@@undefined@@@@';
+        return str.replace(/[&<"]/g, function(m) {
+          switch(m[0]) {
+            case '&':
+              return '&amp;';
+            case '<':
+              return '&lt;';
+            case '"':
+              return '&quot;'; //'
+          }
+        });
+    }
+
+    function relURI(term) {
+        return escapeForXML((this.base) ? $rdf.Util.uri.refTo(this.base, term.uri) : term.uri);
+    }
+    relURI = relURI.bind(this);
+
+    // The tree for a subject
+    function subjectXMLTree(subject, stats) {
+      var results = [];
+      var type, t, st, pred;
+      var sts = stats.subjects[this.toStr(subject)]; // relevant statements
+      if (typeof sts == 'undefined') {
+        throw('Serializing XML - Cant find statements for '+subject);
+      }
+
+
+      // Sort only on the predicate, leave the order at object
+      // level undisturbed.  This leaves multilingual content in
+      // the order of entry (for partner literals), which helps
+      // readability.
+      //
+      // For the predicate sort, we attempt to split the uri
+      // as a hint to the sequence
+      sts.sort(function(a,b) {
+        var ap = a.predicate.uri;
+        var bp = b.predicate.uri;
+        if(ap.substring(0,liPrefix.length) == liPrefix || bp.substring(0,liPrefix.length) == liPrefix) {	//we're only interested in sorting list items
+          return ap.localeCompare(bp);
+        }
+
+        var as = ap.substring(liPrefix.length);
+        var bs = bp.substring(liPrefix.length);
+        var an = parseInt(as);
+        var bn = parseInt(bs);
+        if(isNaN(an) || isNaN(bn) ||
+            an != as || bn != bs) {	//we only care about integers
+          return ap.localeCompare(bp);
+        }
+
+        return an - bn;
+      });
+
+
+      for (var i=0; i<sts.length; i++) {
+        st = sts[i];
+        // look for a type
+        if(st.predicate.uri == 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type' && !type && st.object.termType == "symbol") {
+          type = st.object;
+          continue;	//don't include it as a child element
+        }
+
+        // see whether predicate can be replaced with "li"
+        pred = st.predicate;
+        if(pred.uri.substr(0, liPrefix.length) == liPrefix) {
+          var number = pred.uri.substr(liPrefix.length);
+          // make sure these are actually numeric list items
+          var intNumber = parseInt(number);
+          if(number == intNumber.toString()) {
+            // was numeric; don't need to worry about ordering since we've already
+            // sorted the statements
+            pred = new $rdf.Symbol('http://www.w3.org/1999/02/22-rdf-syntax-ns#li');
+          }
+        }
+
+        t = qname(pred);
+        switch (st.object.termType) {
+          case 'bnode':
+            if(stats.incoming[st.object].length == 1) {	//there should always be something in the incoming array for a bnode
+              results = results.concat(['<'+ t +'>', 
+                subjectXMLTree(st.object, stats),
+                '</'+ t +'>']);
+            } else {
+              results = results.concat(['<'+ t +' rdf:nodeID="'
+                +st.object.toNT().slice(2)+'"/>']);
+            }
+          break;
+          case 'symbol':
+            results = results.concat(['<'+ t +' rdf:resource="'
+              + relURI(st.object)+'"/>']); 
+          break;
+          case 'literal':
+            results = results.concat(['<'+ t
+              + (st.object.dt ? ' rdf:datatype="'+escapeForXML(st.object.dt.uri)+'"' : '') 
+              + (st.object.lang ? ' xml:lang="'+st.object.lang+'"' : '') 
+              + '>' + escapeForXML(st.object.value)
+              + '</'+ t +'>']);
+          break;
+          case 'collection':
+            results = results.concat(['<'+ t +' rdf:parseType="Collection">', 
+              collectionXMLTree(st.object, stats),
+              '</'+ t +'>']);
+          break;
+          default:
+            throw "Can't serialize object of type "+st.object.termType +" into XML";
+        } // switch
+      }
+
+      var tag = type ? qname(type) : 'rdf:Description';
+
+      var attrs = '';
+      if (subject.termType == 'bnode') {
+          if(!stats.incoming[subject] || stats.incoming[subject].length != 1) { // not an anonymous bnode
+              attrs = ' rdf:nodeID="'+subject.toNT().slice(2)+'"';
+          }
+      } else {
+          attrs = ' rdf:about="'+ relURI(subject)+'"';
+      }
+
+      return [ '<' + tag + attrs + '>' ].concat([results]).concat(["</"+ tag +">"]);
+    }
+
+    subjectXMLTree = subjectXMLTree.bind(this);
+
+    function collectionXMLTree(subject, stats) {
+        var res = []
+        for (var i=0; i< subject.elements.length; i++) {
+            res.push(subjectXMLTree(subject.elements[i], stats));
+         }
+         return res;
+    }   
+
+    // The property tree for a single subject or anonymos node
+    function propertyXMLTree(subject, stats) {
+        var results = []
+        var sts = stats.subjects[this.toStr(subject)]; // relevant statements
+        if (sts == undefined) return results;  // No relevant statements
+        sts.sort();
+        for (var i=0; i<sts.length; i++) {
+            var st = sts[i];
+            switch (st.object.termType) {
+                case 'bnode':
+                    if(stats.rootsHash[st.object.toNT()]) { // This bnode has been done as a root -- no content here @@ what bout first time
+                        results = results.concat(['<'+qname(st.predicate)+' rdf:nodeID="'+st.object.toNT().slice(2)+'">',
+                        '</'+qname(st.predicate)+'>']);
+                    } else { 
+                    results = results.concat(['<'+qname(st.predicate)+' rdf:parseType="Resource">', 
+                        propertyXMLTree(st.object, stats),
+                        '</'+qname(st.predicate)+'>']);
+                    }
+                    break;
+                case 'symbol':
+                    results = results.concat(['<'+qname(st.predicate)+' rdf:resource="'
+                            + relURI(st.object)+'"/>']); 
+                    break;
+                case 'literal':
+                    results = results.concat(['<'+qname(st.predicate)
+                        + (st.object.datatype ? ' rdf:datatype="'+escapeForXML(st.object.datatype.uri)+'"' : '') 
+                        + (st.object.lang ? ' xml:lang="'+st.object.lang+'"' : '') 
+                        + '>' + escapeForXML(st.object.value)
+                        + '</'+qname(st.predicate)+'>']);
+                    break;
+                case 'collection':
+                    results = results.concat(['<'+qname(st.predicate)+' rdf:parseType="Collection">', 
+                        collectionXMLTree(st.object, stats),
+                        '</'+qname(st.predicate)+'>']);
+                    break;
+                default:
+                    throw "Can't serialize object of type "+st.object.termType +" into XML";
+                
+            } // switch
+        }
+        return results;
+    }
+    propertyXMLTree = propertyXMLTree.bind(this);
+
+    function qname(term) {
+        var uri = term.uri;
+
+        var j = uri.indexOf('#');
+        if (j<0 && this.flags.indexOf('/') < 0) {
+            j = uri.lastIndexOf('/');
+        }
+        if (j < 0) throw ("Cannot make qname out of <"+uri+">")
+
+        var canSplit = true;
+        for (var k=j+1; k<uri.length; k++) {
+            if (__Serializer.prototype._notNameChars.indexOf(uri[k]) >=0) {
+                throw ('Invalid character "'+uri[k] +'" cannot be in XML qname for URI: '+uri); 
+            }
+        }
+        var localid = uri.slice(j+1);
+        var namesp = uri.slice(0,j+1);
+        if (this.defaultNamespace && this.defaultNamespace == namesp
+            && this.flags.indexOf('d') < 0) {// d -> suppress default
+            return localid;
+        }
+        var prefix = this.prefixes[namesp];
+        if (!prefix) prefix = this.makeUpPrefix(namesp);
+        namespaceCounts[namesp] = true;
+        return prefix + ':' + localid;
+//        throw ('No prefix for namespace "'+namesp +'" for XML qname for '+uri+', namespaces: '+sz.prefixes+' sz='+sz); 
+    }
+    qname = qname.bind(this);
+
+    // Body of toXML:
+    
+    var tree = statementListToXMLTree(sts);
+    var str = '<rdf:RDF';
+    if (this.defaultNamespace)
+      str += ' xmlns="'+escapeForXML(this.defaultNamespace)+'"';
+    for (var ns in namespaceCounts) {
+        if (!namespaceCounts.hasOwnProperty(ns)) continue;
+        str += '\n xmlns:' + this.prefixes[ns] + '="'+escapeForXML(ns)+'"';
+    }
+    str += '>';
+
+    var tree2 = [str, tree, '</rdf:RDF>'];  //@@ namespace declrations
+    return XMLtreeToString(tree2, -1);
+
+
+} // End @@ body
+
+var Serializer = function( store ) {return new __Serializer( store )}; 
+return Serializer;
+
+}();
 /*
 # Updates-Via
 */
@@ -6946,6 +6879,9 @@ $rdf.UpdatesVia = (function() {
     if (d.headers == null) {
       return true;
     }
+    if (typeof WebSocket === "undefined" || WebSocket === null) {
+      return true;
+    }
     etag = d.headers['etag'];
     via = d.headers['updates-via'];
     uri = d.uri;
@@ -7028,6 +6964,7 @@ $rdf.Fetcher = function(store, timeout, async) {
     ns.rdfs = $rdf.Namespace("http://www.w3.org/2000/01/rdf-schema#");
     ns.dc = $rdf.Namespace("http://purl.org/dc/elements/1.1/");
 
+    
     $rdf.Fetcher.crossSiteProxy = function(uri) {
         if ($rdf.Fetcher.crossSiteProxyTemplate)
           return $rdf.Fetcher.crossSiteProxyTemplate.replace('{uri}', encodeURIComponent(uri));
@@ -7037,8 +6974,9 @@ $rdf.Fetcher = function(store, timeout, async) {
         if (args) {
             this.dom = args[0]
         }
-        this.recv = function(xhr) {
+        this.handlerFactory = function(xhr) {
             xhr.handle = function(cb) {
+                //sf.addStatus(xhr.req, 'parsing soon as RDF/XML...');
                 var kb = sf.store;
                 if (!this.dom) this.dom = $rdf.Util.parseXML(xhr.responseText);
 /*                {
@@ -7053,7 +6991,6 @@ $rdf.Fetcher = function(store, timeout, async) {
                 }
 */
                 var root = this.dom.documentElement;
-                //some simple syntax issue should be dealt here, I think
                 if (root.nodeName == 'parsererror') { //@@ Mozilla only See issue/issue110
                     sf.failFetch(xhr, "Badly formed XML in " + xhr.uri.uri); //have to fail the request
                     throw new Error("Badly formed XML in " + xhr.uri.uri); //@@ Add details
@@ -7061,17 +6998,13 @@ $rdf.Fetcher = function(store, timeout, async) {
                 // Find the last URI we actual URI in a series of redirects
                 // (xhr.uri.uri is the original one)
                 var lastRequested = kb.any(xhr.req, ns.link('requestedURI'));
-                //dump('lastRequested 1:'+lastRequested+'\n')
                 if (!lastRequested) {
-                    //dump("Eh? No last requested for "+xhr.uri+"\n");
                     lastRequested = xhr.uri;
                 } else {
                     lastRequested = kb.sym(lastRequested.value);
-                    //dump('lastRequested 2:'+lastRequested+'\n')
                 }
-                //dump('lastRequested 3:'+lastRequested+'\n')
                 var parser = new $rdf.RDFParser(kb);
-                sf.addStatus(xhr.req, 'parsing as RDF/XML...');
+                // sf.addStatus(xhr.req, 'parsing as RDF/XML...');
                 parser.parse(this.dom, lastRequested.uri, lastRequested);
                 kb.add(lastRequested, ns.rdf('type'), ns.link('RDFDocument'), sf.appNode);
                 cb();
@@ -7096,7 +7029,7 @@ $rdf.Fetcher = function(store, timeout, async) {
         if (args) {
             this.dom = args[0]
         }
-        this.recv = function(xhr) {
+        this.handlerFactory = function(xhr) {
             xhr.handle = function(cb) {
                 if (!this.dom) {
                     var dparser;
@@ -7146,6 +7079,7 @@ $rdf.Fetcher = function(store, timeout, async) {
                 // Do RDFa here
                 if ($rdf.rdfa && $rdf.rdfa.parse)
                     $rdf.rdfa.parse(this.dom, kb, xhr.uri.uri);
+                cb(); // Fire done callbacks
             }
         }
     };
@@ -7164,7 +7098,7 @@ $rdf.Fetcher = function(store, timeout, async) {
     /******************************************************/
 
     $rdf.Fetcher.XMLHandler = function() {
-        this.recv = function(xhr) {
+        this.handlerFactory = function(xhr) {
             xhr.handle = function(cb) {
                 var kb = sf.store
                 var dparser;
@@ -7248,7 +7182,7 @@ $rdf.Fetcher = function(store, timeout, async) {
     $rdf.Fetcher.XMLHandler.pattern = new RegExp("(text|application)/(.*)xml");
 
     $rdf.Fetcher.HTMLHandler = function() {
-        this.recv = function(xhr) {
+        this.handlerFactory = function(xhr) {
             xhr.handle = function(cb) {
                 var rt = xhr.responseText
                 // We only handle XHTML so we have to figure out if this is XML
@@ -7305,7 +7239,7 @@ $rdf.Fetcher = function(store, timeout, async) {
     /***********************************************/
 
     $rdf.Fetcher.TextHandler = function() {
-        this.recv = function(xhr) {
+        this.handlerFactory = function(xhr) {
             xhr.handle = function(cb) {
                 // We only speak dialects of XML right now. Is this XML?
                 var rt = xhr.responseText
@@ -7349,9 +7283,11 @@ $rdf.Fetcher = function(store, timeout, async) {
     /***********************************************/
 
     $rdf.Fetcher.N3Handler = function() {
-        this.recv = function(xhr) {
+        this.handlerFactory = function(xhr) {
             xhr.handle = function(cb) {
                 // Parse the text of this non-XML file
+                $rdf.log.debug("web.js: Parsing as N3 " + xhr.uri.uri); // @@@@ comment me out 
+                //sf.addStatus(xhr.req, "N3 not parsed yet...")
                 var rt = xhr.responseText
                 var p = $rdf.N3Parser(kb, kb, xhr.uri.uri, xhr.uri.uri, null, null, "", null)
                 //                p.loadBuf(xhr.responseText)
@@ -7359,13 +7295,13 @@ $rdf.Fetcher = function(store, timeout, async) {
                     p.loadBuf(xhr.responseText)
 
                 } catch (e) {
-                    var msg = ("Error trying to parse " + xhr.uri + ' as Notation3:\n' + e +':\n'+e.stack)
+                    var msg = ("Error trying to parse " + xhr.uri + " as Notation3:\n" + e +':\n'+e.stack)
                     // dump(msg+"\n")
                     sf.failFetch(xhr, msg)
                     return;
                 }
 
-                sf.addStatus(xhr.req, 'N3 parsed: ' + p.statementCount + ' statements in ' + p.lines + ' lines.')
+                sf.addStatus(xhr.req, "N3 parsed: " + p.statementCount + " triples in " + p.lines + " lines.")
                 sf.store.add(xhr.uri, ns.rdf('type'), ns.link('RDFDocument'), sf.appNode);
                 args = [xhr.uri.uri]; // Other args needed ever?
                 sf.doneFetch(xhr, args)
@@ -7416,7 +7352,7 @@ $rdf.Fetcher = function(store, timeout, async) {
                     ';\n\t $rdf.Fetcher.HTMLHandler='+$rdf.Fetcher.HTMLHandler+'\n' +
                     '\n\tsf.handlers='+sf.handlers+'\n'
         }
-        (new handler(args)).recv(xhr);
+        (new handler(args)).handlerFactory(xhr);
         xhr.handle(cb)
     }
 
@@ -7426,7 +7362,12 @@ $rdf.Fetcher = function(store, timeout, async) {
         status = "[" + now.getHours() + ":" + now.getMinutes() + ":" + now.getSeconds() + "." + now.getMilliseconds() + "] " + status;
         //</Debug>
         var kb = this.store
-        kb.the(req, ns.link('status')).append(kb.literal(status))
+        var s = kb.the(req, ns.link('status'));
+        if (s && s.append) {
+            s.append(kb.literal(status));
+        } else {
+            $rdf.log.warn("web.js: No list to add to: " + s + ',' + status); // @@@
+        };
     }
 
     // Record errors in the system on failure
@@ -7435,7 +7376,7 @@ $rdf.Fetcher = function(store, timeout, async) {
         this.addStatus(xhr.req, status)
         kb.add(xhr.uri, ns.link('error'), status)
         this.requested[$rdf.uri.docpart(xhr.uri.uri)] = false
-        this.fireCallbacks('fail', [xhr.requestedURI])
+        this.fireCallbacks('fail', [xhr.requestedURI, status])
         xhr.abort()
         return xhr
     }
@@ -7515,13 +7456,22 @@ $rdf.Fetcher = function(store, timeout, async) {
 
 
 /*  Ask for a doc to be loaded if necessary then call back
-    **/
+**
+** Changed 2013-08-20:  Added (ok, body) params to callback
+**
+**/
     this.nowOrWhenFetched = function(uri, referringTerm, callback) {
         var sta = this.getState(uri);
-        if (sta == 'fetched') return callback();
+        if (sta == 'fetched') return callback(true);
         this.addCallback('done', function(uri2) {
             if (uri2 == uri ||
-                ( $rdf.Fetcher.crossSiteProxy(uri) == uri2  )) callback();
+                ( $rdf.Fetcher.crossSiteProxy(uri) == uri2  )) callback(true);
+            return (uri2 != uri); // Call me again?
+        });
+        this.addCallback('fail', function(uri2, status) {
+            if (uri2 == uri ||
+                ( $rdf.Fetcher.crossSiteProxy(uri) == uri2  )) callback(
+                    false, "Asynch fetch fail: " + status + " for " + uri);
             return (uri2 != uri); // Call me again?
         });
         if (sta == 'unrequested') this.requestURI(
@@ -7530,6 +7480,30 @@ $rdf.Fetcher = function(store, timeout, async) {
 
 
 
+    // Look up response header
+    // 
+    // Returns: a list of header values found in a stored HTTP response
+    //      or [] if response was found but no header found
+    //      or undefined if no response is available.
+    //
+    this.getHeader = function(doc, header) {
+        var kb = this.store;
+        var requests = kb.each(undefined, tabulator.ns.link("requestedURI"), doc.uri);
+        for (var r=0; r<requests.length; r++) {
+            request = requests[r];
+            if (request !== undefined) {
+                var response = kb.any(request, tabulator.ns.link("response"));
+                if (request !== undefined) {
+                    var results = kb.each(response, tabulator.ns.httph(header.toLowerCase()));
+                    if (results.length) {
+                        return results.map(function(v){return v.value});
+                    }
+                    return [];
+                }
+            }
+        }
+        return undefined;
+    };
 
 
     /** Requests a document URI and arranges to load the document.
@@ -7679,9 +7653,10 @@ $rdf.Fetcher = function(store, timeout, async) {
                 if ($rdf.uri.protocol(xhr.uri.uri) == 'http' || $rdf.uri.protocol(xhr.uri.uri) == 'https') {
                     xhr.headers = $rdf.Util.getHTTPHeaders(xhr)
                     for (var h in xhr.headers) { // trim below for Safari - adds a CR!
-                        kb.add(response, ns.httph(h), xhr.headers[h].trim(), response)
+                        kb.add(response, ns.httph(h.toLowerCase()), xhr.headers[h].trim(), response)
                     }
                 }
+
                 sf.fireCallbacks('headers', [{uri: docuri, headers: xhr.headers}]);
 
                 if (xhr.status >= 400) { // For extra dignostics, keep the reply
@@ -7754,7 +7729,6 @@ $rdf.Fetcher = function(store, timeout, async) {
                     sf.requested[udoc] = true
                 }
 
-
                 for (var x = 0; x < sf.handlers.length; x++) {
                     if (xhr.headers['content-type'] && xhr.headers['content-type'].match(sf.handlers[x].pattern)) {
                         handler = new sf.handlers[x]()
@@ -7763,7 +7737,10 @@ $rdf.Fetcher = function(store, timeout, async) {
                     }
                 }
 
-                var link = xhr.getResponseHeader('link');
+                var link;
+                try {
+                    link = xhr.getResponseHeader('link');
+                }catch(e){}
                 if (link) {
                     var rel = null;
                     var arg = link.replace(/ /g, '').split(';');
@@ -7781,10 +7758,17 @@ $rdf.Fetcher = function(store, timeout, async) {
 
 
                 if (handler) {
-                    handler.recv(xhr)
+                    try {
+                        handler.handlerFactory(xhr); 
+                    } catch(e) { // Try to avoid silent errors
+                        sf.failFetch(xhr, "Exception handling content-type " + xhr.headers['content-type'] + ' was: '+e);
+                    };
                 } else {
-                    sf.failFetch(xhr, "Unhandled content type: " + xhr.headers['content-type']+
-                            ", readyState = "+xhr.readyState);
+                    sf.doneFetch(xhr, args); //  Not a problem, we just don't extract data.
+                    /*
+                    // sf.failFetch(xhr, "Unhandled content type: " + xhr.headers['content-type']+
+                    //        ", readyState = "+xhr.readyState);
+                    */
                     return;
                 }
             };
@@ -7794,6 +7778,9 @@ $rdf.Fetcher = function(store, timeout, async) {
             // LOADING: 3
             // OPENED: 1
             // UNSENT: 0
+
+            // $rdf.log.debug("web.js: XHR " + xhr.uri.uri + ' readyState='+xhr.readyState); // @@@@ comment me out 
+
             switch (xhr.readyState) {
             case 0:
                     var uri = xhr.uri.uri, newURI;
@@ -7860,8 +7847,10 @@ $rdf.Fetcher = function(store, timeout, async) {
                         sf.doneFetch(xhr, args)
                     })
                 } else {
-                    sf.failFetch(xhr, "HTTP failed unusually. (no handler set) (cross-site violation? no net?) for <"+
-                        docuri+">");
+                    sf.addStatus(xhr.req, "Fetch OK. No known semantics.");
+                    sf.doneFetch(xhr, args);
+                    //sf.failFetch(xhr, "HTTP failed unusually. (no handler set) (x-site violation? no net?) for <"+
+                    //    docuri+">");
                 }    
                 break
             } // switch
@@ -8247,4 +8236,22 @@ $rdf.parse = function parse(str, kb, base, contentType) {
 
 
 // ends
-return $rdf;}()
+
+// Handle node, amd, and global systems
+if (typeof exports !== 'undefined') {
+    if (typeof module !== 'undefined' && module.exports) {
+        exports = module.exports = $rdf;
+    }
+    exports.$rdf = $rdf;
+}
+else {
+    if (typeof define === 'function' && define.amd) {
+        define('rdflib', function() {
+            return $rdf;
+        });
+    }
+
+    // Leak a global regardless of module system
+    root['$rdf'] = $rdf;
+}
+})(this);