rdflib 2.2.9 → 2.2.10-4fa7e876

package/esm/n3parser.js

@@ -1,3 +1,5 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
 import _typeof from "@babel/runtime/helpers/typeof";
 
 /**
@@ -8,216 +10,220 @@ import _typeof from "@babel/runtime/helpers/typeof";
 **/
 import * as Uri from './uri';
 import { ArrayIndexOf } from './utils';
-export default (function () {
-  function hexify(str) {
-    // also used in parser
-    return encodeURI(str);
-  }
 
-  var Utf8 = {
-    // public method for url encoding
-    encode: function encode(string) {
-      string = string.replace(/\r\n/g, "\n");
-      var utftext = "";
+function hexify(str) {
+  // also used in parser
+  return encodeURI(str);
+}
+
+var Utf8 = {
+  // public method for url encoding
+  encode: function encode(string) {
+    string = string.replace(/\r\n/g, "\n");
+    var utftext = "";
+
+    for (var n = 0; n < string.length; n++) {
+      var c = string.charCodeAt(n);
+
+      if (c < 128) {
+        utftext += String.fromCharCode(c);
+      } else if (c > 127 && c < 2048) {
+        utftext += String.fromCharCode(c >> 6 | 192);
+        utftext += String.fromCharCode(c & 63 | 128);
+      } else {
+        utftext += String.fromCharCode(c >> 12 | 224);
+        utftext += String.fromCharCode(c >> 6 & 63 | 128);
+        utftext += String.fromCharCode(c & 63 | 128);
+      }
+    }
+
+    return utftext;
+  },
+  // public method for url decoding
+  decode: function decode(utftext) {
+    var string = "";
+    var i = 0;
 
-      for (var n = 0; n < string.length; n++) {
-        var c = string.charCodeAt(n);
+    while (i < utftext.length) {
+      var c = utftext.charCodeAt(i);
 
-        if (c < 128) {
-          utftext += String.fromCharCode(c);
-        } else if (c > 127 && c < 2048) {
-          utftext += String.fromCharCode(c >> 6 | 192);
-          utftext += String.fromCharCode(c & 63 | 128);
-        } else {
-          utftext += String.fromCharCode(c >> 12 | 224);
-          utftext += String.fromCharCode(c >> 6 & 63 | 128);
-          utftext += String.fromCharCode(c & 63 | 128);
-        }
+      if (c < 128) {
+        string += String.fromCharCode(c);
+        i++;
+      } else if (c > 191 && c < 224) {
+        string += String.fromCharCode((c & 31) << 6 | utftext.charCodeAt(i + 1) & 63);
+        i += 2;
+      } else {
+        string += String.fromCharCode((c & 15) << 12 | (utftext.charCodeAt(i + 1) & 63) << 6 | utftext.charCodeAt(i + 2) & 63);
+        i += 3;
       }
+    }
 
-      return utftext;
-    },
-    // public method for url decoding
-    decode: function decode(utftext) {
-      var string = "";
-      var i = 0;
+    return string;
+  }
+}; // Things we need to define to make converted pythn code work in js
+// environment of $rdf
 
-      while (i < utftext.length) {
-        var c = utftext.charCodeAt(i);
+var RDFSink_forSomeSym = "http://www.w3.org/2000/10/swap/log#forSome";
+var RDFSink_forAllSym = "http://www.w3.org/2000/10/swap/log#forAll";
+var Logic_NS = "http://www.w3.org/2000/10/swap/log#"; //  pyjs seems to reference runtime library which I didn't find
 
-        if (c < 128) {
-          string += String.fromCharCode(c);
-          i++;
-        } else if (c > 191 && c < 224) {
-          string += String.fromCharCode((c & 31) << 6 | utftext.charCodeAt(i + 1) & 63);
-          i += 2;
-        } else {
-          string += String.fromCharCode((c & 15) << 12 | (utftext.charCodeAt(i + 1) & 63) << 6 | utftext.charCodeAt(i + 2) & 63);
-          i += 3;
-        }
-      }
+var pyjslib_Tuple = function pyjslib_Tuple(theList) {
+  return theList;
+};
 
-      return string;
-    }
-  }; // Things we need to define to make converted pythn code work in js
-  // environment of $rdf
+var pyjslib_List = function pyjslib_List(theList) {
+  return theList;
+};
 
-  var RDFSink_forSomeSym = "http://www.w3.org/2000/10/swap/log#forSome";
-  var RDFSink_forAllSym = "http://www.w3.org/2000/10/swap/log#forAll";
-  var Logic_NS = "http://www.w3.org/2000/10/swap/log#"; //  pyjs seems to reference runtime library which I didn't find
+var pyjslib_Dict = function pyjslib_Dict(listOfPairs) {
+  if (listOfPairs.length > 0) throw "missing.js: oops nnonempty dict not imp";
+  return [];
+};
 
-  var pyjslib_Tuple = function pyjslib_Tuple(theList) {
-    return theList;
-  };
+var pyjslib_len = function pyjslib_len(s) {
+  return s.length;
+};
 
-  var pyjslib_List = function pyjslib_List(theList) {
-    return theList;
-  };
+var pyjslib_slice = function pyjslib_slice(str, i, j) {
+  if (typeof str.slice == 'undefined') throw '@@ mising.js: No .slice function for ' + str + ' of type ' + _typeof(str);
+  if (typeof j == 'undefined' || j == null) return str.slice(i);
+  return str.slice(i, j); // @ exactly the same spec?
+};
 
-  var pyjslib_Dict = function pyjslib_Dict(listOfPairs) {
-    if (listOfPairs.length > 0) throw "missing.js: oops nnonempty dict not imp";
-    return [];
-  };
+var StopIteration = Error('dummy error stop iteration');
 
-  var pyjslib_len = function pyjslib_len(s) {
-    return s.length;
-  };
+var pyjslib_Iterator = function pyjslib_Iterator(theList) {
+  this.last = 0;
+  this.li = theList;
 
-  var pyjslib_slice = function pyjslib_slice(str, i, j) {
-    if (typeof str.slice == 'undefined') throw '@@ mising.js: No .slice function for ' + str + ' of type ' + _typeof(str);
-    if (typeof j == 'undefined' || j == null) return str.slice(i);
-    return str.slice(i, j); // @ exactly the same spec?
+  this.next = function () {
+    if (this.last == this.li.length) throw StopIteration;
+    return this.li[this.last++];
   };
 
-  var StopIteration = Error('dummy error stop iteration');
+  return this;
+};
 
-  var pyjslib_Iterator = function pyjslib_Iterator(theList) {
-    this.last = 0;
-    this.li = theList;
+var ord = function ord(str) {
+  return str.charCodeAt(0);
+};
 
-    this.next = function () {
-      if (this.last == this.li.length) throw StopIteration;
-      return this.li[this.last++];
-    };
+var string_find = function string_find(str, s) {
+  return str.indexOf(s);
+};
 
-    return this;
-  };
+var assertFudge = function assertFudge(condition, desc) {
+  if (condition) return;
+  if (desc) throw "python Assertion failed: " + desc;
+  throw "(python) Assertion failed.";
+};
 
-  var ord = function ord(str) {
-    return str.charCodeAt(0);
-  };
+var stringFromCharCode = function stringFromCharCode(uesc) {
+  return String.fromCharCode(uesc);
+};
 
-  var string_find = function string_find(str, s) {
-    return str.indexOf(s);
-  };
+String.prototype.encode = function (encoding) {
+  if (encoding != 'utf-8') throw "UTF8_converter: can only do utf-8";
+  return Utf8.encode(this);
+};
 
-  var assertFudge = function assertFudge(condition, desc) {
-    if (condition) return;
-    if (desc) throw "python Assertion failed: " + desc;
-    throw "(python) Assertion failed.";
-  };
+String.prototype.decode = function (encoding) {
+  if (encoding != 'utf-8') throw "UTF8_converter: can only do utf-8"; //return Utf8.decode(this);
 
-  var stringFromCharCode = function stringFromCharCode(uesc) {
-    return String.fromCharCode(uesc);
-  };
+  return this;
+};
 
-  String.prototype.encode = function (encoding) {
-    if (encoding != 'utf-8') throw "UTF8_converter: can only do utf-8";
-    return Utf8.encode(this);
-  };
+var uripath_join = function uripath_join(base, given) {
+  return Uri.join(given, base); // sad but true
+};
 
-  String.prototype.decode = function (encoding) {
-    if (encoding != 'utf-8') throw "UTF8_converter: can only do utf-8"; //return Utf8.decode(this);
+var becauseSubexpression = null; // No reason needed
 
-    return this;
-  };
+var diag_tracking = 0;
+var diag_chatty_flag = 0;
 
-  var uripath_join = function uripath_join(base, given) {
-    return Uri.join(given, base); // sad but true
-  };
+var diag_progress = function diag_progress(str) {
+  /*$rdf.log.debug(str);*/
+}; // why_BecauseOfData = function(doc, reason) { return doc };
 
-  var becauseSubexpression = null; // No reason needed
 
-  var diag_tracking = 0;
-  var diag_chatty_flag = 0;
+var RDF_type_URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
+var DAML_sameAs_URI = "http://www.w3.org/2002/07/owl#sameAs";
+/*
+function SyntaxError(details) {
+    return new __SyntaxError(details);
+}
+*/
 
-  var diag_progress = function diag_progress(str) {
-    /*$rdf.log.debug(str);*/
-  }; // why_BecauseOfData = function(doc, reason) { return doc };
+function __SyntaxError(details) {
+  this.details = details;
+}
+/*
 
+$Id: n3parser.js 14561 2008-02-23 06:37:26Z kennyluck $
 
-  var RDF_type_URI = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
-  var DAML_sameAs_URI = "http://www.w3.org/2002/07/owl#sameAs";
-  /*
-  function SyntaxError(details) {
-      return new __SyntaxError(details);
-  }
-  */
+HAND EDITED FOR CONVERSION TO JAVASCRIPT
 
-  function __SyntaxError(details) {
-    this.details = details;
-  }
-  /*
-  
-  $Id: n3parser.js 14561 2008-02-23 06:37:26Z kennyluck $
-  
-  HAND EDITED FOR CONVERSION TO JAVASCRIPT
-  
-  This module implements a Nptation3 parser, and the final
-  part of a notation3 serializer.
-  
-  See also:
-  
-  Notation 3
-  http://www.w3.org/DesignIssues/Notation3
-  
-  Closed World Machine - and RDF Processor
-  http://www.w3.org/2000/10/swap/cwm
-  
-  To DO: See also "@@" in comments
-  
-  - Clean up interfaces
-  ______________________________________________
-  
-  Module originally by Dan Connolly, includeing notation3
-  parser and RDF generator. TimBL added RDF stream model
-  and N3 generation, replaced stream model with use
-  of common store/formula API.  Yosi Scharf developped
-  the module, including tests and test harness.
-  
-  */
-
-
-  var ADDED_HASH = "#";
-  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 !\"#$%&'()*.,+/;<=>?@[\\]^`{|}~";
-
-  var _notNameChars = _notQNameChars + ":";
-
-  var _rdfns = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
-  var N3CommentCharacter = "#";
-  var eol = new RegExp("^[ \\t]*(#[^\\n]*)?\\r?\\n", 'g');
-  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');
+This module implements a Nptation3 parser, and the final
+part of a notation3 serializer.
+
+See also:
+
+Notation 3
+http://www.w3.org/DesignIssues/Notation3
 
+Closed World Machine - and RDF Processor
+http://www.w3.org/2000/10/swap/cwm
+
+To DO: See also "@@" in comments
+
+- Clean up interfaces
+______________________________________________
+
+Module originally by Dan Connolly, includeing notation3
+parser and RDF generator. TimBL added RDF stream model
+and N3 generation, replaced stream model with use
+of common store/formula API.  Yosi Scharf developped
+the module, including tests and test harness.
+
+*/
+
+
+var ADDED_HASH = "#";
+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 !\"#$%&'()*.,+/;<=>?@[\\]^`{|}~";
+
+var _notNameChars = _notQNameChars + ":";
+
+var _rdfns = "http://www.w3.org/1999/02/22-rdf-syntax-ns#";
+var N3CommentCharacter = "#";
+var eol = new RegExp("^[ \\t]*(#[^\\n]*)?\\r?\\n", 'g');
+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');
+
+function createSinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why) {
+  return new SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why);
+}
+
+export default createSinkParser;
+export var SinkParser = /*#__PURE__*/function () {
   function SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why) {
-    return new __SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why);
-  }
+    _classCallCheck(this, SinkParser);
 
-  function __SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why) {
     if (typeof openFormula == 'undefined') openFormula = null;
     if (typeof thisDoc == 'undefined') thisDoc = "";
     if (typeof baseURI == 'undefined') baseURI = null;
@@ -296,1515 +302,1553 @@ export default (function () {
     this._parentContext = null;
   }
 
-  __SinkParser.prototype.here = function (i) {
-    return this._genPrefix + "_L" + this.lines + "C" + (i - this.startOfLine + 1);
-  };
-
-  __SinkParser.prototype.formula = function () {
-    return this._formula;
-  };
-
-  __SinkParser.prototype.loadStream = function (stream) {
-    return this.loadBuf(stream.read());
-  };
+  _createClass(SinkParser, [{
+    key: "here",
+    value: function here(i) {
+      return this._genPrefix + "_L" + this.lines + "C" + (i - this.startOfLine + 1);
+    }
+  }, {
+    key: "formula",
+    value: function formula() {
+      return this._formula;
+    }
+  }, {
+    key: "loadStream",
+    value: function loadStream(stream) {
+      return this.loadBuf(stream.read());
+    }
+  }, {
+    key: "loadBuf",
+    value: function loadBuf(buf) {
+      /*
+      Parses a buffer and returns its top level formula*/
+      this.startDoc();
+      this.feed(buf);
+      return this.endDoc();
+    }
+  }, {
+    key: "feed",
+    value: function feed(octets) {
+      /*
+      Feed an octet stream tothe parser
+       if BadSyntax is raised, the string
+      passed in the exception object is the
+      remainder after any statements have been parsed.
+      So if there is more data to feed to the
+      parser, it should be straightforward to recover.*/
+      var str = octets.decode("utf-8");
+      var i = 0;
 
-  __SinkParser.prototype.loadBuf = function (buf) {
-    /*
-    Parses a buffer and returns its top level formula*/
-    this.startDoc();
-    this.feed(buf);
-    return this.endDoc();
-  };
+      while (i >= 0) {
+        var j = this.skipSpace(str, i);
 
-  __SinkParser.prototype.feed = function (octets) {
-    /*
-    Feed an octet stream tothe parser
-     if BadSyntax is raised, the string
-    passed in the exception object is the
-    remainder after any statements have been parsed.
-    So if there is more data to feed to the
-    parser, it should be straightforward to recover.*/
-    var str = octets.decode("utf-8");
-    var i = 0;
+        if (j < 0) {
+          return;
+        }
 
-    while (i >= 0) {
-      var j = this.skipSpace(str, i);
+        var i = this.directiveOrStatement(str, j);
 
-      if (j < 0) {
-        return;
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "expected directive or statement");
+        }
       }
-
-      var i = this.directiveOrStatement(str, j);
+    }
+  }, {
+    key: "directiveOrStatement",
+    value: function directiveOrStatement(str, h) {
+      var i = this.skipSpace(str, h);
 
       if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "expected directive or statement");
+        return i;
       }
-    }
-  };
 
-  __SinkParser.prototype.directiveOrStatement = function (str, h) {
-    var i = this.skipSpace(str, h);
+      var j = this.directive(str, i);
 
-    if (i < 0) {
-      return i;
-    }
-
-    var j = this.directive(str, i);
+      if (j >= 0) {
+        return this.checkDot(str, j);
+      }
 
-    if (j >= 0) {
-      return this.checkDot(str, j);
-    }
+      var j = this.statement(str, i);
 
-    var j = this.statement(str, i);
+      if (j >= 0) {
+        return this.checkDot(str, j);
+      }
 
-    if (j >= 0) {
-      return this.checkDot(str, j);
+      return j;
     }
+  }, {
+    key: "tok",
+    value: function tok(_tok, str, i) {
+      /*
+      Check for keyword.  Space must have been stripped on entry and
+      we must not be at end of file.*/
+      var whitespace = "\t\n\v\f\r ";
 
-    return j;
-  };
+      if (str.slice(i, i + 1) == "@") {
+        var i = i + 1;
+      } else {
+        if (ArrayIndexOf(this.keywords, _tok) < 0) {
+          return -1;
+        }
+      }
 
-  __SinkParser.prototype.tok = function (tok, str, i) {
-    /*
-    Check for keyword.  Space must have been stripped on entry and
-    we must not be at end of file.*/
-    var whitespace = "\t\n\v\f\r ";
+      var k = i + pyjslib_len(_tok);
 
-    if (str.slice(i, i + 1) == "@") {
-      var i = i + 1;
-    } else {
-      if (ArrayIndexOf(this.keywords, tok) < 0) {
+      if (str.slice(i, k) == _tok && _notQNameChars.indexOf(str.charAt(k)) >= 0) {
+        return k;
+      } else {
         return -1;
       }
     }
+  }, {
+    key: "directive",
+    value: function directive(str, i) {
+      var j = this.skipSpace(str, i);
 
-    var k = i + pyjslib_len(tok);
+      if (j < 0) {
+        return j;
+      }
 
-    if (str.slice(i, k) == tok && _notQNameChars.indexOf(str.charAt(k)) >= 0) {
-      return k;
-    } else {
-      return -1;
-    }
-  };
+      var res = new pyjslib_List([]);
+      var j = this.tok("bind", str, i);
 
-  __SinkParser.prototype.directive = function (str, i) {
-    var j = this.skipSpace(str, i);
+      if (j > 0) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "keyword bind is obsolete: use @prefix");
+      }
 
-    if (j < 0) {
-      return j;
-    }
+      var j = this.tok("keywords", str, i);
 
-    var res = new pyjslib_List([]);
-    var j = this.tok("bind", str, i);
+      if (j > 0) {
+        var i = this.commaSeparatedList(str, j, res, false);
 
-    if (j > 0) {
-      throw BadSyntax(this._thisDoc, this.lines, str, i, "keyword bind is obsolete: use @prefix");
-    }
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "'@keywords' needs comma separated list of words");
+        }
 
-    var j = this.tok("keywords", str, i);
+        this.setKeywords(pyjslib_slice(res, null, null));
 
-    if (j > 0) {
-      var i = this.commaSeparatedList(str, j, res, false);
+        if (diag_chatty_flag > 80) {
+          diag_progress("Keywords ", this.keywords);
+        }
 
-      if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "'@keywords' needs comma separated list of words");
+        return i;
       }
 
-      this.setKeywords(pyjslib_slice(res, null, null));
+      var j = this.tok("forAll", str, i);
 
-      if (diag_chatty_flag > 80) {
-        diag_progress("Keywords ", this.keywords);
-      }
+      if (j > 0) {
+        var i = this.commaSeparatedList(str, j, res, true);
 
-      return i;
-    }
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "Bad variable list after @forAll");
+        }
 
-    var j = this.tok("forAll", str, i);
+        var __x = new pyjslib_Iterator(res);
 
-    if (j > 0) {
-      var i = this.commaSeparatedList(str, j, res, true);
+        try {
+          while (true) {
+            var x = __x.next();
 
-      if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "Bad variable list after @forAll");
+            if (ArrayIndexOf(this._variables, x) < 0 || ArrayIndexOf(this._parentVariables, x) >= 0) {
+              this._variables[x] = this._context.newUniversal(x);
+            }
+          }
+        } catch (e) {
+          if (e != StopIteration) {
+            throw e;
+          }
+        }
+
+        return i;
       }
 
-      var __x = new pyjslib_Iterator(res);
+      var j = this.tok("forSome", str, i);
 
-      try {
-        while (true) {
-          var x = __x.next();
+      if (j > 0) {
+        var i = this.commaSeparatedList(str, j, res, this.uri_ref2);
 
-          if (ArrayIndexOf(this._variables, x) < 0 || ArrayIndexOf(this._parentVariables, x) >= 0) {
-            this._variables[x] = this._context.newUniversal(x);
-          }
-        }
-      } catch (e) {
-        if (e != StopIteration) {
-          throw e;
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "Bad variable list after @forSome");
         }
-      }
 
-      return i;
-    }
+        var __x = new pyjslib_Iterator(res);
 
-    var j = this.tok("forSome", str, i);
+        try {
+          while (true) {
+            var x = __x.next();
 
-    if (j > 0) {
-      var i = this.commaSeparatedList(str, j, res, this.uri_ref2);
+            this._context.declareExistential(x);
+          }
+        } catch (e) {
+          if (e != StopIteration) {
+            throw e;
+          }
+        }
 
-      if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "Bad variable list after @forSome");
+        return i;
       }
 
-      var __x = new pyjslib_Iterator(res);
+      var j = this.tok("prefix", str, i);
 
-      try {
-        while (true) {
-          var x = __x.next();
+      if (j >= 0) {
+        var t = new pyjslib_List([]);
+        var i = this.qname(str, j, t);
 
-          this._context.declareExistential(x);
-        }
-      } catch (e) {
-        if (e != StopIteration) {
-          throw e;
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "expected qname after @prefix");
         }
-      }
 
-      return i;
-    }
+        var j = this.uri_ref2(str, i, t);
 
-    var j = this.tok("prefix", str, i);
+        if (j < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "expected <uriref> after @prefix _qname_");
+        }
 
-    if (j >= 0) {
-      var t = new pyjslib_List([]);
-      var i = this.qname(str, j, t);
+        var ns = t[1].uri;
 
-      if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "expected qname after @prefix");
+        if (this._baseURI) {
+          var ns = uripath_join(this._baseURI, ns);
+        } else {
+          assertFudge(ns.indexOf(":") >= 0, "With no base URI, cannot handle relative URI for NS");
+        }
+
+        assertFudge(ns.indexOf(":") >= 0);
+        this._bindings[t[0][0]] = ns;
+        this.bind(t[0][0], hexify(ns));
+        return j;
       }
 
-      var j = this.uri_ref2(str, i, t);
+      var j = this.tok("base", str, i);
 
-      if (j < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "expected <uriref> after @prefix _qname_");
-      }
+      if (j >= 0) {
+        var t = new pyjslib_List([]);
+        var i = this.uri_ref2(str, j, t);
+
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "expected <uri> after @base ");
+        }
 
-      var ns = t[1].uri;
+        var ns = t[0].uri;
 
-      if (this._baseURI) {
-        var ns = uripath_join(this._baseURI, ns);
-      } else {
-        assertFudge(ns.indexOf(":") >= 0, "With no base URI, cannot handle relative URI for NS");
+        if (this._baseURI) {
+          var ns = uripath_join(this._baseURI, ns);
+        } else {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "With no previous base URI, cannot use relative URI in @base  <" + ns + ">");
+        }
+
+        assertFudge(ns.indexOf(":") >= 0);
+        this._baseURI = ns;
+        return i;
       }
 
-      assertFudge(ns.indexOf(":") >= 0);
-      this._bindings[t[0][0]] = ns;
-      this.bind(t[0][0], hexify(ns));
-      return j;
+      return -1;
     }
-
-    var j = this.tok("base", str, i);
-
-    if (j >= 0) {
-      var t = new pyjslib_List([]);
-      var i = this.uri_ref2(str, j, t);
+  }, {
+    key: "bind",
+    value: function bind(qn, uri) {
+      if (qn == "") {} else {
+        this._store.setPrefixForURI(qn, uri);
+      }
+    }
+  }, {
+    key: "setKeywords",
+    value: function setKeywords(k) {
+      /*
+      Takes a list of strings*/
+      if (k == null) {
+        this.keywordsSet = 0;
+      } else {
+        this.keywords = k;
+        this.keywordsSet = 1;
+      }
+    }
+  }, {
+    key: "startDoc",
+    value: function startDoc() {}
+  }, {
+    key: "endDoc",
+    value: function endDoc() {
+      /*
+      Signal end of document and stop parsing. returns formula*/
+      return this._formula;
+    }
+  }, {
+    key: "makeStatement",
+    value: function makeStatement(quad) {
+      quad[0].add(quad[2], quad[1], quad[3], this.source);
+      this.statementCount += 1;
+    }
+  }, {
+    key: "statement",
+    value: function statement(str, i) {
+      var r = new pyjslib_List([]);
+      var i = this.object(str, i, r);
 
       if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "expected <uri> after @base ");
+        return i;
       }
 
-      var ns = t[0].uri;
+      var j = this.property_list(str, i, r[0]);
 
-      if (this._baseURI) {
-        var ns = uripath_join(this._baseURI, ns);
-      } else {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "With no previous base URI, cannot use relative URI in @base  <" + ns + ">");
+      if (j < 0) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "expected propertylist");
       }
 
-      assertFudge(ns.indexOf(":") >= 0);
-      this._baseURI = ns;
-      return i;
+      return j;
     }
+  }, {
+    key: "subject",
+    value: function subject(str, i, res) {
+      return this.item(str, i, res);
+    }
+  }, {
+    key: "verb",
+    value: function verb(str, i, res) {
+      /*
+      has _prop_
+      is _prop_ of
+      a
+      =
+      _prop_
+      >- prop ->
+      <- prop -<
+      _operator_*/
+      var j = this.skipSpace(str, i);
 
-    return -1;
-  };
-
-  __SinkParser.prototype.bind = function (qn, uri) {
-    if (qn == "") {} else {
-      this._store.setPrefixForURI(qn, uri);
-    }
-  };
+      if (j < 0) {
+        return j;
+      }
 
-  __SinkParser.prototype.setKeywords = function (k) {
-    /*
-    Takes a list of strings*/
-    if (k == null) {
-      this.keywordsSet = 0;
-    } else {
-      this.keywords = k;
-      this.keywordsSet = 1;
-    }
-  };
+      var r = new pyjslib_List([]);
+      var j = this.tok("has", str, i);
 
-  __SinkParser.prototype.startDoc = function () {};
+      if (j >= 0) {
+        var i = this.prop(str, j, r);
 
-  __SinkParser.prototype.endDoc = function () {
-    /*
-    Signal end of document and stop parsing. returns formula*/
-    return this._formula;
-  };
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "expected property after 'has'");
+        }
 
-  __SinkParser.prototype.makeStatement = function (quad) {
-    quad[0].add(quad[2], quad[1], quad[3], this.source);
-    this.statementCount += 1;
-  };
+        res.push(new pyjslib_Tuple(["->", r[0]]));
+        return i;
+      }
 
-  __SinkParser.prototype.statement = function (str, i) {
-    var r = new pyjslib_List([]);
-    var i = this.object(str, i, r);
+      var j = this.tok("is", str, i);
 
-    if (i < 0) {
-      return i;
-    }
+      if (j >= 0) {
+        var i = this.prop(str, j, r);
 
-    var j = this.property_list(str, i, r[0]);
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "expected <property> after 'is'");
+        }
 
-    if (j < 0) {
-      throw BadSyntax(this._thisDoc, this.lines, str, i, "expected propertylist");
-    }
+        var j = this.skipSpace(str, i);
 
-    return j;
-  };
+        if (j < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "End of file found, expected property after 'is'");
+          return j;
+        }
 
-  __SinkParser.prototype.subject = function (str, i, res) {
-    return this.item(str, i, res);
-  };
+        var i = j;
+        var j = this.tok("of", str, i);
 
-  __SinkParser.prototype.verb = function (str, i, res) {
-    /*
-    has _prop_
-    is _prop_ of
-    a
-    =
-    _prop_
-    >- prop ->
-    <- prop -<
-    _operator_*/
-    var j = this.skipSpace(str, i);
-
-    if (j < 0) {
-      return j;
-    }
+        if (j < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "expected 'of' after 'is' <prop>");
+        }
 
-    var r = new pyjslib_List([]);
-    var j = this.tok("has", str, i);
+        res.push(new pyjslib_Tuple(["<-", r[0]]));
+        return j;
+      }
 
-    if (j >= 0) {
-      var i = this.prop(str, j, r);
+      var j = this.tok("a", str, i);
 
-      if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "expected property after 'has'");
+      if (j >= 0) {
+        res.push(new pyjslib_Tuple(["->", this._store.sym(RDF_type_URI)]));
+        return j;
       }
 
-      res.push(new pyjslib_Tuple(["->", r[0]]));
-      return i;
-    }
+      if (str.slice(i, i + 2) == "<=") {
+        res.push(new pyjslib_Tuple(["<-", this._store.sym(Logic_NS + "implies")]));
+        return i + 2;
+      }
 
-    var j = this.tok("is", str, i);
+      if (str.slice(i, i + 1) == "=") {
+        if (str.slice(i + 1, i + 2) == ">") {
+          res.push(new pyjslib_Tuple(["->", this._store.sym(Logic_NS + "implies")]));
+          return i + 2;
+        }
 
-    if (j >= 0) {
-      var i = this.prop(str, j, r);
+        res.push(new pyjslib_Tuple(["->", this._store.sym(DAML_sameAs_URI)]));
+        return i + 1;
+      }
 
-      if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "expected <property> after 'is'");
+      if (str.slice(i, i + 2) == ":=") {
+        res.push(new pyjslib_Tuple(["->", Logic_NS + "becomes"]));
+        return i + 2;
       }
 
-      var j = this.skipSpace(str, i);
+      var j = this.prop(str, i, r);
 
-      if (j < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "End of file found, expected property after 'is'");
+      if (j >= 0) {
+        res.push(new pyjslib_Tuple(["->", r[0]]));
         return j;
       }
 
-      var i = j;
-      var j = this.tok("of", str, i);
-
-      if (j < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "expected 'of' after 'is' <prop>");
+      if (str.slice(i, i + 2) == ">-" || str.slice(i, i + 2) == "<-") {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, ">- ... -> syntax is obsolete.");
       }
 
-      res.push(new pyjslib_Tuple(["<-", r[0]]));
-      return j;
-    }
-
-    var j = this.tok("a", str, i);
-
-    if (j >= 0) {
-      res.push(new pyjslib_Tuple(["->", this._store.sym(RDF_type_URI)]));
-      return j;
-    }
-
-    if (str.slice(i, i + 2) == "<=") {
-      res.push(new pyjslib_Tuple(["<-", this._store.sym(Logic_NS + "implies")]));
-      return i + 2;
+      return -1;
     }
+  }, {
+    key: "prop",
+    value: function prop(str, i, res) {
+      return this.item(str, i, res);
+    }
+  }, {
+    key: "item",
+    value: function item(str, i, res) {
+      return this.path(str, i, res);
+    }
+  }, {
+    key: "blankNode",
+    value: function blankNode(uri) {
+      return this._context.bnode(uri, this._reason2);
+    }
+  }, {
+    key: "path",
+    value: function path(str, i, res) {
+      /*
+      Parse the path production.
+      */
+      var j = this.nodeOrLiteral(str, i, res);
 
-    if (str.slice(i, i + 1) == "=") {
-      if (str.slice(i + 1, i + 2) == ">") {
-        res.push(new pyjslib_Tuple(["->", this._store.sym(Logic_NS + "implies")]));
-        return i + 2;
+      if (j < 0) {
+        return j;
       }
 
-      res.push(new pyjslib_Tuple(["->", this._store.sym(DAML_sameAs_URI)]));
-      return i + 1;
-    }
-
-    if (str.slice(i, i + 2) == ":=") {
-      res.push(new pyjslib_Tuple(["->", Logic_NS + "becomes"]));
-      return i + 2;
-    }
-
-    var j = this.prop(str, i, r);
+      while ("!^.".indexOf(str.slice(j, j + 1)) >= 0) {
+        var ch = str.slice(j, j + 1);
 
-    if (j >= 0) {
-      res.push(new pyjslib_Tuple(["->", r[0]]));
-      return j;
-    }
+        if (ch == ".") {
+          var ahead = str.slice(j + 1, j + 2);
 
-    if (str.slice(i, i + 2) == ">-" || str.slice(i, i + 2) == "<-") {
-      throw BadSyntax(this._thisDoc, this.lines, str, j, ">- ... -> syntax is obsolete.");
-    }
+          if (!ahead || _notNameChars.indexOf(ahead) >= 0 && ":?<[{(".indexOf(ahead) < 0) {
+            break;
+          }
+        }
 
-    return -1;
-  };
+        var subj = res.pop();
+        var obj = this.blankNode(this.here(j));
+        var j = this.node(str, j + 1, res);
 
-  __SinkParser.prototype.prop = function (str, i, res) {
-    return this.item(str, i, res);
-  };
+        if (j < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "EOF found in middle of path syntax");
+        }
 
-  __SinkParser.prototype.item = function (str, i, res) {
-    return this.path(str, i, res);
-  };
+        var pred = res.pop();
 
-  __SinkParser.prototype.blankNode = function (uri) {
-    return this._context.bnode(uri, this._reason2);
-  };
+        if (ch == "^") {
+          this.makeStatement(new pyjslib_Tuple([this._context, pred, obj, subj]));
+        } else {
+          this.makeStatement(new pyjslib_Tuple([this._context, pred, subj, obj]));
+        }
 
-  __SinkParser.prototype.path = function (str, i, res) {
-    /*
-    Parse the path production.
-    */
-    var j = this.nodeOrLiteral(str, i, res);
+        res.push(obj);
+      }
 
-    if (j < 0) {
       return j;
     }
+  }, {
+    key: "anonymousNode",
+    value: function anonymousNode(ln) {
+      /*
+      Remember or generate a term for one of these _: anonymous nodes*/
+      var term = this._anonymousNodes[ln];
 
-    while ("!^.".indexOf(str.slice(j, j + 1)) >= 0) {
-      var ch = str.slice(j, j + 1);
+      if (term) {
+        return term;
+      }
 
-      if (ch == ".") {
-        var ahead = str.slice(j + 1, j + 2);
+      var term = this._store.bnode(ln); // var term = this._store.bnode(this._context, this._reason2); eh?
 
-        if (!ahead || _notNameChars.indexOf(ahead) >= 0 && ":?<[{(".indexOf(ahead) < 0) {
-          break;
-        }
-      }
 
-      var subj = res.pop();
-      var obj = this.blankNode(this.here(j));
-      var j = this.node(str, j + 1, res);
+      this._anonymousNodes[ln] = term;
+      return term;
+    }
+  }, {
+    key: "node",
+    value: function node(str, i, res, subjectAlready) {
+      if (typeof subjectAlready == 'undefined') subjectAlready = null;
+      /*
+      Parse the <node> production.
+      Space is now skipped once at the beginning
+      instead of in multipe calls to self.skipSpace().
+      */
+
+      var subj = subjectAlready;
+      var j = this.skipSpace(str, i);
 
       if (j < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "EOF found in middle of path syntax");
+        return j;
       }
 
-      var pred = res.pop();
+      var i = j;
+      var ch = str.slice(i, i + 1);
 
-      if (ch == "^") {
-        this.makeStatement(new pyjslib_Tuple([this._context, pred, obj, subj]));
-      } else {
-        this.makeStatement(new pyjslib_Tuple([this._context, pred, subj, obj]));
-      }
+      if (ch == "[") {
+        var bnodeID = this.here(i);
+        var j = this.skipSpace(str, i + 1);
 
-      res.push(obj);
-    }
+        if (j < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF after '['");
+        }
 
-    return j;
-  };
+        if (str.slice(j, j + 1) == "=") {
+          var i = j + 1;
+          var objs = new pyjslib_List([]);
+          var j = this.objectList(str, i, objs);
 
-  __SinkParser.prototype.anonymousNode = function (ln) {
-    /*
-    Remember or generate a term for one of these _: anonymous nodes*/
-    var term = this._anonymousNodes[ln];
+          if (j >= 0) {
+            var subj = objs[0];
 
-    if (term) {
-      return term;
-    }
+            if (pyjslib_len(objs) > 1) {
+              var __obj = new pyjslib_Iterator(objs);
 
-    var term = this._store.bnode(ln); // var term = this._store.bnode(this._context, this._reason2); eh?
+              try {
+                while (true) {
+                  var obj = __obj.next();
 
+                  this.makeStatement(new pyjslib_Tuple([this._context, this._store.sym(DAML_sameAs_URI), subj, obj]));
+                }
+              } catch (e) {
+                if (e != StopIteration) {
+                  throw e;
+                }
+              }
+            }
 
-    this._anonymousNodes[ln] = term;
-    return term;
-  };
+            var j = this.skipSpace(str, j);
 
-  __SinkParser.prototype.node = function (str, i, res, subjectAlready) {
-    if (typeof subjectAlready == 'undefined') subjectAlready = null;
-    /*
-    Parse the <node> production.
-    Space is now skipped once at the beginning
-    instead of in multipe calls to self.skipSpace().
-    */
+            if (j < 0) {
+              throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF when objectList expected after [ = ");
+            }
 
-    var subj = subjectAlready;
-    var j = this.skipSpace(str, i);
+            if (str.slice(j, j + 1) == ";") {
+              var j = j + 1;
+            }
+          } else {
+            throw BadSyntax(this._thisDoc, this.lines, str, i, "objectList expected after [= ");
+          }
+        }
 
-    if (j < 0) {
-      return j;
-    }
+        if (subj == null) {
+          var subj = this.blankNode(bnodeID);
+        }
 
-    var i = j;
-    var ch = str.slice(i, i + 1);
+        var i = this.property_list(str, j, subj);
 
-    if (ch == "[") {
-      var bnodeID = this.here(i);
-      var j = this.skipSpace(str, i + 1);
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "property_list expected");
+        }
 
-      if (j < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF after '['");
+        var j = this.skipSpace(str, i);
+
+        if (j < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF when ']' expected after [ <propertyList>");
+        }
+
+        if (str.slice(j, j + 1) != "]") {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "']' expected");
+        }
+
+        res.push(subj);
+        return j + 1;
       }
 
-      if (str.slice(j, j + 1) == "=") {
-        var i = j + 1;
-        var objs = new pyjslib_List([]);
-        var j = this.objectList(str, i, objs);
+      if (ch == "{") {
+        var ch2 = str.slice(i + 1, i + 2);
 
-        if (j >= 0) {
-          var subj = objs[0];
+        if (ch2 == "$") {
+          i += 1;
+          var j = i + 1;
+          var mylist = new pyjslib_List([]);
+          var first_run = true;
 
-          if (pyjslib_len(objs) > 1) {
-            var __obj = new pyjslib_Iterator(objs);
+          while (1) {
+            var i = this.skipSpace(str, j);
 
-            try {
-              while (true) {
-                var obj = __obj.next();
+            if (i < 0) {
+              throw BadSyntax(this._thisDoc, this.lines, str, i, "needed '$}', found end.");
+            }
 
-                this.makeStatement(new pyjslib_Tuple([this._context, this._store.sym(DAML_sameAs_URI), subj, obj]));
-              }
-            } catch (e) {
-              if (e != StopIteration) {
-                throw e;
+            if (str.slice(i, i + 2) == "$}") {
+              var j = i + 2;
+              break;
+            }
+
+            if (!first_run) {
+              if (str.slice(i, i + 1) == ",") {
+                i += 1;
+              } else {
+                throw BadSyntax(this._thisDoc, this.lines, str, i, "expected: ','");
               }
+            } else {
+              var first_run = false;
             }
-          }
 
-          var j = this.skipSpace(str, j);
+            var item = new pyjslib_List([]);
+            var j = this.item(str, i, item);
 
-          if (j < 0) {
-            throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF when objectList expected after [ = ");
-          }
+            if (j < 0) {
+              throw BadSyntax(this._thisDoc, this.lines, str, i, "expected item in set or '$}'");
+            }
 
-          if (str.slice(j, j + 1) == ";") {
-            var j = j + 1;
+            mylist.push(item[0]);
           }
+
+          res.push(this._store.newSet(mylist, this._context));
+          return j;
         } else {
-          throw BadSyntax(this._thisDoc, this.lines, str, i, "objectList expected after [= ");
-        }
-      }
+          var j = i + 1;
+          var oldParentContext = this._parentContext;
+          this._parentContext = this._context;
+          var parentAnonymousNodes = this._anonymousNodes;
+          var grandParentVariables = this._parentVariables;
+          this._parentVariables = this._variables;
+          this._anonymousNodes = new pyjslib_Dict([]);
+          this._variables = this._variables.slice();
+          var reason2 = this._reason2;
+          this._reason2 = becauseSubexpression;
+
+          if (subj == null) {
+            var subj = this._store.formula();
+          }
 
-      if (subj == null) {
-        var subj = this.blankNode(bnodeID);
-      }
+          this._context = subj;
 
-      var i = this.property_list(str, j, subj);
+          while (1) {
+            var i = this.skipSpace(str, j);
 
-      if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "property_list expected");
-      }
+            if (i < 0) {
+              throw BadSyntax(this._thisDoc, this.lines, str, i, "needed '}', found end.");
+            }
 
-      var j = this.skipSpace(str, i);
+            if (str.slice(i, i + 1) == "}") {
+              var j = i + 1;
+              break;
+            }
 
-      if (j < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF when ']' expected after [ <propertyList>");
-      }
+            var j = this.directiveOrStatement(str, i);
+
+            if (j < 0) {
+              throw BadSyntax(this._thisDoc, this.lines, str, i, "expected statement or '}'");
+            }
+          }
 
-      if (str.slice(j, j + 1) != "]") {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "']' expected");
+          this._anonymousNodes = parentAnonymousNodes;
+          this._variables = this._parentVariables;
+          this._parentVariables = grandParentVariables;
+          this._context = this._parentContext;
+          this._reason2 = reason2;
+          this._parentContext = oldParentContext;
+          res.push(subj.close());
+          return j;
+        }
       }
 
-      res.push(subj);
-      return j + 1;
-    }
+      if (ch == "(") {
+        var thing_type = this._store.list;
+        var ch2 = str.slice(i + 1, i + 2);
 
-    if (ch == "{") {
-      var ch2 = str.slice(i + 1, i + 2);
+        if (ch2 == "$") {
+          var thing_type = this._store.newSet;
+          i += 1;
+        }
 
-      if (ch2 == "$") {
-        i += 1;
         var j = i + 1;
         var mylist = new pyjslib_List([]);
-        var first_run = true;
 
         while (1) {
           var i = this.skipSpace(str, j);
 
           if (i < 0) {
-            throw BadSyntax(this._thisDoc, this.lines, str, i, "needed '$}', found end.");
+            throw BadSyntax(this._thisDoc, this.lines, str, i, "needed ')', found end.");
           }
 
-          if (str.slice(i, i + 2) == "$}") {
-            var j = i + 2;
+          if (str.slice(i, i + 1) == ")") {
+            var j = i + 1;
             break;
           }
 
-          if (!first_run) {
-            if (str.slice(i, i + 1) == ",") {
-              i += 1;
-            } else {
-              throw BadSyntax(this._thisDoc, this.lines, str, i, "expected: ','");
-            }
-          } else {
-            var first_run = false;
-          }
-
           var item = new pyjslib_List([]);
           var j = this.item(str, i, item);
 
           if (j < 0) {
-            throw BadSyntax(this._thisDoc, this.lines, str, i, "expected item in set or '$}'");
+            throw BadSyntax(this._thisDoc, this.lines, str, i, "expected item in list or ')'");
           }
 
           mylist.push(item[0]);
         }
 
-        res.push(this._store.newSet(mylist, this._context));
+        res.push(thing_type(mylist, this._context));
         return j;
-      } else {
-        var j = i + 1;
-        var oldParentContext = this._parentContext;
-        this._parentContext = this._context;
-        var parentAnonymousNodes = this._anonymousNodes;
-        var grandParentVariables = this._parentVariables;
-        this._parentVariables = this._variables;
-        this._anonymousNodes = new pyjslib_Dict([]);
-        this._variables = this._variables.slice();
-        var reason2 = this._reason2;
-        this._reason2 = becauseSubexpression;
-
-        if (subj == null) {
-          var subj = this._store.formula();
-        }
-
-        this._context = subj;
+      }
 
-        while (1) {
-          var i = this.skipSpace(str, j);
+      var j = this.tok("this", str, i);
 
-          if (i < 0) {
-            throw BadSyntax(this._thisDoc, this.lines, str, i, "needed '}', found end.");
-          }
+      if (j >= 0) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "Keyword 'this' was ancient N3. Now use @forSome and @forAll keywords.");
+        res.push(this._context);
+        return j;
+      }
 
-          if (str.slice(i, i + 1) == "}") {
-            var j = i + 1;
-            break;
-          }
+      var j = this.tok("true", str, i);
 
-          var j = this.directiveOrStatement(str, i);
+      if (j >= 0) {
+        res.push(true);
+        return j;
+      }
 
-          if (j < 0) {
-            throw BadSyntax(this._thisDoc, this.lines, str, i, "expected statement or '}'");
-          }
-        }
+      var j = this.tok("false", str, i);
 
-        this._anonymousNodes = parentAnonymousNodes;
-        this._variables = this._parentVariables;
-        this._parentVariables = grandParentVariables;
-        this._context = this._parentContext;
-        this._reason2 = reason2;
-        this._parentContext = oldParentContext;
-        res.push(subj.close());
+      if (j >= 0) {
+        res.push(false);
         return j;
       }
-    }
 
-    if (ch == "(") {
-      var thing_type = this._store.list;
-      var ch2 = str.slice(i + 1, i + 2);
+      if (subj == null) {
+        var j = this.uri_ref2(str, i, res);
 
-      if (ch2 == "$") {
-        var thing_type = this._store.newSet;
-        i += 1;
+        if (j >= 0) {
+          return j;
+        }
       }
 
-      var j = i + 1;
-      var mylist = new pyjslib_List([]);
-
+      return -1;
+    }
+  }, {
+    key: "property_list",
+    value: function property_list(str, i, subj) {
+      /*
+      Parse property list
+      Leaves the terminating punctuation in the buffer
+      */
       while (1) {
-        var i = this.skipSpace(str, j);
+        var j = this.skipSpace(str, i);
 
-        if (i < 0) {
-          throw BadSyntax(this._thisDoc, this.lines, str, i, "needed ')', found end.");
+        if (j < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF found when expected verb in property list");
+          return j;
         }
 
-        if (str.slice(i, i + 1) == ")") {
-          var j = i + 1;
-          break;
+        if (str.slice(j, j + 2) == ":-") {
+          var i = j + 2;
+          var res = new pyjslib_List([]);
+          var j = this.node(str, i, res, subj);
+
+          if (j < 0) {
+            throw BadSyntax(this._thisDoc, this.lines, str, i, "bad {} or () or [] node after :- ");
+          }
+
+          var i = j;
+          continue;
         }
 
-        var item = new pyjslib_List([]);
-        var j = this.item(str, i, item);
+        var i = j;
+        var v = new pyjslib_List([]);
+        var j = this.verb(str, i, v);
 
-        if (j < 0) {
-          throw BadSyntax(this._thisDoc, this.lines, str, i, "expected item in list or ')'");
+        if (j <= 0) {
+          return i;
         }
 
-        mylist.push(item[0]);
-      }
+        var objs = new pyjslib_List([]);
+        var i = this.objectList(str, j, objs);
 
-      res.push(thing_type(mylist, this._context));
-      return j;
-    }
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "objectList expected");
+        }
 
-    var j = this.tok("this", str, i);
+        var __obj = new pyjslib_Iterator(objs);
 
-    if (j >= 0) {
-      throw BadSyntax(this._thisDoc, this.lines, str, i, "Keyword 'this' was ancient N3. Now use @forSome and @forAll keywords.");
-      res.push(this._context);
-      return j;
-    }
+        try {
+          while (true) {
+            var obj = __obj.next();
 
-    var j = this.tok("true", str, i);
+            var pairFudge = v[0];
+            var dir = pairFudge[0];
+            var sym = pairFudge[1];
 
-    if (j >= 0) {
-      res.push(true);
-      return j;
-    }
+            if (dir == "->") {
+              this.makeStatement(new pyjslib_Tuple([this._context, sym, subj, obj]));
+            } else {
+              this.makeStatement(new pyjslib_Tuple([this._context, sym, obj, subj]));
+            }
+          }
+        } catch (e) {
+          if (e != StopIteration) {
+            throw e;
+          }
+        }
 
-    var j = this.tok("false", str, i);
+        var j = this.skipSpace(str, i);
 
-    if (j >= 0) {
-      res.push(false);
-      return j;
-    }
+        if (j < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "EOF found in list of objects");
+          return j;
+        }
 
-    if (subj == null) {
-      var j = this.uri_ref2(str, i, res);
+        if (str.slice(i, i + 1) != ";") {
+          return i;
+        }
 
-      if (j >= 0) {
-        return j;
+        var i = i + 1;
       }
     }
+  }, {
+    key: "commaSeparatedList",
+    value: function commaSeparatedList(str, j, res, ofUris) {
+      /*
+      return value: -1 bad syntax; >1 new position in str
+      res has things found appended
+       Used to use a final value of the function to be called, e.g. this.bareWord
+      but passing the function didn't work fo js converion pyjs
+      */
+      var i = this.skipSpace(str, j);
 
-    return -1;
-  };
-
-  __SinkParser.prototype.property_list = function (str, i, subj) {
-    /*
-    Parse property list
-    Leaves the terminating punctuation in the buffer
-    */
-    while (1) {
-      var j = this.skipSpace(str, i);
-
-      if (j < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF found when expected verb in property list");
-        return j;
+      if (i < 0) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF found expecting comma sep list");
+        return i;
       }
 
-      if (str.slice(j, j + 2) == ":-") {
-        var i = j + 2;
-        var res = new pyjslib_List([]);
-        var j = this.node(str, i, res, subj);
-
-        if (j < 0) {
-          throw BadSyntax(this._thisDoc, this.lines, str, i, "bad {} or () or [] node after :- ");
-        }
-
-        var i = j;
-        continue;
+      if (str.charAt(i) == ".") {
+        return j;
       }
 
-      var i = j;
-      var v = new pyjslib_List([]);
-      var j = this.verb(str, i, v);
-
-      if (j <= 0) {
-        return i;
+      if (ofUris) {
+        var i = this.uri_ref2(str, i, res);
+      } else {
+        var i = this.bareWord(str, i, res);
       }
 
-      var objs = new pyjslib_List([]);
-      var i = this.objectList(str, j, objs);
-
       if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "objectList expected");
+        return -1;
       }
 
-      var __obj = new pyjslib_Iterator(objs);
+      while (1) {
+        var j = this.skipSpace(str, i);
 
-      try {
-        while (true) {
-          var obj = __obj.next();
+        if (j < 0) {
+          return j;
+        }
 
-          var pairFudge = v[0];
-          var dir = pairFudge[0];
-          var sym = pairFudge[1];
+        var ch = str.slice(j, j + 1);
 
-          if (dir == "->") {
-            this.makeStatement(new pyjslib_Tuple([this._context, sym, subj, obj]));
-          } else {
-            this.makeStatement(new pyjslib_Tuple([this._context, sym, obj, subj]));
+        if (ch != ",") {
+          if (ch != ".") {
+            return -1;
           }
+
+          return j;
         }
-      } catch (e) {
-        if (e != StopIteration) {
-          throw e;
-        }
-      }
 
-      var j = this.skipSpace(str, i);
+        if (ofUris) {
+          var i = this.uri_ref2(str, j + 1, res);
+        } else {
+          var i = this.bareWord(str, j + 1, res);
+        }
 
-      if (j < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "EOF found in list of objects");
-        return j;
+        if (i < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "bad list content");
+          return i;
+        }
       }
+    }
+  }, {
+    key: "objectList",
+    value: function objectList(str, i, res) {
+      var i = this.object(str, i, res);
 
-      if (str.slice(i, i + 1) != ";") {
-        return i;
+      if (i < 0) {
+        return -1;
       }
 
-      var i = i + 1;
-    }
-  };
+      while (1) {
+        var j = this.skipSpace(str, i);
 
-  __SinkParser.prototype.commaSeparatedList = function (str, j, res, ofUris) {
-    /*
-    return value: -1 bad syntax; >1 new position in str
-    res has things found appended
-     Used to use a final value of the function to be called, e.g. this.bareWord
-    but passing the function didn't work fo js converion pyjs
-    */
-    var i = this.skipSpace(str, j);
-
-    if (i < 0) {
-      throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF found expecting comma sep list");
-      return i;
-    }
+        if (j < 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, j, "EOF found after object");
+          return j;
+        }
 
-    if (str.charAt(i) == ".") {
-      return j;
-    }
+        if (str.slice(j, j + 1) != ",") {
+          return j;
+        }
 
-    if (ofUris) {
-      var i = this.uri_ref2(str, i, res);
-    } else {
-      var i = this.bareWord(str, i, res);
-    }
+        var i = this.object(str, j + 1, res);
 
-    if (i < 0) {
-      return -1;
+        if (i < 0) {
+          return i;
+        }
+      }
     }
-
-    while (1) {
+  }, {
+    key: "checkDot",
+    value: function checkDot(str, i) {
       var j = this.skipSpace(str, i);
 
       if (j < 0) {
         return j;
       }
 
-      var ch = str.slice(j, j + 1);
-
-      if (ch != ",") {
-        if (ch != ".") {
-          return -1;
-        }
+      if (str.slice(j, j + 1) == ".") {
+        return j + 1;
+      }
 
+      if (str.slice(j, j + 1) == "}") {
         return j;
       }
 
-      if (ofUris) {
-        var i = this.uri_ref2(str, j + 1, res);
-      } else {
-        var i = this.bareWord(str, j + 1, res);
+      if (str.slice(j, j + 1) == "]") {
+        return j;
       }
 
-      if (i < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "bad list content");
-        return i;
-      }
+      throw BadSyntax(this._thisDoc, this.lines, str, j, "expected '.' or '}' or ']' at end of statement");
+      return i;
     }
-  };
+  }, {
+    key: "uri_ref2",
+    value: function uri_ref2(str, i, res) {
+      /*
+      Generate uri from n3 representation.
+       Note that the RDF convention of directly concatenating
+      NS and local name is now used though I prefer inserting a '#'
+      to make the namesapces look more like what XML folks expect.
+      */
+      var qn = new pyjslib_List([]);
+      var j = this.qname(str, i, qn);
 
-  __SinkParser.prototype.objectList = function (str, i, res) {
-    var i = this.object(str, i, res);
+      if (j >= 0) {
+        var pairFudge = qn[0];
+        var pfx = pairFudge[0];
+        var ln = pairFudge[1];
 
-    if (i < 0) {
-      return -1;
-    }
+        if (pfx == null) {
+          assertFudge(0, "not used?");
+          var ns = this._baseURI + ADDED_HASH;
+        } else {
+          var ns = this._bindings[pfx];
 
-    while (1) {
-      var j = this.skipSpace(str, i);
+          if (!ns) {
+            if (pfx == "_") {
+              res.push(this.anonymousNode(ln));
+              return j;
+            }
 
-      if (j < 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, j, "EOF found after object");
-        return j;
-      }
+            throw BadSyntax(this._thisDoc, this.lines, str, i, "Prefix " + pfx + " not bound.");
+          }
+        }
+
+        var symb = this._store.sym(ns + ln);
+
+        if (ArrayIndexOf(this._variables, symb) >= 0) {
+          res.push(this._variables[symb]);
+        } else {
+          res.push(symb);
+        }
 
-      if (str.slice(j, j + 1) != ",") {
         return j;
       }
 
-      var i = this.object(str, j + 1, res);
+      var i = this.skipSpace(str, i);
 
       if (i < 0) {
-        return i;
+        return -1;
       }
-    }
-  };
 
-  __SinkParser.prototype.checkDot = function (str, i) {
-    var j = this.skipSpace(str, i);
+      if (str.charAt(i) == "?") {
+        var v = new pyjslib_List([]);
+        var j = this.variable(str, i, v);
 
-    if (j < 0) {
-      return j;
-    }
-
-    if (str.slice(j, j + 1) == ".") {
-      return j + 1;
-    }
+        if (j > 0) {
+          res.push(v[0]);
+          return j;
+        }
 
-    if (str.slice(j, j + 1) == "}") {
-      return j;
-    }
+        return -1;
+      } else if (str.charAt(i) == "<") {
+        var i = i + 1;
+        var st = i;
 
-    if (str.slice(j, j + 1) == "]") {
-      return j;
-    }
+        while (i < pyjslib_len(str)) {
+          if (str.charAt(i) == ">") {
+            var uref = str.slice(st, i);
 
-    throw BadSyntax(this._thisDoc, this.lines, str, j, "expected '.' or '}' or ']' at end of statement");
-    return i;
-  };
+            if (this._baseURI) {
+              var uref = uripath_join(this._baseURI, uref);
+            } else {
+              assertFudge(uref.indexOf(":") >= 0, "With no base URI, cannot deal with relative URIs");
+            }
 
-  __SinkParser.prototype.uri_ref2 = function (str, i, res) {
-    /*
-    Generate uri from n3 representation.
-     Note that the RDF convention of directly concatenating
-    NS and local name is now used though I prefer inserting a '#'
-    to make the namesapces look more like what XML folks expect.
-    */
-    var qn = new pyjslib_List([]);
-    var j = this.qname(str, i, qn);
-
-    if (j >= 0) {
-      var pairFudge = qn[0];
-      var pfx = pairFudge[0];
-      var ln = pairFudge[1];
-
-      if (pfx == null) {
-        assertFudge(0, "not used?");
-        var ns = this._baseURI + ADDED_HASH;
-      } else {
-        var ns = this._bindings[pfx];
+            if (str.slice(i - 1, i) == "#" && !(pyjslib_slice(uref, -1, null) == "#")) {
+              var uref = uref + "#";
+            }
 
-        if (!ns) {
-          if (pfx == "_") {
-            res.push(this.anonymousNode(ln));
-            return j;
-          }
+            var symb = this._store.sym(uref);
 
-          throw BadSyntax(this._thisDoc, this.lines, str, i, "Prefix " + pfx + " not bound.");
-        }
-      }
-
-      var symb = this._store.sym(ns + ln);
+            if (ArrayIndexOf(this._variables, symb) >= 0) {
+              res.push(this._variables[symb]);
+            } else {
+              res.push(symb);
+            }
 
-      if (ArrayIndexOf(this._variables, symb) >= 0) {
-        res.push(this._variables[symb]);
-      } else {
-        res.push(symb);
-      }
+            return i + 1;
+          }
 
-      return j;
-    }
+          var i = i + 1;
+        }
 
-    var i = this.skipSpace(str, i);
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "unterminated URI reference");
+      } else if (this.keywordsSet) {
+        var v = new pyjslib_List([]);
+        var j = this.bareWord(str, i, v);
 
-    if (i < 0) {
-      return -1;
-    }
+        if (j < 0) {
+          return -1;
+        }
 
-    if (str.charAt(i) == "?") {
-      var v = new pyjslib_List([]);
-      var j = this.variable(str, i, v);
+        if (ArrayIndexOf(this.keywords, v[0]) >= 0) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "Keyword \"" + v[0] + "\" not allowed here.");
+        }
 
-      if (j > 0) {
-        res.push(v[0]);
+        res.push(this._store.sym(this._bindings[""] + v[0]));
         return j;
+      } else {
+        return -1;
       }
+    }
+  }, {
+    key: "skipSpace",
+    value: function skipSpace(str, i) {
+      /*
+      Skip white space, newlines and comments.
+      return -1 if EOF, else position of first non-ws character*/
+      var whitespace = " \n\r\t\f\x0B\xA0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u200B\u2028\u2029\u3000";
+
+      for (var j = i ? i : 0; j < str.length; j++) {
+        var ch = str.charAt(j); // console.log("    skipspace j= "+j + " i= " + i + " n= " + str.length);
+        // console.log(" skipspace ch <" + ch + ">");
+
+        if (whitespace.indexOf(ch) < 0) {
+          //not ws
+          // console.log(" skipspace 2 ch <" + ch + ">");
+          if (str.charAt(j) === '#') {
+            for (;; j++) {
+              // console.log("    skipspace2 j= "+j + " i= " + i + " n= " + str.length);
+              if (j === str.length) {
+                return -1; // EOF
+              }
 
-      return -1;
-    } else if (str.charAt(i) == "<") {
-      var i = i + 1;
-      var st = i;
-
-      while (i < pyjslib_len(str)) {
-        if (str.charAt(i) == ">") {
-          var uref = str.slice(st, i);
+              if (str.charAt(j) === '\n') {
+                this.lines = this.lines + 1;
+                break;
+              }
+            }
 
-          if (this._baseURI) {
-            var uref = uripath_join(this._baseURI, uref);
+            ;
           } else {
-            assertFudge(uref.indexOf(":") >= 0, "With no base URI, cannot deal with relative URIs");
-          }
-
-          if (str.slice(i - 1, i) == "#" && !(pyjslib_slice(uref, -1, null) == "#")) {
-            var uref = uref + "#";
+            // Not hash - something interesting
+            // console.log(" skipspace 3 ch <" + ch + ">");
+            return j;
           }
-
-          var symb = this._store.sym(uref);
-
-          if (ArrayIndexOf(this._variables, symb) >= 0) {
-            res.push(this._variables[symb]);
-          } else {
-            res.push(symb);
+        } else {
+          // Whitespace
+          // console.log(" skipspace 5 ch <" + ch + ">");
+          if (str.charAt(j) === '\n') {
+            this.lines = this.lines + 1;
           }
-
-          return i + 1;
         }
+      } // next j
 
-        var i = i + 1;
-      }
 
-      throw BadSyntax(this._thisDoc, this.lines, str, j, "unterminated URI reference");
-    } else if (this.keywordsSet) {
-      var v = new pyjslib_List([]);
-      var j = this.bareWord(str, i, v);
+      return -1; // EOF
+    }
+  }, {
+    key: "variable",
+    value: function variable(str, i, res) {
+      /*
+      ?abc -> variable(:abc)
+      */
+      var j = this.skipSpace(str, i);
 
       if (j < 0) {
         return -1;
       }
 
-      if (ArrayIndexOf(this.keywords, v[0]) >= 0) {
-        throw BadSyntax(this._thisDoc, this.lines, str, i, "Keyword \"" + v[0] + "\" not allowed here.");
+      if (str.slice(j, j + 1) != "?") {
+        return -1;
       }
 
-      res.push(this._store.sym(this._bindings[""] + v[0]));
-      return j;
-    } else {
-      return -1;
-    }
-  };
-
-  __SinkParser.prototype.skipSpace = function (str, i) {
-    /*
-    Skip white space, newlines and comments.
-    return -1 if EOF, else position of first non-ws character*/
-    var whitespace = " \n\r\t\f\x0B\xA0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u200B\u2028\u2029\u3000";
-
-    for (var j = i ? i : 0; j < str.length; j++) {
-      var ch = str.charAt(j); // console.log("    skipspace j= "+j + " i= " + i + " n= " + str.length);
-      // console.log(" skipspace ch <" + ch + ">");
-
-      if (whitespace.indexOf(ch) < 0) {
-        //not ws
-        // console.log(" skipspace 2 ch <" + ch + ">");
-        if (str.charAt(j) === '#') {
-          for (;; j++) {
-            // console.log("    skipspace2 j= "+j + " i= " + i + " n= " + str.length);
-            if (j === str.length) {
-              return -1; // EOF
-            }
-
-            if (str.charAt(j) === '\n') {
-              this.lines = this.lines + 1;
-              break;
-            }
-          }
+      var j = j + 1;
+      var i = j;
 
-          ;
-        } else {
-          // Not hash - something interesting
-          // console.log(" skipspace 3 ch <" + ch + ">");
-          return j;
-        }
-      } else {
-        // Whitespace
-        // console.log(" skipspace 5 ch <" + ch + ">");
-        if (str.charAt(j) === '\n') {
-          this.lines = this.lines + 1;
-        }
+      if ("0123456789-".indexOf(str.charAt(j)) >= 0) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "Varible name can't start with '" + str.charAt(j) + "s'");
+        return -1;
       }
-    } // next j
-
-
-    return -1; // EOF
-  };
 
-  __SinkParser.prototype.variable = function (str, i, res) {
-    /*
-    ?abc -> variable(:abc)
-    */
-    var j = this.skipSpace(str, i);
-
-    if (j < 0) {
-      return -1;
-    }
-
-    if (str.slice(j, j + 1) != "?") {
-      return -1;
-    }
-
-    var j = j + 1;
-    var i = j;
-
-    if ("0123456789-".indexOf(str.charAt(j)) >= 0) {
-      throw BadSyntax(this._thisDoc, this.lines, str, j, "Varible name can't start with '" + str.charAt(j) + "s'");
-      return -1;
-    }
+      while (i < pyjslib_len(str) && _notNameChars.indexOf(str.charAt(i)) < 0) {
+        var i = i + 1;
+      }
 
-    while (i < pyjslib_len(str) && _notNameChars.indexOf(str.charAt(i)) < 0) {
-      var i = i + 1;
-    }
+      if (this._parentContext == null) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "Can't use ?xxx syntax for variable in outermost level: " + str.slice(j - 1, i));
+      }
 
-    if (this._parentContext == null) {
-      throw BadSyntax(this._thisDoc, this.lines, str, j, "Can't use ?xxx syntax for variable in outermost level: " + str.slice(j - 1, i));
+      res.push(this._store.variable(str.slice(j, i)));
+      return i;
     }
+  }, {
+    key: "bareWord",
+    value: function bareWord(str, i, res) {
+      /*
+      abc -> :abc
+      */
+      var j = this.skipSpace(str, i);
 
-    res.push(this._store.variable(str.slice(j, i)));
-    return i;
-  };
-
-  __SinkParser.prototype.bareWord = function (str, i, res) {
-    /*
-    abc -> :abc
-    */
-    var j = this.skipSpace(str, i);
+      if (j < 0) {
+        return -1;
+      }
 
-    if (j < 0) {
-      return -1;
-    }
+      var ch = str.charAt(j);
 
-    var ch = str.charAt(j);
+      if ("0123456789-".indexOf(ch) >= 0) {
+        return -1;
+      }
 
-    if ("0123456789-".indexOf(ch) >= 0) {
-      return -1;
-    }
+      if (_notNameChars.indexOf(ch) >= 0) {
+        return -1;
+      }
 
-    if (_notNameChars.indexOf(ch) >= 0) {
-      return -1;
-    }
+      var i = j;
 
-    var i = j;
+      while (i < pyjslib_len(str) && _notNameChars.indexOf(str.charAt(i)) < 0) {
+        var i = i + 1;
+      }
 
-    while (i < pyjslib_len(str) && _notNameChars.indexOf(str.charAt(i)) < 0) {
-      var i = i + 1;
+      res.push(str.slice(j, i));
+      return i;
     }
+  }, {
+    key: "qname",
+    value: function qname(str, i, res) {
+      /*
+       xyz:def -> ('xyz', 'def')
+      If not in keywords and keywordsSet: def -> ('', 'def')
+      :def -> ('', 'def')
+      */
+      var i = this.skipSpace(str, i);
 
-    res.push(str.slice(j, i));
-    return i;
-  };
-
-  __SinkParser.prototype.qname = function (str, i, res) {
-    /*
-     xyz:def -> ('xyz', 'def')
-    If not in keywords and keywordsSet: def -> ('', 'def')
-    :def -> ('', 'def')
-    */
-    var i = this.skipSpace(str, i);
-
-    if (i < 0) {
-      return -1;
-    }
+      if (i < 0) {
+        return -1;
+      }
 
-    var c = str.charAt(i);
+      var c = str.charAt(i);
 
-    if ("0123456789-+".indexOf(c) >= 0) {
-      return -1;
-    }
+      if ("0123456789-+".indexOf(c) >= 0) {
+        return -1;
+      }
 
-    if (_notNameChars.indexOf(c) < 0) {
-      var ln = c;
-      var i = i + 1;
+      if (_notNameChars.indexOf(c) < 0) {
+        var ln = c;
+        var i = i + 1;
 
-      while (i < pyjslib_len(str)) {
-        var c = str.charAt(i);
+        while (i < pyjslib_len(str)) {
+          var c = str.charAt(i);
 
-        if (_notNameChars.indexOf(c) < 0) {
-          var ln = ln + c;
-          var i = i + 1;
-        } else {
-          break;
+          if (_notNameChars.indexOf(c) < 0) {
+            var ln = ln + c;
+            var i = i + 1;
+          } else {
+            break;
+          }
         }
+      } else {
+        var ln = "";
       }
-    } else {
-      var ln = "";
-    }
 
-    if (i < pyjslib_len(str) && str.charAt(i) == ":") {
-      var pfx = ln;
-      var i = i + 1;
-      var ln = "";
+      if (i < pyjslib_len(str) && str.charAt(i) == ":") {
+        var pfx = ln;
+        var i = i + 1;
+        var ln = "";
 
-      while (i < pyjslib_len(str)) {
-        var c = str.charAt(i);
+        while (i < pyjslib_len(str)) {
+          var c = str.charAt(i);
 
-        if (_notNameChars.indexOf(c) < 0) {
-          var ln = ln + c;
-          var i = i + 1;
-        } else {
-          break;
+          if (_notNameChars.indexOf(c) < 0) {
+            var ln = ln + c;
+            var i = i + 1;
+          } else {
+            break;
+          }
         }
-      }
 
-      res.push(new pyjslib_Tuple([pfx, ln]));
-      return i;
-    } else {
-      if (ln && this.keywordsSet && ArrayIndexOf(this.keywords, ln) < 0) {
-        res.push(new pyjslib_Tuple(["", ln]));
+        res.push(new pyjslib_Tuple([pfx, ln]));
         return i;
-      }
+      } else {
+        if (ln && this.keywordsSet && ArrayIndexOf(this.keywords, ln) < 0) {
+          res.push(new pyjslib_Tuple(["", ln]));
+          return i;
+        }
 
-      return -1;
+        return -1;
+      }
     }
-  };
+  }, {
+    key: "object",
+    value: function object(str, i, res) {
+      var j = this.subject(str, i, res);
 
-  __SinkParser.prototype.object = function (str, i, res) {
-    var j = this.subject(str, i, res);
+      if (j >= 0) {
+        return j;
+      } else {
+        var j = this.skipSpace(str, i);
 
-    if (j >= 0) {
-      return j;
-    } else {
-      var j = this.skipSpace(str, i);
+        if (j < 0) {
+          return -1;
+        } else {
+          var i = j;
+        }
 
-      if (j < 0) {
-        return -1;
-      } else {
-        var i = j;
-      }
+        var delim = null;
+        var ch = str.charAt(i);
 
-      var delim = null;
-      var ch = str.charAt(i);
+        if (ch == "\"" || ch == "'") {
+          if (str.slice(i, i + 3 == ch + ch)) {
+            delim = ch + ch + ch;
+          } else {
+            delim = ch;
+          }
 
-      if (ch == "\"" || ch == "'") {
-        if (str.slice(i, i + 3 == ch + ch)) {
-          delim = ch + ch + ch;
+          var i = i + pyjslib_len(delim);
+          var pairFudge = this.strconst(str, i, delim);
+          var j = pairFudge[0];
+          var s = pairFudge[1];
+          res.push(this._store.literal(s));
+          diag_progress("New string const ", s, j);
+          return j;
         } else {
-          delim = ch;
+          return -1;
         }
+      }
+    }
+  }, {
+    key: "nodeOrLiteral",
+    value: function nodeOrLiteral(str, i, res) {
+      var j = this.node(str, i, res);
 
-        var i = i + pyjslib_len(delim);
-        var pairFudge = this.strconst(str, i, delim);
-        var j = pairFudge[0];
-        var s = pairFudge[1];
-        res.push(this._store.literal(s));
-        diag_progress("New string const ", s, j);
+      if (j >= 0) {
         return j;
       } else {
-        return -1;
-      }
-    }
-  };
+        var j = this.skipSpace(str, i);
 
-  __SinkParser.prototype.nodeOrLiteral = function (str, i, res) {
-    var j = this.node(str, i, res);
+        if (j < 0) {
+          return -1;
+        } else {
+          var i = j;
+        }
 
-    if (j >= 0) {
-      return j;
-    } else {
-      var j = this.skipSpace(str, i);
+        var ch = str.charAt(i);
 
-      if (j < 0) {
-        return -1;
-      } else {
-        var i = j;
-      }
+        if ("-+0987654321".indexOf(ch) >= 0) {
+          datetime_syntax.lastIndex = 0;
+          var m = datetime_syntax.exec(str.slice(i));
 
-      var ch = str.charAt(i);
+          if (m != null) {
+            // j =  ( i + datetime_syntax.lastIndex ) ;
+            var val = m[0];
+            j = i + val.length;
 
-      if ("-+0987654321".indexOf(ch) >= 0) {
-        datetime_syntax.lastIndex = 0;
-        var m = datetime_syntax.exec(str.slice(i));
+            if (val.indexOf("T") >= 0) {
+              res.push(this._store.literal(val, this._store.sym(DATETIME_DATATYPE)));
+            } else {
+              res.push(this._store.literal(val, this._store.sym(DATE_DATATYPE)));
+            }
+          } else {
+            number_syntax.lastIndex = 0;
+            var m = number_syntax.exec(str.slice(i));
 
-        if (m != null) {
-          // j =  ( i + datetime_syntax.lastIndex ) ;
-          var val = m[0];
-          j = i + val.length;
+            if (m == null) {
+              throw BadSyntax(this._thisDoc, this.lines, str, i, "Bad number or date syntax");
+            }
 
-          if (val.indexOf("T") >= 0) {
-            res.push(this._store.literal(val, this._store.sym(DATETIME_DATATYPE)));
-          } else {
-            res.push(this._store.literal(val, this._store.sym(DATE_DATATYPE)));
-          }
-        } else {
-          number_syntax.lastIndex = 0;
-          var m = number_syntax.exec(str.slice(i));
+            j = i + number_syntax.lastIndex;
+            var val = str.slice(i, j);
 
-          if (m == null) {
-            throw BadSyntax(this._thisDoc, this.lines, str, i, "Bad number or date syntax");
+            if (val.indexOf("e") >= 0) {
+              res.push(this._store.literal(parseFloat(val), this._store.sym(FLOAT_DATATYPE)));
+            } else if (str.slice(i, j).indexOf(".") >= 0) {
+              res.push(this._store.literal(parseFloat(val), this._store.sym(DECIMAL_DATATYPE)));
+            } else {
+              res.push(this._store.literal(parseInt(val), this._store.sym(INTEGER_DATATYPE)));
+            }
           }
 
-          j = i + number_syntax.lastIndex;
-          var val = str.slice(i, j);
+          ;
+          return j; // Where we have got up to
+        }
 
-          if (val.indexOf("e") >= 0) {
-            res.push(this._store.literal(parseFloat(val), this._store.sym(FLOAT_DATATYPE)));
-          } else if (str.slice(i, j).indexOf(".") >= 0) {
-            res.push(this._store.literal(parseFloat(val), this._store.sym(DECIMAL_DATATYPE)));
+        if (str.charAt(i) == "\"") {
+          if (str.slice(i, i + 3) == "\"\"\"") {
+            var delim = "\"\"\"";
           } else {
-            res.push(this._store.literal(parseInt(val), this._store.sym(INTEGER_DATATYPE)));
+            var delim = "\"";
           }
-        }
-
-        ;
-        return j; // Where we have got up to
-      }
 
-      if (str.charAt(i) == "\"") {
-        if (str.slice(i, i + 3) == "\"\"\"") {
-          var delim = "\"\"\"";
-        } else {
-          var delim = "\"";
-        }
+          var i = i + pyjslib_len(delim);
+          var dt = null;
+          var pairFudge = this.strconst(str, i, delim);
+          var j = pairFudge[0];
+          var s = pairFudge[1];
+          var lang = null;
 
-        var i = i + pyjslib_len(delim);
-        var dt = null;
-        var pairFudge = this.strconst(str, i, delim);
-        var j = pairFudge[0];
-        var s = pairFudge[1];
-        var lang = null;
+          if (str.slice(j, j + 1) == "@") {
+            langcode.lastIndex = 0;
+            var m = langcode.exec(str.slice(j + 1));
 
-        if (str.slice(j, j + 1) == "@") {
-          langcode.lastIndex = 0;
-          var m = langcode.exec(str.slice(j + 1));
+            if (m == null) {
+              throw BadSyntax(this._thisDoc, startline, str, i, "Bad language code syntax on string literal, after @");
+            }
 
-          if (m == null) {
-            throw BadSyntax(this._thisDoc, startline, str, i, "Bad language code syntax on string literal, after @");
+            var i = langcode.lastIndex + j + 1;
+            var lang = str.slice(j + 1, i);
+            var j = i;
           }
 
-          var i = langcode.lastIndex + j + 1;
-          var lang = str.slice(j + 1, i);
-          var j = i;
-        }
+          if (str.slice(j, j + 2) == "^^") {
+            var res2 = new pyjslib_List([]);
+            var j = this.uri_ref2(str, j + 2, res2);
+            var dt = res2[0];
+          }
 
-        if (str.slice(j, j + 2) == "^^") {
-          var res2 = new pyjslib_List([]);
-          var j = this.uri_ref2(str, j + 2, res2);
-          var dt = res2[0];
+          res.push(this._store.literal(s, lang || dt));
+          return j;
+        } else {
+          return -1;
         }
-
-        res.push(this._store.literal(s, lang || dt));
-        return j;
-      } else {
-        return -1;
       }
     }
-  };
-
-  __SinkParser.prototype.strconst = function (str, i, delim) {
-    /*
-    parse an N3 string constant delimited by delim.
-    return index, val
-    */
-    var j = i;
-    var ustr = "";
-    var startline = this.lines;
+  }, {
+    key: "strconst",
+    value: function strconst(str, i, delim) {
+      /*
+      parse an N3 string constant delimited by delim.
+      return index, val
+      */
+      var j = i;
+      var ustr = "";
+      var startline = this.lines;
 
-    while (j < pyjslib_len(str)) {
-      var i = j + pyjslib_len(delim);
+      while (j < pyjslib_len(str)) {
+        var i = j + pyjslib_len(delim);
 
-      if (str.slice(j, i) == delim) {
-        return new pyjslib_Tuple([i, ustr]);
-      }
+        if (str.slice(j, i) == delim) {
+          return new pyjslib_Tuple([i, ustr]);
+        }
 
-      if (str.charAt(j) == "\"") {
-        var ustr = ustr + "\"";
-        var j = j + 1;
-        continue;
-      }
+        if (str.charAt(j) == "\"") {
+          var ustr = ustr + "\"";
+          var j = j + 1;
+          continue;
+        }
 
-      interesting.lastIndex = 0;
-      var m = interesting.exec(str.slice(j));
+        interesting.lastIndex = 0;
+        var m = interesting.exec(str.slice(j));
 
-      if (!m) {
-        throw BadSyntax(this._thisDoc, startline, str, j, "Closing quote missing in string at ^ in " + str.slice(j - 20, j) + "^" + str.slice(j, j + 20));
-      }
+        if (!m) {
+          throw BadSyntax(this._thisDoc, startline, str, j, "Closing quote missing in string at ^ in " + str.slice(j - 20, j) + "^" + str.slice(j, j + 20));
+        }
 
-      var i = j + interesting.lastIndex - 1;
-      var ustr = ustr + str.slice(j, i);
-      var ch = str.charAt(i);
+        var i = j + interesting.lastIndex - 1;
+        var ustr = ustr + str.slice(j, i);
+        var ch = str.charAt(i);
 
-      if (ch == "\"") {
-        var j = i;
-        continue;
-      } else if (ch == "\r") {
-        var j = i + 1;
-        continue;
-      } else if (ch == "\n") {
-        if (delim == "\"") {
-          throw BadSyntax(this._thisDoc, startline, str, i, "newline found in string literal");
-        }
+        if (ch == "\"") {
+          var j = i;
+          continue;
+        } else if (ch == "\r") {
+          var j = i + 1;
+          continue;
+        } else if (ch == "\n") {
+          if (delim == "\"") {
+            throw BadSyntax(this._thisDoc, startline, str, i, "newline found in string literal");
+          }
 
-        this.lines = this.lines + 1;
-        var ustr = ustr + ch;
-        var j = i + 1;
-        this.previousLine = this.startOfLine;
-        this.startOfLine = j;
-      } else if (ch == "\\") {
-        var j = i + 1;
-        var ch = str.slice(j, j + 1);
+          this.lines = this.lines + 1;
+          var ustr = ustr + ch;
+          var j = i + 1;
+          this.previousLine = this.startOfLine;
+          this.startOfLine = j;
+        } else if (ch == "\\") {
+          var j = i + 1;
+          var ch = str.slice(j, j + 1);
 
-        if (!ch) {
-          throw BadSyntax(this._thisDoc, startline, str, i, "unterminated string literal (2)");
-        }
+          if (!ch) {
+            throw BadSyntax(this._thisDoc, startline, str, i, "unterminated string literal (2)");
+          }
 
-        var k = string_find("abfrtvn\\\"", ch);
+          var k = string_find("abfrtvn\\\"", ch);
 
-        if (k >= 0) {
-          var uch = "\a\b\f\r\t\v\n\\\"".charAt(k);
-          var ustr = ustr + uch;
-          var j = j + 1;
-        } else if (ch == "u") {
-          var pairFudge = this.uEscape(str, j + 1, startline);
-          var j = pairFudge[0];
-          var ch = pairFudge[1];
-          var ustr = ustr + ch;
-        } else if (ch == "U") {
-          var pairFudge = this.UEscape(str, j + 1, startline);
-          var j = pairFudge[0];
-          var ch = pairFudge[1];
-          var ustr = ustr + ch;
-        } else {
-          throw BadSyntax(this._thisDoc, this.lines, str, i, "bad escape");
+          if (k >= 0) {
+            var uch = "\a\b\f\r\t\v\n\\\"".charAt(k);
+            var ustr = ustr + uch;
+            var j = j + 1;
+          } else if (ch == "u") {
+            var pairFudge = this.uEscape(str, j + 1, startline);
+            var j = pairFudge[0];
+            var ch = pairFudge[1];
+            var ustr = ustr + ch;
+          } else if (ch == "U") {
+            var pairFudge = this.UEscape(str, j + 1, startline);
+            var j = pairFudge[0];
+            var ch = pairFudge[1];
+            var ustr = ustr + ch;
+          } else {
+            throw BadSyntax(this._thisDoc, this.lines, str, i, "bad escape");
+          }
         }
       }
-    }
 
-    throw BadSyntax(this._thisDoc, this.lines, str, i, "unterminated string literal");
-  };
+      throw BadSyntax(this._thisDoc, this.lines, str, i, "unterminated string literal");
+    }
+  }, {
+    key: "uEscape",
+    value: function uEscape(str, i, startline) {
+      var j = i;
+      var count = 0;
+      var value = 0;
 
-  __SinkParser.prototype.uEscape = function (str, i, startline) {
-    var j = i;
-    var count = 0;
-    var value = 0;
+      while (count < 4) {
+        var chFudge = str.slice(j, j + 1);
+        var ch = chFudge.toLowerCase();
+        var j = j + 1;
 
-    while (count < 4) {
-      var chFudge = str.slice(j, j + 1);
-      var ch = chFudge.toLowerCase();
-      var j = j + 1;
+        if (ch == "") {
+          throw BadSyntax(this._thisDoc, startline, str, i, "unterminated string literal(3)");
+        }
 
-      if (ch == "") {
-        throw BadSyntax(this._thisDoc, startline, str, i, "unterminated string literal(3)");
-      }
+        var k = string_find("0123456789abcdef", ch);
 
-      var k = string_find("0123456789abcdef", ch);
+        if (k < 0) {
+          throw BadSyntax(this._thisDoc, startline, str, i, "bad string literal hex escape");
+        }
 
-      if (k < 0) {
-        throw BadSyntax(this._thisDoc, startline, str, i, "bad string literal hex escape");
+        var value = value * 16 + k;
+        var count = count + 1;
       }
 
-      var value = value * 16 + k;
-      var count = count + 1;
+      var uch = String.fromCharCode(value);
+      return new pyjslib_Tuple([j, uch]);
     }
+  }, {
+    key: "UEscape",
+    value: function UEscape(str, i, startline) {
+      var j = i;
+      var count = 0;
+      var value = "\\U";
 
-    var uch = String.fromCharCode(value);
-    return new pyjslib_Tuple([j, uch]);
-  };
-
-  __SinkParser.prototype.UEscape = function (str, i, startline) {
-    var j = i;
-    var count = 0;
-    var value = "\\U";
+      while (count < 8) {
+        var chFudge = str.slice(j, j + 1);
+        var ch = chFudge.toLowerCase();
+        var j = j + 1;
 
-    while (count < 8) {
-      var chFudge = str.slice(j, j + 1);
-      var ch = chFudge.toLowerCase();
-      var j = j + 1;
+        if (ch == "") {
+          throw BadSyntax(this._thisDoc, startline, str, i, "unterminated string literal(3)");
+        }
 
-      if (ch == "") {
-        throw BadSyntax(this._thisDoc, startline, str, i, "unterminated string literal(3)");
-      }
+        var k = string_find("0123456789abcdef", ch);
 
-      var k = string_find("0123456789abcdef", ch);
+        if (k < 0) {
+          throw BadSyntax(this._thisDoc, startline, str, i, "bad string literal hex escape");
+        }
 
-      if (k < 0) {
-        throw BadSyntax(this._thisDoc, startline, str, i, "bad string literal hex escape");
+        var value = value + ch;
+        var count = count + 1;
       }
 
-      var value = value + ch;
-      var count = count + 1;
+      var uch = stringFromCharCode("0x" + pyjslib_slice(value, 2, 10) - 0);
+      return new pyjslib_Tuple([j, uch]);
     }
+  }]);
 
-    var uch = stringFromCharCode("0x" + pyjslib_slice(value, 2, 10) - 0);
-    return new pyjslib_Tuple([j, uch]);
-  };
-
-  function OLD_BadSyntax(uri, lines, str, i, why) {
-    return new __OLD_BadSyntax(uri, lines, str, i, why);
+  return SinkParser;
+}();
+
+function OLD_BadSyntax(uri, lines, str, i, why) {
+  return new __OLD_BadSyntax(uri, lines, str, i, why);
+}
+
+function __OLD_BadSyntax(uri, lines, str, i, why) {
+  this._str = str.encode("utf-8");
+  this._str = str;
+  this._i = i;
+  this._why = why;
+  this.lines = lines;
+  this._uri = uri;
+}
+
+__OLD_BadSyntax.prototype.toString = function () {
+  var str = this._str;
+  var i = this._i;
+  var st = 0;
+
+  if (i > 60) {
+    var pre = "...";
+    var st = i - 60;
+  } else {
+    var pre = "";
   }
 
-  function __OLD_BadSyntax(uri, lines, str, i, why) {
-    this._str = str.encode("utf-8");
-    this._str = str;
-    this._i = i;
-    this._why = why;
-    this.lines = lines;
-    this._uri = uri;
+  if (pyjslib_len(str) - i > 60) {
+    var post = "...";
+  } else {
+    var post = "";
   }
 
-  __OLD_BadSyntax.prototype.toString = function () {
-    var str = this._str;
-    var i = this._i;
-    var st = 0;
+  return "Line %i of <%s>: Bad syntax (%s) at ^ in:\n\"%s%s^%s%s\"" % new pyjslib_Tuple([this.lines + 1, this._uri, this._why, pre, str.slice(st, i), str.slice(i, i + 60), post]);
+};
 
-    if (i > 60) {
-      var pre = "...";
-      var st = i - 60;
-    } else {
-      var pre = "";
-    }
+function BadSyntax(uri, lines, str, i, why) {
+  var lineNo = lines + 1;
+  var msg = "Line " + lineNo + " of <" + uri + ">: Bad syntax: " + why + "\nat: \"" + str.slice(i, i + 30) + "\"";
+  var e = new SyntaxError(msg, uri, lineNo);
+  e.lineNo = lineNo;
+  e.characterInFile = i;
+  e.syntaxProblem = why;
+  return e;
+}
 
-    if (pyjslib_len(str) - i > 60) {
-      var post = "...";
-    } else {
-      var post = "";
-    }
+function stripCR(str) {
+  var res = "";
 
-    return "Line %i of <%s>: Bad syntax (%s) at ^ in:\n\"%s%s^%s%s\"" % new pyjslib_Tuple([this.lines + 1, this._uri, this._why, pre, str.slice(st, i), str.slice(i, i + 60), post]);
-  };
+  var __ch = new pyjslib_Iterator(str);
 
-  function BadSyntax(uri, lines, str, i, why) {
-    var lineNo = lines + 1;
-    var msg = "Line " + lineNo + " of <" + uri + ">: Bad syntax: " + why + "\nat: \"" + str.slice(i, i + 30) + "\"";
-    var e = new SyntaxError(msg, uri, lineNo);
-    e.lineNo = lineNo;
-    e.characterInFile = i;
-    e.syntaxProblem = why;
-    return e;
-  }
+  try {
+    while (true) {
+      var ch = __ch.next();
 
-  function stripCR(str) {
-    var res = "";
-
-    var __ch = new pyjslib_Iterator(str);
-
-    try {
-      while (true) {
-        var ch = __ch.next();
-
-        if (ch != "\r") {
-          var res = res + ch;
-        }
-      }
-    } catch (e) {
-      if (e != StopIteration) {
-        throw e;
+      if (ch != "\r") {
+        var res = res + ch;
       }
     }
-
-    return res;
+  } catch (e) {
+    if (e != StopIteration) {
+      throw e;
+    }
   }
 
-  function dummyWrite(x) {}
+  return res;
+}
 
-  return SinkParser;
-})();
+function dummyWrite(x) {}