n3 1.11.1 → 1.11.2

package/lib/N3DataFactory.js

@@ -3,11 +3,11 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+exports.default = exports.Variable = exports.Triple = exports.Term = exports.Quad = exports.NamedNode = exports.Literal = exports.DefaultGraph = exports.BlankNode = void 0;
+exports.escapeQuotes = escapeQuotes;
 exports.termFromId = termFromId;
 exports.termToId = termToId;
-exports.escapeQuotes = escapeQuotes;
 exports.unescapeQuotes = unescapeQuotes;
-exports.Triple = exports.Quad = exports.DefaultGraph = exports.Variable = exports.BlankNode = exports.Literal = exports.NamedNode = exports.Term = exports.default = void 0;
 
 var _IRIs = _interopRequireDefault(require("./IRIs"));
 
@@ -353,11 +353,11 @@ function literal(value, languageOrDataType) {
     // Convert a boolean
     if (typeof value === 'boolean') datatype = xsd.boolean; // Convert an integer or double
     else if (typeof value === 'number') {
-        if (Number.isFinite(value)) datatype = Number.isInteger(value) ? xsd.integer : xsd.double;else {
-          datatype = xsd.double;
-          if (!Number.isNaN(value)) value = value > 0 ? 'INF' : '-INF';
-        }
+      if (Number.isFinite(value)) datatype = Number.isInteger(value) ? xsd.integer : xsd.double;else {
+        datatype = xsd.double;
+        if (!Number.isNaN(value)) value = value > 0 ? 'INF' : '-INF';
       }
+    }
   } // Create a datatyped literal
 
 

package/lib/N3Lexer.js

@@ -95,8 +95,8 @@ class N3Lexer {
       }
     } // When not in line mode, enable N3 functionality by default
     else {
-        this._n3Mode = options.n3 !== false;
-      } // Don't output comment tokens by default
+      this._n3Mode = options.n3 !== false;
+    } // Don't output comment tokens by default
 
 
     this._comments = !!options.comments; // Cache the last tested closing position of long literals
@@ -167,35 +167,35 @@ class N3Lexer {
           // We need at least 3 tokens lookahead to distinguish ^^<IRI> and ^^pre:fixed
           if (input.length < 3) break; // Try to match a type
           else if (input[1] === '^') {
-              this._previousMarker = '^^'; // Move to type IRI or prefixed name
+            this._previousMarker = '^^'; // Move to type IRI or prefixed name
 
-              input = input.substr(2);
+            input = input.substr(2);
 
-              if (input[0] !== '<') {
-                inconclusive = true;
-                break;
-              }
-            } // If no type, it must be a path expression
-            else {
-                if (this._n3Mode) {
-                  matchLength = 1;
-                  type = '^';
-                }
+            if (input[0] !== '<') {
+              inconclusive = true;
+              break;
+            }
+          } // If no type, it must be a path expression
+          else {
+            if (this._n3Mode) {
+              matchLength = 1;
+              type = '^';
+            }
 
-                break;
-              }
+            break;
+          }
         // Fall through in case the type is an IRI
 
         case '<':
           // Try to find a full IRI without escape sequences
           if (match = this._unescapedIri.exec(input)) type = 'IRI', value = match[1]; // Try to find a full IRI with escape sequences
           else if (match = this._iri.exec(input)) {
-              value = this._unescape(match[1]);
-              if (value === null || illegalIriChars.test(value)) return reportSyntaxError(this);
-              type = 'IRI';
-            } // Try to find a nested triple
-            else if (input.length > 1 && input[1] === '<') type = '<<', matchLength = 2; // Try to find a backwards implication arrow
-              else if (this._n3Mode && input.length > 1 && input[1] === '=') type = 'inverse', matchLength = 2, value = '>';
+            value = this._unescape(match[1]);
+            if (value === null || illegalIriChars.test(value)) return reportSyntaxError(this);
+            type = 'IRI';
+          } // Try to find a nested triple
+          else if (input.length > 1 && input[1] === '<') type = '<<', matchLength = 2; // Try to find a backwards implication arrow
+          else if (this._n3Mode && input.length > 1 && input[1] === '=') type = 'inverse', matchLength = 2, value = '>';
           break;
 
         case '>':
@@ -213,12 +213,12 @@ class N3Lexer {
           // Try to find a literal without escape sequences
           if (match = this._simpleQuotedString.exec(input)) value = match[1]; // Try to find a literal wrapped in three pairs of quotes
           else {
-              ({
-                value,
-                matchLength
-              } = this._parseLiteral(input));
-              if (value === null) return reportSyntaxError(this);
-            }
+            ({
+              value,
+              matchLength
+            } = this._parseLiteral(input));
+            if (value === null) return reportSyntaxError(this);
+          }
 
           if (match !== null || matchLength !== 0) {
             type = 'literal';
@@ -232,12 +232,12 @@ class N3Lexer {
             // Try to find a literal without escape sequences
             if (match = this._simpleApostropheString.exec(input)) value = match[1]; // Try to find a literal wrapped in three pairs of quotes
             else {
-                ({
-                  value,
-                  matchLength
-                } = this._parseLiteral(input));
-                if (value === null) return reportSyntaxError(this);
-              }
+              ({
+                value,
+                matchLength
+              } = this._parseLiteral(input));
+              if (value === null) return reportSyntaxError(this);
+            }
 
             if (match !== null || matchLength !== 0) {
               type = 'literal';
@@ -488,45 +488,45 @@ class N3Lexer {
 
       if (typeof callback === 'function') (0, _queueMicrotask.default)(() => this._tokenizeToEnd(callback, true)); // If no callback was passed, tokenize synchronously and return
       else {
-          const tokens = [];
-          let error;
+        const tokens = [];
+        let error;
 
-          this._tokenizeToEnd((e, t) => e ? error = e : tokens.push(t), true);
+        this._tokenizeToEnd((e, t) => e ? error = e : tokens.push(t), true);
 
-          if (error) throw error;
-          return tokens;
-        }
+        if (error) throw error;
+        return tokens;
+      }
     } // Otherwise, the input must be a stream
     else {
-        this._pendingBuffer = null;
-        if (typeof input.setEncoding === 'function') input.setEncoding('utf8'); // Adds the data chunk to the buffer and parses as far as possible
+      this._pendingBuffer = null;
+      if (typeof input.setEncoding === 'function') input.setEncoding('utf8'); // Adds the data chunk to the buffer and parses as far as possible
 
-        input.on('data', data => {
-          if (this._input !== null && data.length !== 0) {
-            // Prepend any previous pending writes
-            if (this._pendingBuffer) {
-              data = Buffer.concat([this._pendingBuffer, data]);
-              this._pendingBuffer = null;
-            } // Hold if the buffer ends in an incomplete unicode sequence
+      input.on('data', data => {
+        if (this._input !== null && data.length !== 0) {
+          // Prepend any previous pending writes
+          if (this._pendingBuffer) {
+            data = Buffer.concat([this._pendingBuffer, data]);
+            this._pendingBuffer = null;
+          } // Hold if the buffer ends in an incomplete unicode sequence
 
 
-            if (data[data.length - 1] & 0x80) {
-              this._pendingBuffer = data;
-            } // Otherwise, tokenize as far as possible
-            else {
-                // Only read a BOM at the start
-                if (typeof this._input === 'undefined') this._input = this._readStartingBom(typeof data === 'string' ? data : data.toString());else this._input += data;
+          if (data[data.length - 1] & 0x80) {
+            this._pendingBuffer = data;
+          } // Otherwise, tokenize as far as possible
+          else {
+            // Only read a BOM at the start
+            if (typeof this._input === 'undefined') this._input = this._readStartingBom(typeof data === 'string' ? data : data.toString());else this._input += data;
 
-                this._tokenizeToEnd(callback, false);
-              }
+            this._tokenizeToEnd(callback, false);
           }
-        }); // Parses until the end
+        }
+      }); // Parses until the end
 
-        input.on('end', () => {
-          if (typeof this._input === 'string') this._tokenizeToEnd(callback, true);
-        });
-        input.on('error', callback);
-      }
+      input.on('end', () => {
+        if (typeof this._input === 'string') this._tokenizeToEnd(callback, true);
+      });
+      input.on('error', callback);
+    }
   }
 
 }

package/lib/N3Parser.js

@@ -303,6 +303,14 @@ class N3Parser {
         // Additional semicolons can be safely ignored
         return this._predicate !== null ? this._readPredicate : this._error('Expected predicate but got ;', token);
 
+      case '[':
+        if (this._n3Mode) {
+          // Start a new quad with a new blank node as subject
+          this._saveContext('blank', this._graph, this._subject, this._subject = this._blankNode(), null);
+
+          return this._readBlankNodeHead;
+        }
+
       case 'blank':
         if (!this._n3Mode) return this._error('Disallowed blank node as predicate', token);
 
@@ -398,12 +406,13 @@ class N3Parser {
 
     const empty = this._predicate === null;
 
-    this._restoreContext(); // If the blank node was the subject, continue reading the predicate
+    this._restoreContext(); // If the blank node was the object, restore previous context and read punctuation
 
 
-    if (this._object === null) // If the blank node was empty, it could be a named graph label
-      return empty ? this._readPredicateOrNamedGraph : this._readPredicateAfterBlank; // If the blank node was the object, restore previous context and read punctuation
-    else return this._getContextEndReader();
+    if (this._object !== null) return this._getContextEndReader(); // If the blank node was the predicate, continue reading the object
+    else if (this._predicate !== null) return this._readObject; // If the blank node was the subject, continue reading the predicate
+    else // If the blank node was empty, it could be a named graph label
+      return empty ? this._readPredicateOrNamedGraph : this._readPredicateAfterBlank;
   } // ### `_readPredicateAfterBlank` reads a predicate after an anonymous blank node
 
 
@@ -464,10 +473,10 @@ class N3Parser {
           if (this._subject === this.RDF_NIL) return next;
         } // The list was in the parent context's object
         else {
-            next = this._getContextEndReader(); // No list tail if this was an empty list
+          next = this._getContextEndReader(); // No list tail if this was an empty list
 
-            if (this._object === this.RDF_NIL) return next;
-          } // Close the list by making the head nil
+          if (this._object === this.RDF_NIL) return next;
+        } // Close the list by making the head nil
 
 
         list = this.RDF_NIL;
@@ -480,9 +489,9 @@ class N3Parser {
           next = this._readListItemDataTypeOrLang;
         } // Pre-datatyped string literal (prefix stores the datatype)
         else {
-            item = this._literal(token.value, this._namedNode(token.prefix));
-            next = this._getContextEndReader();
-          }
+          item = this._literal(token.value, this._namedNode(token.prefix));
+          next = this._getContextEndReader();
+        }
 
         break;
 
@@ -586,9 +595,9 @@ class N3Parser {
 
     if (completed.token === null) return this._getContextEndReader(); // Otherwise, consume the token now
     else {
-        this._readCallback = this._getContextEndReader();
-        return this._readCallback(completed.token);
-      }
+      this._readCallback = this._getContextEndReader();
+      return this._readCallback(completed.token);
+    }
   } // ### `_readFormulaTail` reads the end of a formula
 
 
@@ -768,12 +777,12 @@ class N3Parser {
 
     if (!this._explicitQuantifiers) this._quantified[entity.id] = this._quantifier(this._blankNode().value); // With explicit quantifiers, output the reified quantifier
     else {
-        // If this is the first item, start a new quantifier list
-        if (this._subject === null) this._emit(this._graph || this.DEFAULTGRAPH, this._predicate, this._subject = this._blankNode(), this.QUANTIFIERS_GRAPH); // Otherwise, continue the previous list
-        else this._emit(this._subject, this.RDF_REST, this._subject = this._blankNode(), this.QUANTIFIERS_GRAPH); // Output the list item
+      // If this is the first item, start a new quantifier list
+      if (this._subject === null) this._emit(this._graph || this.DEFAULTGRAPH, this._predicate, this._subject = this._blankNode(), this.QUANTIFIERS_GRAPH); // Otherwise, continue the previous list
+      else this._emit(this._subject, this.RDF_REST, this._subject = this._blankNode(), this.QUANTIFIERS_GRAPH); // Output the list item
 
-        this._emit(this._subject, this.RDF_FIRST, entity, this.QUANTIFIERS_GRAPH);
-      }
+      this._emit(this._subject, this.RDF_FIRST, entity, this.QUANTIFIERS_GRAPH);
+    }
     return this._readQuantifierPunctuation;
   } // Reads punctuation from a @forSome or @forAll statement
 
@@ -782,17 +791,17 @@ class N3Parser {
     // Read more quantifiers
     if (token.type === ',') return this._readQuantifierList; // End of the quantifier list
     else {
-        // With explicit quantifiers, close the quantifier list
-        if (this._explicitQuantifiers) {
-          this._emit(this._subject, this.RDF_REST, this.RDF_NIL, this.QUANTIFIERS_GRAPH);
+      // With explicit quantifiers, close the quantifier list
+      if (this._explicitQuantifiers) {
+        this._emit(this._subject, this.RDF_REST, this.RDF_NIL, this.QUANTIFIERS_GRAPH);
 
-          this._subject = null;
-        } // Read a dot
+        this._subject = null;
+      } // Read a dot
 
 
-        this._readCallback = this._getContextEndReader();
-        return this._readCallback(token);
-      }
+      this._readCallback = this._getContextEndReader();
+      return this._readCallback(token);
+    }
   } // ### `_getPathReader` reads a potential path and then resumes with the given function
 
 
@@ -889,9 +898,9 @@ class N3Parser {
       return this._readPredicate;
     } // If the triple was the object, read context end.
     else {
-        this._object = quad;
-        return this._getContextEndReader();
-      }
+      this._object = quad;
+      return this._getContextEndReader();
+    }
   } // ### `_getContextEndReader` gets the next reader function at the end of a context
 
 

package/lib/N3Store.js

@@ -677,10 +677,10 @@ class N3Store {
       while (this._ids[name]) name = suggestedName + index++;
     } // Generate a generic blank node name
     else {
-        do {
-          name = `_:b${this._blankNodeIndex++}`;
-        } while (this._ids[name]);
-      } // Add the blank node to the entities, avoiding the generation of duplicates
+      do {
+        name = `_:b${this._blankNodeIndex++}`;
+      } while (this._ids[name]);
+    } // Add the blank node to the entities, avoiding the generation of duplicates
 
 
     this._ids[name] = ++this._id;
@@ -728,16 +728,16 @@ class N3Store {
           quad = subjectQuads[i];
           if (!quad.graph.equals(graph)) malformed = onError(current, 'not confined to single graph');else if (head) malformed = onError(current, 'has non-list arcs out'); // one rdf:first
           else if (quad.predicate.value === _IRIs.default.rdf.first) {
-              if (first) malformed = onError(current, 'has multiple rdf:first arcs');else toRemove.push(first = quad);
-            } // one rdf:rest
-            else if (quad.predicate.value === _IRIs.default.rdf.rest) {
-                if (rest) malformed = onError(current, 'has multiple rdf:rest arcs');else toRemove.push(rest = quad);
-              } // alien triple
-              else if (objectQuads.length) malformed = onError(current, 'can\'t be subject and object');else {
-                  head = quad; // e.g. { (1 2 3) :p :o }
-
-                  headPos = 'subject';
-                }
+            if (first) malformed = onError(current, 'has multiple rdf:first arcs');else toRemove.push(first = quad);
+          } // one rdf:rest
+          else if (quad.predicate.value === _IRIs.default.rdf.rest) {
+            if (rest) malformed = onError(current, 'has multiple rdf:rest arcs');else toRemove.push(rest = quad);
+          } // alien triple
+          else if (objectQuads.length) malformed = onError(current, 'can\'t be subject and object');else {
+            head = quad; // e.g. { (1 2 3) :p :o }
+
+            headPos = 'subject';
+          }
         } // { :s :p (1 2) } arrives here with no head
         // { (1 2) :p :o } arrives here with head set to the list.
 
@@ -746,12 +746,12 @@ class N3Store {
           quad = objectQuads[i];
           if (head) malformed = onError(current, 'can\'t have coreferences'); // one rdf:rest
           else if (quad.predicate.value === _IRIs.default.rdf.rest) {
-              if (parent) malformed = onError(current, 'has incoming rdf:rest arcs');else parent = quad;
-            } else {
-              head = quad; // e.g. { :s :p (1 2) }
+            if (parent) malformed = onError(current, 'has incoming rdf:rest arcs');else parent = quad;
+          } else {
+            head = quad; // e.g. { :s :p (1 2) }
 
-              headPos = 'object';
-            }
+            headPos = 'object';
+          }
         } // Store the list item and continue with parent
 
 

package/lib/N3Util.js

@@ -3,12 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.isNamedNode = isNamedNode;
+exports.inDefaultGraph = inDefaultGraph;
 exports.isBlankNode = isBlankNode;
+exports.isDefaultGraph = isDefaultGraph;
 exports.isLiteral = isLiteral;
+exports.isNamedNode = isNamedNode;
 exports.isVariable = isVariable;
-exports.isDefaultGraph = isDefaultGraph;
-exports.inDefaultGraph = inDefaultGraph;
 exports.prefix = prefix;
 exports.prefixes = prefixes;
 

package/lib/N3Writer.js

@@ -247,7 +247,7 @@ class N3Writer {
     // The quad was given as an object, so shift parameters
     if (object === undefined) this._writeQuad(subject.subject, subject.predicate, subject.object, subject.graph, predicate); // The optional `graph` parameter was not provided
     else if (typeof graph === 'function') this._writeQuad(subject, predicate, object, DEFAULTGRAPH, graph); // The `graph` parameter was provided
-      else this._writeQuad(subject, predicate, object, graph || DEFAULTGRAPH, done);
+    else this._writeQuad(subject, predicate, object, graph || DEFAULTGRAPH, done);
   } // ### `addQuads` adds the quads to the output stream
 
 
@@ -312,10 +312,10 @@ class N3Writer {
 
     if (predicate === undefined) children = []; // Blank node passed as blank(Term("predicate"), Term("object"))
     else if (predicate.termType) children = [{
-        predicate: predicate,
-        object: object
-      }]; // Blank node passed as blank({ predicate: predicate, object: object })
-      else if (!('length' in predicate)) children = [predicate];
+      predicate: predicate,
+      object: object
+    }]; // Blank node passed as blank({ predicate: predicate, object: object })
+    else if (!('length' in predicate)) children = [predicate];
 
     switch (length = children.length) {
       // Generate an empty blank node
@@ -336,9 +336,9 @@ class N3Writer {
 
           if (child.predicate.equals(predicate)) contents += `, ${this._encodeObject(child.object)}`; // Otherwise, write the predicate and the object
           else {
-              contents += `${(i ? ';\n  ' : '\n  ') + this._encodePredicate(child.predicate)} ${this._encodeObject(child.object)}`;
-              predicate = child.predicate;
-            }
+            contents += `${(i ? ';\n  ' : '\n  ') + this._encodePredicate(child.predicate)} ${this._encodeObject(child.object)}`;
+            predicate = child.predicate;
+          }
         }
 
         return new SerializedTerm(`${contents}\n]`);
@@ -398,9 +398,9 @@ function characterReplacer(character) {
       result = '\\u0000'.substr(0, 6 - result.length) + result;
     } // Replace a surrogate pair with its 8-bit unicode escape sequence
     else {
-        result = ((character.charCodeAt(0) - 0xD800) * 0x400 + character.charCodeAt(1) + 0x2400).toString(16);
-        result = '\\U00000000'.substr(0, 10 - result.length) + result;
-      }
+      result = ((character.charCodeAt(0) - 0xD800) * 0x400 + character.charCodeAt(1) + 0x2400).toString(16);
+      result = '\\U00000000'.substr(0, 10 - result.length) + result;
+    }
   }
 
   return result;

package/lib/index.js

@@ -3,94 +3,95 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "Lexer", {
+Object.defineProperty(exports, "BlankNode", {
   enumerable: true,
   get: function () {
-    return _N3Lexer.default;
+    return _N3DataFactory.BlankNode;
   }
 });
-Object.defineProperty(exports, "Parser", {
+Object.defineProperty(exports, "DataFactory", {
   enumerable: true,
   get: function () {
-    return _N3Parser.default;
+    return _N3DataFactory.default;
   }
 });
-Object.defineProperty(exports, "Writer", {
+Object.defineProperty(exports, "DefaultGraph", {
   enumerable: true,
   get: function () {
-    return _N3Writer.default;
+    return _N3DataFactory.DefaultGraph;
   }
 });
-Object.defineProperty(exports, "Store", {
+Object.defineProperty(exports, "Lexer", {
   enumerable: true,
   get: function () {
-    return _N3Store.default;
+    return _N3Lexer.default;
   }
 });
-Object.defineProperty(exports, "StreamParser", {
+Object.defineProperty(exports, "Literal", {
   enumerable: true,
   get: function () {
-    return _N3StreamParser.default;
+    return _N3DataFactory.Literal;
   }
 });
-Object.defineProperty(exports, "StreamWriter", {
+Object.defineProperty(exports, "NamedNode", {
   enumerable: true,
   get: function () {
-    return _N3StreamWriter.default;
+    return _N3DataFactory.NamedNode;
   }
 });
-Object.defineProperty(exports, "DataFactory", {
+Object.defineProperty(exports, "Parser", {
   enumerable: true,
   get: function () {
-    return _N3DataFactory.default;
+    return _N3Parser.default;
   }
 });
-Object.defineProperty(exports, "Term", {
+Object.defineProperty(exports, "Quad", {
   enumerable: true,
   get: function () {
-    return _N3DataFactory.Term;
+    return _N3DataFactory.Quad;
   }
 });
-Object.defineProperty(exports, "NamedNode", {
+Object.defineProperty(exports, "Store", {
   enumerable: true,
   get: function () {
-    return _N3DataFactory.NamedNode;
+    return _N3Store.default;
   }
 });
-Object.defineProperty(exports, "Literal", {
+Object.defineProperty(exports, "StreamParser", {
   enumerable: true,
   get: function () {
-    return _N3DataFactory.Literal;
+    return _N3StreamParser.default;
   }
 });
-Object.defineProperty(exports, "BlankNode", {
+Object.defineProperty(exports, "StreamWriter", {
   enumerable: true,
   get: function () {
-    return _N3DataFactory.BlankNode;
+    return _N3StreamWriter.default;
   }
 });
-Object.defineProperty(exports, "Variable", {
+Object.defineProperty(exports, "Term", {
   enumerable: true,
   get: function () {
-    return _N3DataFactory.Variable;
+    return _N3DataFactory.Term;
   }
 });
-Object.defineProperty(exports, "DefaultGraph", {
+Object.defineProperty(exports, "Triple", {
   enumerable: true,
   get: function () {
-    return _N3DataFactory.DefaultGraph;
+    return _N3DataFactory.Triple;
   }
 });
-Object.defineProperty(exports, "Quad", {
+exports.Util = void 0;
+Object.defineProperty(exports, "Variable", {
   enumerable: true,
   get: function () {
-    return _N3DataFactory.Quad;
+    return _N3DataFactory.Variable;
   }
 });
-Object.defineProperty(exports, "Triple", {
+Object.defineProperty(exports, "Writer", {
   enumerable: true,
   get: function () {
-    return _N3DataFactory.Triple;
+    return _N3Writer.default;
   }
 });
 Object.defineProperty(exports, "termFromId", {
@@ -105,7 +106,6 @@ Object.defineProperty(exports, "termToId", {
     return _N3DataFactory.termToId;
   }
 });
-exports.Util = void 0;
 
 var _N3Lexer = _interopRequireDefault(require("./N3Lexer"));
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n3",
-  "version": "1.11.1",
+  "version": "1.11.2",
   "description": "Lightning fast, asynchronous, streaming Turtle / N3 / RDF library.",
   "author": "Ruben Verborgh <ruben.verborgh@gmail.com>",
   "keywords": [
@@ -27,10 +27,10 @@
     "readable-stream": "^3.6.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.5.5",
-    "@babel/core": "^7.5.5",
-    "@babel/preset-env": "^7.5.5",
-    "@babel/register": "^7.5.5",
+    "@babel/cli": "^7.16.0",
+    "@babel/core": "^7.16.0",
+    "@babel/preset-env": "^7.16.0",
+    "@babel/register": "^7.16.0",
     "arrayify-stream": "^1.0.0",
     "chai": "^4.0.2",
     "chai-things": "^0.2.0",

package/src/N3Parser.js

@@ -272,6 +272,13 @@ export default class N3Parser {
       // Additional semicolons can be safely ignored
       return this._predicate !== null ? this._readPredicate :
              this._error('Expected predicate but got ;', token);
+    case '[':
+      if (this._n3Mode) {
+        // Start a new quad with a new blank node as subject
+        this._saveContext('blank', this._graph, this._subject,
+                          this._subject = this._blankNode(), null);
+        return this._readBlankNodeHead;
+      }
     case 'blank':
       if (!this._n3Mode)
         return this._error('Disallowed blank node as predicate', token);
@@ -368,13 +375,16 @@ export default class N3Parser {
     // Restore the parent context containing this blank node
     const empty = this._predicate === null;
     this._restoreContext();
+    // If the blank node was the object, restore previous context and read punctuation
+    if (this._object !== null)
+      return this._getContextEndReader();
+    // If the blank node was the predicate, continue reading the object
+    else if (this._predicate !== null)
+      return this._readObject;
     // If the blank node was the subject, continue reading the predicate
-    if (this._object === null)
+    else
       // If the blank node was empty, it could be a named graph label
       return empty ? this._readPredicateOrNamedGraph : this._readPredicateAfterBlank;
-    // If the blank node was the object, restore previous context and read punctuation
-    else
-      return this._getContextEndReader();
   }
 
   // ### `_readPredicateAfterBlank` reads a predicate after an anonymous blank node