citeclaw 2.0.0

package/vendor/zotero/modules/translate/src/rdf/n3parser.js

@@ -0,0 +1,1392 @@
+if (typeof process === 'object' && process + '' === '[object process]'){
+  var $rdf = require('./init');
+}
+
+$rdf.N3Parser = function () {
+
+  function hexify(str) { // also used in parser
+    return encodeURI(str);
+  }
+
+  // Things we need to define to make converted pythn code work in js
+  // environment of $rdf
+  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_Tuple = function (theList) {
+      return theList
+    };
+
+  var pyjslib_List = function (theList) {
+      return theList
+    };
+
+  var pyjslib_Dict = function (listOfPairs) {
+      if(listOfPairs.length > 0)
+        throw "missing.js: oops nnonempty dict not imp";
+      return [];
+    }
+
+  var pyjslib_len = function (s) {
+      return s.length
+    }
+
+  var pyjslib_slice = function (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 StopIteration = Error('dummy error stop iteration');
+
+  var pyjslib_Iterator = function (theList) {
+      this.last = 0;
+      this.li = theList;
+      this.next = function () {
+        if(this.last == this.li.length) throw StopIteration;
+        return this.li[this.last++];
+      }
+      return this;
+    };
+
+  var ord = function (str) {
+      return str.charCodeAt(0)
+    }
+
+  var string_find = function (str, s) {
+      return str.indexOf(s)
+    }
+
+  var assertFudge = function (condition, desc) {
+      if(condition) return;
+      if(desc) throw "python Assertion failed: " + desc;
+      throw "(python) Assertion failed.";
+    }
+
+
+  var stringFromCharCode = function (uesc) {
+      return String.fromCharCode(uesc);
+    }
+
+  var uripath_join = function (base, given) {
+      return $rdf.Util.uri.join(given, base) // sad but true
+    }
+
+  var becauseSubexpression = null; // No reason needed
+  var diag_tracking = 0;
+  var diag_chatty_flag = 0;
+  var diag_progress = function (str) {
+      /*$rdf.log(str);*/
+    }
+
+    // why_BecauseOfData = function(doc, reason) { return doc };
+
+  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);
+}
+*/
+
+  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 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 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 SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why) {
+    return new __SinkParser(store, openFormula, thisDoc, baseURI, genPrefix, metaURI, flags, why);
+  }
+
+  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;
+    if(typeof genPrefix == 'undefined') genPrefix = "";
+    if(typeof metaURI == 'undefined') metaURI = null;
+    if(typeof flags == 'undefined') flags = "";
+    if(typeof why == 'undefined') why = null;
+    /*
+    note: namespace names should *not* end in #;
+    the # will get added during qname processing */
+
+    this._bindings = new pyjslib_Dict([]);
+    this._flags = flags;
+    if((thisDoc != "")) {
+      assertFudge((thisDoc.indexOf(":") >= 0), ("Document URI not absolute: " + thisDoc));
+      this._bindings[""] = ((thisDoc + "#"));
+    }
+    this._store = store;
+    if(genPrefix) {
+      store.setGenPrefix(genPrefix);
+    }
+    this._thisDoc = thisDoc;
+    this.source = store.sym(thisDoc);
+    this.lines = 0;
+    this.statementCount = 0;
+    this.startOfLine = 0;
+    this.previousLine = 0;
+    this._genPrefix = genPrefix;
+    this.keywords = new pyjslib_List(["a", "this", "bind", "has", "is", "of", "true", "false"]);
+    this.keywordsSet = 0;
+    this._anonymousNodes = new pyjslib_Dict([]);
+    this._variables = new pyjslib_Dict([]);
+    this._parentVariables = new pyjslib_Dict([]);
+    this._reason = why;
+    this._reason2 = null;
+    if(diag_tracking) {
+      this._reason2 = why_BecauseOfData(store.sym(thisDoc), this._reason);
+    }
+    if(baseURI) {
+      this._baseURI = baseURI;
+    } else {
+      if(thisDoc) {
+        this._baseURI = thisDoc;
+      } else {
+        this._baseURI = null;
+      }
+    }
+    assertFudge(!(this._baseURI) || (this._baseURI.indexOf(":") >= 0));
+    if(!(this._genPrefix)) {
+      if(this._thisDoc) {
+        this._genPrefix = (this._thisDoc + "#_g");
+      } else {
+        this._genPrefix = RDFSink_uniqueURI();
+      }
+    }
+    if((openFormula == null)) {
+      if(this._thisDoc) {
+        this._formula = store.formula((thisDoc + "#_formula"));
+      } else {
+        this._formula = store.formula();
+      }
+    } else {
+      this._formula = openFormula;
+    }
+    this._context = this._formula;
+    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());
+  };
+  __SinkParser.prototype.loadBuf = function (buf) {
+    /*
+    Parses a buffer and returns its top level formula*/
+
+    this.startDoc();
+    this.feed(buf);
+    return this.endDoc();
+  };
+  __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;
+    var i = 0;
+    while((i >= 0)) {
+      var j = this.skipSpace(str, i);
+      if((j < 0)) {
+        return;
+      }
+      var i = this.directiveOrStatement(str, j);
+      if((i < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "expected directive or statement");
+      }
+    }
+  };
+  __SinkParser.prototype.directiveOrStatement = function (str, h) {
+    var i = this.skipSpace(str, h);
+    if((i < 0)) {
+      return i;
+    }
+    var j = this.directive(str, i);
+    if((j >= 0)) {
+      return this.checkDot(str, j);
+    }
+    var j = this.statement(str, i);
+    if((j >= 0)) {
+      return this.checkDot(str, j);
+    }
+    return j;
+  };
+  __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 ";
+    if((pyjslib_slice(str, i, (i + 1)) == "@")) {
+      var i = (i + 1);
+    } else {
+      if(($rdf.Util.ArrayIndexOf(this.keywords, tok) < 0)) {
+        return -1;
+      }
+    }
+    var k = (i + pyjslib_len(tok));
+    if((pyjslib_slice(str, i, k) == tok) && (_notQNameChars.indexOf(str.charAt(k)) >= 0)) {
+      return k;
+    } else {
+      return -1;
+    }
+  };
+  __SinkParser.prototype.directive = function (str, i) {
+    var j = this.skipSpace(str, i);
+    if((j < 0)) {
+      return j;
+    }
+    var res = new pyjslib_List([]);
+    var j = this.tok("bind", str, i);
+    if((j > 0)) {
+      throw BadSyntax(this._thisDoc, this.lines, str, i, "keyword bind is obsolete: use @prefix");
+    }
+    var j = this.tok("keywords", str, i);
+    if((j > 0)) {
+      var i = this.commaSeparatedList(str, j, res, false);
+      if((i < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "'@keywords' needs comma separated list of words");
+      }
+      this.setKeywords(pyjslib_slice(res, null, null));
+      if((diag_chatty_flag > 80)) {
+        diag_progress("Keywords ", this.keywords);
+      }
+      return i;
+    }
+    var j = this.tok("forAll", str, i);
+    if((j > 0)) {
+      var i = this.commaSeparatedList(str, j, res, true);
+      if((i < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "Bad variable list after @forAll");
+      }
+
+      var __x = new pyjslib_Iterator(res);
+      try {
+        while(true) {
+          var x = __x.next();
+
+
+          if($rdf.Util.ArrayIndexOf(this._variables, x) < 0 || ($rdf.Util.ArrayIndexOf(this._parentVariables, x) >= 0)) {
+            this._variables[x] = (this._context.newUniversal(x));
+          }
+
+        }
+      } catch(e) {
+        if(e != StopIteration) {
+          throw e;
+        }
+      }
+
+      return i;
+    }
+    var j = this.tok("forSome", str, i);
+    if((j > 0)) {
+      var i = this.commaSeparatedList(str, j, res, this.uri_ref2);
+      if((i < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "Bad variable list after @forSome");
+      }
+
+      var __x = new pyjslib_Iterator(res);
+      try {
+        while(true) {
+          var x = __x.next();
+
+
+          this._context.declareExistential(x);
+
+        }
+      } catch(e) {
+        if(e != StopIteration) {
+          throw e;
+        }
+      }
+
+      return i;
+    }
+    var j = this.tok("prefix", str, i);
+    if((j >= 0)) {
+      var t = new pyjslib_List([]);
+      var i = this.qname(str, j, t);
+      if((i < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "expected qname after @prefix");
+      }
+      var j = this.uri_ref2(str, i, t);
+      if((j < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "expected <uriref> after @prefix _qname_");
+      }
+      var ns = t[1].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");
+      }
+      assertFudge((ns.indexOf(":") >= 0));
+      this._bindings[t[0][0]] = (ns);
+
+      this.bind(t[0][0], hexify(ns));
+      return j;
+    }
+    var j = this.tok("base", str, i);
+    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[0].uri;
+      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;
+    }
+    return -1;
+  };
+  __SinkParser.prototype.bind = function (qn, uri) {
+    if((qn == "")) {
+    } else {
+      this._store.setPrefixForURI(qn, uri);
+    }
+  };
+  __SinkParser.prototype.setKeywords = function (k) {
+    /*
+    Takes a list of strings*/
+
+    if((k == null)) {
+      this.keywordsSet = 0;
+    } else {
+      this.keywords = k;
+      this.keywordsSet = 1;
+    }
+  };
+  __SinkParser.prototype.startDoc = function () {};
+  __SinkParser.prototype.endDoc = function () {
+    /*
+    Signal end of document and stop parsing. returns formula*/
+
+    return this._formula;
+  };
+  __SinkParser.prototype.makeStatement = function (quad) {
+    quad[0].add(quad[2], quad[1], quad[3], this.source);
+    this.statementCount += 1;
+  };
+  __SinkParser.prototype.statement = function (str, i) {
+    var r = new pyjslib_List([]);
+    var i = this.object(str, i, r);
+    if((i < 0)) {
+      return i;
+    }
+    var j = this.property_list(str, i, r[0]);
+    if((j < 0)) {
+      throw BadSyntax(this._thisDoc, this.lines, str, i, "expected propertylist");
+    }
+    return j;
+  };
+  __SinkParser.prototype.subject = function (str, i, res) {
+    return this.item(str, i, res);
+  };
+  __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;
+    }
+    var r = new pyjslib_List([]);
+    var j = this.tok("has", str, i);
+    if((j >= 0)) {
+      var i = this.prop(str, j, r);
+      if((i < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "expected property after 'has'");
+      }
+      res.push(new pyjslib_Tuple(["->", r[0]]));
+      return i;
+    }
+    var j = this.tok("is", str, i);
+    if((j >= 0)) {
+      var i = this.prop(str, j, r);
+      if((i < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "expected <property> after 'is'");
+      }
+      var j = this.skipSpace(str, i);
+      if((j < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "End of file found, expected property after 'is'");
+        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>");
+      }
+      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((pyjslib_slice(str, i, (i + 2)) == "<=")) {
+      res.push(new pyjslib_Tuple(["<-", this._store.sym((Logic_NS + "implies"))]));
+      return(i + 2);
+    }
+    if((pyjslib_slice(str, i, (i + 1)) == "=")) {
+      if((pyjslib_slice(str, (i + 1), (i + 2)) == ">")) {
+        res.push(new pyjslib_Tuple(["->", this._store.sym((Logic_NS + "implies"))]));
+        return(i + 2);
+      }
+      res.push(new pyjslib_Tuple(["->", this._store.sym(DAML_sameAs_URI)]));
+      return(i + 1);
+    }
+    if((pyjslib_slice(str, i, (i + 2)) == ":=")) {
+      res.push(new pyjslib_Tuple(["->", (Logic_NS + "becomes")]));
+      return(i + 2);
+    }
+    var j = this.prop(str, i, r);
+    if((j >= 0)) {
+      res.push(new pyjslib_Tuple(["->", r[0]]));
+      return j;
+    }
+    if((pyjslib_slice(str, i, (i + 2)) == ">-") || (pyjslib_slice(str, i, (i + 2)) == "<-")) {
+      throw BadSyntax(this._thisDoc, this.lines, str, j, ">- ... -> syntax is obsolete.");
+    }
+    return -1;
+  };
+  __SinkParser.prototype.prop = function (str, i, res) {
+    return this.item(str, i, res);
+  };
+  __SinkParser.prototype.item = function (str, i, res) {
+    return this.path(str, i, res);
+  };
+  __SinkParser.prototype.blankNode = function (uri) {
+    return this._context.bnode(uri, this._reason2);
+  };
+  __SinkParser.prototype.path = function (str, i, res) {
+    /*
+    Parse the path production.
+    */
+
+    var j = this.nodeOrLiteral(str, i, res);
+    if((j < 0)) {
+      return j;
+    }
+    while(("!^.".indexOf(pyjslib_slice(str, j, (j + 1))) >= 0)) {
+      var ch = pyjslib_slice(str, j, (j + 1));
+      if((ch == ".")) {
+        var ahead = pyjslib_slice(str, (j + 1), (j + 2));
+        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);
+      if((j < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "EOF found in middle of path syntax");
+      }
+      var pred = res.pop();
+      if((ch == "^")) {
+        this.makeStatement(new pyjslib_Tuple([this._context, pred, obj, subj]));
+      } else {
+        this.makeStatement(new pyjslib_Tuple([this._context, pred, subj, obj]));
+      }
+      res.push(obj);
+    }
+    return j;
+  };
+  __SinkParser.prototype.anonymousNode = function (ln) {
+    /*
+    Remember or generate a term for one of these _: anonymous nodes*/
+
+    var term = this._anonymousNodes[ln];
+    if(term) {
+      return term;
+    }
+    var term = this._store.bnode(this._context, this._reason2);
+    this._anonymousNodes[ln] = (term);
+    return term;
+  };
+  __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().
+    */
+
+    var subj = subjectAlready;
+    var j = this.skipSpace(str, i);
+    if((j < 0)) {
+      return j;
+    }
+    var i = j;
+    var ch = pyjslib_slice(str, i, (i + 1));
+    if((ch == "[")) {
+      var bnodeID = this.here(i);
+      var j = this.skipSpace(str, (i + 1));
+      if((j < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF after '['");
+      }
+      if((pyjslib_slice(str, j, (j + 1)) == "=")) {
+        var i = (j + 1);
+        var objs = new pyjslib_List([]);
+        var j = this.objectList(str, i, objs);
+
+        if((j >= 0)) {
+          var subj = objs[0];
+          if((pyjslib_len(objs) > 1)) {
+
+            var __obj = new pyjslib_Iterator(objs);
+            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;
+              }
+            }
+
+          }
+          var j = this.skipSpace(str, j);
+          if((j < 0)) {
+            throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF when objectList expected after [ = ");
+          }
+          if((pyjslib_slice(str, j, (j + 1)) == ";")) {
+            var j = (j + 1);
+          }
+        } else {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "objectList expected after [= ");
+        }
+      }
+      if((subj == null)) {
+        var subj = this.blankNode(bnodeID);
+      }
+      var i = this.property_list(str, j, subj);
+      if((i < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "property_list expected");
+      }
+      var j = this.skipSpace(str, i);
+      if((j < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "EOF when ']' expected after [ <propertyList>");
+      }
+      if((pyjslib_slice(str, j, (j + 1)) != "]")) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "']' expected");
+      }
+      res.push(subj);
+      return(j + 1);
+    }
+    if((ch == "{")) {
+      var ch2 = pyjslib_slice(str, (i + 1), (i + 2));
+      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.");
+          }
+          if((pyjslib_slice(str, i, (i + 2)) == "$}")) {
+            var j = (i + 2);
+            break;
+          }
+          if(!(first_run)) {
+            if((pyjslib_slice(str, 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 '$}'");
+          }
+          mylist.push(item[0]);
+        }
+        res.push(this._store.newSet(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);
+          if((i < 0)) {
+            throw BadSyntax(this._thisDoc, this.lines, str, i, "needed '}', found end.");
+          }
+          if((pyjslib_slice(str, i, (i + 1)) == "}")) {
+            var j = (i + 1);
+            break;
+          }
+          var j = this.directiveOrStatement(str, i);
+          if((j < 0)) {
+            throw BadSyntax(this._thisDoc, this.lines, str, i, "expected statement or '}'");
+          }
+        }
+        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;
+      }
+    }
+    if((ch == "(")) {
+      var thing_type = this._store.list;
+      var ch2 = pyjslib_slice(str, (i + 1), (i + 2));
+      if((ch2 == "$")) {
+        var thing_type = this._store.newSet;
+        i += 1;
+      }
+      var j = (i + 1);
+      var mylist = new pyjslib_List([]);
+      while(1) {
+        var i = this.skipSpace(str, j);
+        if((i < 0)) {
+          throw BadSyntax(this._thisDoc, this.lines, str, i, "needed ')', found end.");
+        }
+        if((pyjslib_slice(str, i, (i + 1)) == ")")) {
+          var j = (i + 1);
+          break;
+        }
+        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 list or ')'");
+        }
+        mylist.push(item[0]);
+      }
+      res.push(thing_type(mylist, this._context));
+      return j;
+    }
+    var j = this.tok("this", str, i);
+    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;
+    }
+    var j = this.tok("true", str, i);
+    if((j >= 0)) {
+      res.push(true);
+      return j;
+    }
+    var j = this.tok("false", str, i);
+    if((j >= 0)) {
+      res.push(false);
+      return j;
+    }
+    if((subj == null)) {
+      var j = this.uri_ref2(str, i, res);
+      if((j >= 0)) {
+        return 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((pyjslib_slice(str, 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 i = j;
+      var v = new pyjslib_List([]);
+      var j = this.verb(str, i, v);
+      if((j <= 0)) {
+        return i;
+      }
+      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");
+      }
+
+      var __obj = new pyjslib_Iterator(objs);
+      try {
+        while(true) {
+          var obj = __obj.next();
+
+
+          var pairFudge = v[0];
+          var dir = pairFudge[0];
+          var sym = pairFudge[1];
+          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.skipSpace(str, i);
+      if((j < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "EOF found in list of objects");
+        return j;
+      }
+      if((pyjslib_slice(str, i, (i + 1)) != ";")) {
+        return i;
+      }
+      var i = (i + 1);
+    }
+  };
+  __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((str.charAt(i) == ".")) {
+      return j;
+    }
+    if(ofUris) {
+      var i = this.uri_ref2(str, i, res);
+    } else {
+      var i = this.bareWord(str, i, res);
+    }
+    if((i < 0)) {
+      return -1;
+    }
+    while(1) {
+      var j = this.skipSpace(str, i);
+      if((j < 0)) {
+        return j;
+      }
+      var ch = pyjslib_slice(str, j, (j + 1));
+      if((ch != ",")) {
+        if((ch != ".")) {
+          return -1;
+        }
+        return j;
+      }
+      if(ofUris) {
+        var i = this.uri_ref2(str, (j + 1), res);
+      } else {
+        var i = this.bareWord(str, (j + 1), res);
+      }
+      if((i < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, "bad list content");
+        return i;
+      }
+    }
+  };
+  __SinkParser.prototype.objectList = function (str, i, res) {
+    var i = this.object(str, i, res);
+    if((i < 0)) {
+      return -1;
+    }
+    while(1) {
+      var j = this.skipSpace(str, i);
+      if((j < 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, j, "EOF found after object");
+        return j;
+      }
+      if((pyjslib_slice(str, j, (j + 1)) != ",")) {
+        return j;
+      }
+      var i = this.object(str, (j + 1), res);
+      if((i < 0)) {
+        return i;
+      }
+    }
+  };
+  __SinkParser.prototype.checkDot = function (str, i) {
+    var j = this.skipSpace(str, i);
+    if((j < 0)) {
+      return j;
+    }
+    if((pyjslib_slice(str, j, (j + 1)) == ".")) {
+      return(j + 1);
+    }
+    if((pyjslib_slice(str, j, (j + 1)) == "}")) {
+      return j;
+    }
+    if((pyjslib_slice(str, j, (j + 1)) == "]")) {
+      return j;
+    }
+    throw BadSyntax(this._thisDoc, this.lines, str, j, "expected '.' or '}' or ']' at end of statement");
+    return i;
+  };
+  __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(!(ns)) {
+          if((pfx == "_")) {
+            res.push(this.anonymousNode(ln));
+            return j;
+          }
+          throw BadSyntax(this._thisDoc, this.lines, str, i, (("Prefix " + pfx) + " not bound."));
+        }
+      }
+      var symb = this._store.sym((ns + ln));
+      if(($rdf.Util.ArrayIndexOf(this._variables, symb) >= 0)) {
+        res.push(this._variables[symb]);
+      } else {
+        res.push(symb);
+      }
+      return j;
+    }
+    var i = this.skipSpace(str, i);
+    if((i < 0)) {
+      return -1;
+    }
+    if((str.charAt(i) == "?")) {
+      var v = new pyjslib_List([]);
+      var j = this.variable(str, i, v);
+      if((j > 0)) {
+        res.push(v[0]);
+        return j;
+      }
+      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 = pyjslib_slice(str, st, 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");
+          }
+          if((pyjslib_slice(str, (i - 1), i) == "#") && !((pyjslib_slice(uref, -1, null) == "#"))) {
+            var uref = (uref + "#");
+          }
+          var symb = this._store.sym(uref);
+          if(($rdf.Util.ArrayIndexOf(this._variables, symb) >= 0)) {
+            res.push(this._variables[symb]);
+          } else {
+            res.push(symb);
+          }
+          return(i + 1);
+        }
+        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);
+      if((j < 0)) {
+        return -1;
+      }
+      if(($rdf.Util.ArrayIndexOf(this.keywords, v[0]) >= 0)) {
+        throw BadSyntax(this._thisDoc, this.lines, str, i, (("Keyword \"" + v[0]) + "\" not allowed here."));
+      }
+      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 tmp = str;
+    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++) {
+      if(whitespace.indexOf(str.charAt(j)) === -1) {
+        if(str.charAt(j) === '#') {
+          str = str.slice(i).replace(/^[^\n]*\n/, "");
+          i = 0;
+          j = -1;
+        } else {
+          break;
+        }
+      }
+    }
+    var val = (tmp.length - str.length) + j;
+    if(val === tmp.length) {
+      return -1;
+    }
+    return val;
+  };
+  __SinkParser.prototype.variable = function (str, i, res) {
+    /*
+    ?abc -> variable(:abc)
+    */
+
+    var j = this.skipSpace(str, i);
+    if((j < 0)) {
+      return -1;
+    }
+    if((pyjslib_slice(str, 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);
+    }
+    if((this._parentContext == null)) {
+      throw BadSyntax(this._thisDoc, this.lines, str, j, ("Can't use ?xxx syntax for variable in outermost level: " + pyjslib_slice(str, (j - 1), i)));
+    }
+    res.push(this._store.variable(pyjslib_slice(str, j, i)));
+    return i;
+  };
+  __SinkParser.prototype.bareWord = function (str, i, res) {
+    /*
+    abc -> :abc
+    */
+
+    var j = this.skipSpace(str, i);
+    if((j < 0)) {
+      return -1;
+    }
+    var ch = str.charAt(j);
+    if(("0123456789-".indexOf(ch) >= 0)) {
+      return -1;
+    }
+    if((_notNameChars.indexOf(ch) >= 0)) {
+      return -1;
+    }
+    var i = j;
+    while((i < pyjslib_len(str)) && (_notNameChars.indexOf(str.charAt(i)) < 0)) {
+      var i = (i + 1);
+    }
+    res.push(pyjslib_slice(str, 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;
+    }
+    var c = str.charAt(i);
+    if(("0123456789-+".indexOf(c) >= 0)) {
+      return -1;
+    }
+    if((_notNameChars.indexOf(c) < 0)) {
+      var ln = c;
+      var i = (i + 1);
+      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;
+        }
+      }
+    } else {
+      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);
+        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 && ($rdf.Util.ArrayIndexOf(this.keywords, ln) < 0)) {
+        res.push(new pyjslib_Tuple(["", ln]));
+        return i;
+      }
+      return -1;
+    }
+  };
+  __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 -1;
+      } else {
+        var i = j;
+      }
+      if((str.charAt(i) == "\"")) {
+        if((pyjslib_slice(str, i, (i + 3)) == "\"\"\"")) {
+          var delim = "\"\"\"";
+        } else {
+          var delim = "\"";
+        }
+        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 {
+        return -1;
+      }
+    }
+  };
+  __SinkParser.prototype.nodeOrLiteral = function (str, i, res) {
+    var j = this.node(str, i, res);
+    if((j >= 0)) {
+      return j;
+    } else {
+      var j = this.skipSpace(str, i);
+      if((j < 0)) {
+        return -1;
+      } else {
+        var i = j;
+      }
+      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;
+      }
+      if((str.charAt(i) == "\"")) {
+        if((pyjslib_slice(str, 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;
+        if((pyjslib_slice(str, 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 @");
+          }
+          var i = ((langcode.lastIndex + j) + 1);
+
+          var lang = pyjslib_slice(str, (j + 1), i);
+          var j = i;
+        }
+        if((pyjslib_slice(str, 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;
+      }
+    }
+  };
+  __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;
+    while((j < pyjslib_len(str))) {
+      var i = (j + pyjslib_len(delim));
+      if((pyjslib_slice(str, j, i) == delim)) {
+        return new pyjslib_Tuple([i, ustr]);
+      }
+      if((str.charAt(j) == "\"")) {
+        var ustr = (ustr + "\"");
+        var j = (j + 1);
+        continue;
+      }
+      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 " + pyjslib_slice(str, (j - 20), j)) + "^") + pyjslib_slice(str, j, (j + 20))));
+      }
+      var i = ((j + interesting.lastIndex) - 1);
+      var ustr = (ustr + pyjslib_slice(str, 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");
+        }
+        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 = pyjslib_slice(str, j, (j + 1));
+        if(!(ch)) {
+          throw BadSyntax(this._thisDoc, startline, str, i, "unterminated string literal (2)");
+        }
+        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");
+        }
+      }
+    }
+    throw BadSyntax(this._thisDoc, this.lines, str, i, "unterminated string literal");
+  };
+  __SinkParser.prototype.uEscape = function (str, i, startline) {
+    var j = i;
+    var count = 0;
+    var value = 0;
+    while((count < 4)) {
+      var chFudge = pyjslib_slice(str, j, (j + 1));
+      var ch = chFudge.toLowerCase();
+      var j = (j + 1);
+      if((ch == "")) {
+        throw BadSyntax(this._thisDoc, startline, str, i, "unterminated string literal(3)");
+      }
+      var k = string_find("0123456789abcdef", ch);
+      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 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 = pyjslib_slice(str, j, (j + 1));
+      var ch = chFudge.toLowerCase();
+      var j = (j + 1);
+      if((ch == "")) {
+        throw BadSyntax(this._thisDoc, startline, str, i, "unterminated string literal(3)");
+      }
+      var k = string_find("0123456789abcdef", ch);
+      if((k < 0)) {
+        throw BadSyntax(this._thisDoc, startline, str, i, "bad string literal hex escape");
+      }
+      var value = (value + ch);
+      var count = (count + 1);
+    }
+    var uch = stringFromCharCode((("0x" + pyjslib_slice(value, 2, 10)) - 0));
+    return new pyjslib_Tuple([j, uch]);
+  };
+
+  function BadSyntax(uri, lines, str, i, why) {
+    return(((((((("Line " + (lines + 1)) + " of <") + uri) + ">: Bad syntax: ") + why) + "\nat: \"") + pyjslib_slice(str, i, (i + 30))) + "\"");
+  }
+
+
+  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;
+      }
+    }
+
+    return res;
+  }
+
+
+  function dummyWrite(x) {
+  }
+
+  return SinkParser;
+
+}();
+
+if (typeof process === 'object' && process + '' === '[object process]'){
+  module.exports = $rdf.N3Parser;
+}