n3 1.13.0 → 1.16.0

package/lib/N3DataFactory.js

@@ -48,12 +48,6 @@ class Term {
 
   get value() {
     return this.id;
-  } // ### Implement hashCode for Immutable.js, since we implement `equals`
-  // https://immutable-js.com/docs/v4.0.0/ValueObject/#hashCode()
-
-
-  get hashCode() {
-    return 0;
   } // ### Returns whether this object represents the same term as the other
 
 
@@ -63,6 +57,12 @@ class Term {
     if (other instanceof Term) return this.id === other.id; // Otherwise, compare term type and value
 
     return !!other && this.termType === other.termType && this.value === other.value;
+  } // ### Implement hashCode for Immutable.js, since we implement `equals`
+  // https://immutable-js.com/docs/v4.0.0/ValueObject/#hashCode()
+
+
+  hashCode() {
+    return 0;
   } // ### Returns a plain object representation of this term
 
 

package/lib/N3Lexer.js

@@ -109,7 +109,7 @@ class N3Lexer {
   _tokenizeToEnd(callback, inputFinished) {
     // Continue parsing as far as possible; the loop will return eventually
     let input = this._input;
-    const outputComments = this._comments;
+    let currentLineLength = input.length;
 
     while (true) {
       // Count and skip whitespace lines
@@ -117,14 +117,10 @@ class N3Lexer {
 
       while (whiteSpaceMatch = this._newline.exec(input)) {
         // Try to find a comment
-        if (outputComments && (comment = this._comment.exec(whiteSpaceMatch[0]))) callback(null, {
-          line: this._line,
-          type: 'comment',
-          value: comment[1],
-          prefix: ''
-        }); // Advance the input
+        if (this._comments && (comment = this._comment.exec(whiteSpaceMatch[0]))) emitToken('comment', comment[1], '', this._line, whiteSpaceMatch[0].length); // Advance the input
 
         input = input.substr(whiteSpaceMatch[0].length, input.length);
+        currentLineLength = input.length;
         this._line++;
       } // Skip whitespace on current line
 
@@ -135,18 +131,9 @@ class N3Lexer {
         // If the input is finished, emit EOF
         if (inputFinished) {
           // Try to find a final comment
-          if (outputComments && (comment = this._comment.exec(input))) callback(null, {
-            line: this._line,
-            type: 'comment',
-            value: comment[1],
-            prefix: ''
-          });
-          callback(input = null, {
-            line: this._line,
-            type: 'eof',
-            value: '',
-            prefix: ''
-          });
+          if (this._comments && (comment = this._comment.exec(input))) emitToken('comment', comment[1], '', this._line, input.length);
+          input = null;
+          emitToken('eof', '', '', this._line, 0);
         }
 
         return this._input = input;
@@ -376,17 +363,28 @@ class N3Lexer {
       } // Emit the parsed token
 
 
-      const token = {
-        line: line,
-        type: type,
-        value: value,
-        prefix: prefix
-      };
-      callback(null, token);
+      const length = matchLength || match[0].length;
+      const token = emitToken(type, value, prefix, line, length);
       this.previousToken = token;
       this._previousMarker = type; // Advance to next part to tokenize
 
-      input = input.substr(matchLength || match[0].length, input.length);
+      input = input.substr(length, input.length);
+    } // Emits the token through the callback
+
+
+    function emitToken(type, value, prefix, line, length) {
+      const start = input ? currentLineLength - input.length : currentLineLength;
+      const end = start + length;
+      const token = {
+        type,
+        value,
+        prefix,
+        line,
+        start,
+        end
+      };
+      callback(null, token);
+      return token;
     } // Signals the syntax error through the callback
 
 

package/lib/N3Store.js

@@ -92,17 +92,15 @@ class N3Store {
   // `name0`, `name1`, and `name2` are the names of the keys at each level,
   // used when reconstructing the resulting quad
   // (for instance: _subject_, _predicate_, and _object_).
-  // Finally, `graph` will be the graph of the created quads.
-  // If `callback` is given, each result is passed through it
-  // and iteration halts when it returns truthy for any quad.
-  // If instead `array` is given, each result is added to the array.
+  // Finally, `graphId` will be the graph of the created quads.
 
 
-  _findInIndex(index0, key0, key1, key2, name0, name1, name2, graph, callback, array) {
+  *_findInIndex(index0, key0, key1, key2, name0, name1, name2, graphId) {
     let tmp, index1, index2; // Depending on the number of variables, keys or reverse index are faster
 
     const varCount = !key0 + !key1 + !key2,
-          entityKeys = varCount > 1 ? Object.keys(this._ids) : this._entities; // If a key is specified, use only that part of index 0.
+          entityKeys = varCount > 1 ? Object.keys(this._ids) : this._entities;
+    const graph = (0, _N3DataFactory.termFromId)(graphId, this._factory); // If a key is specified, use only that part of index 0.
 
     if (key0) (tmp = index0, index0 = {})[key0] = tmp[key0];
 
@@ -129,17 +127,12 @@ class N3Store {
               parts[name0] = (0, _N3DataFactory.termFromId)(entity0, this._factory);
               parts[name1] = (0, _N3DataFactory.termFromId)(entity1, this._factory);
               parts[name2] = (0, _N3DataFactory.termFromId)(entityKeys[values[l]], this._factory);
-
-              const quad = this._factory.quad(parts.subject, parts.predicate, parts.object, (0, _N3DataFactory.termFromId)(graph, this._factory));
-
-              if (array) array.push(quad);else if (callback(quad)) return true;
+              yield this._factory.quad(parts.subject, parts.predicate, parts.object, graph);
             }
           }
         }
       }
     }
-
-    return array;
   } // ### `_loop` executes the callback on all keys of index 0
 
 
@@ -288,13 +281,17 @@ class N3Store {
   delete(quad) {
     this.removeQuad(quad);
     return this;
-  } // ### `has` determines whether a dataset includes a certain quad.
-  // Returns true or false as appropriate.
+  } // ### `has` determines whether a dataset includes a certain quad or quad pattern.
 
 
-  has(quad) {
-    const quads = this.getQuads(quad.subject, quad.predicate, quad.object, quad.graph);
-    return quads.length !== 0;
+  has(subjectOrQuad, predicate, object, graph) {
+    if (subjectOrQuad && subjectOrQuad.subject) ({
+      subject: subjectOrQuad,
+      predicate,
+      object,
+      graph
+    } = subjectOrQuad);
+    return !this.readQuads(subjectOrQuad, predicate, object, graph).next().done;
   } // ### `import` adds a stream of quads to the store
 
 
@@ -356,7 +353,7 @@ class N3Store {
     });
 
     stream._read = () => {
-      for (const quad of this.getQuads(subject, predicate, object, graph)) stream.push(quad);
+      for (const quad of this.readQuads(subject, predicate, object, graph)) stream.push(quad);
 
       stream.push(null);
     };
@@ -372,19 +369,24 @@ class N3Store {
 
 
   getQuads(subject, predicate, object, graph) {
+    return [...this.readQuads(subject, predicate, object, graph)];
+  } // ### `readQuads` returns an generator of quads matching a pattern.
+  // Setting any field to `undefined` or `null` indicates a wildcard.
+
+
+  *readQuads(subject, predicate, object, graph) {
     // Convert terms to internal string representation
     subject = subject && (0, _N3DataFactory.termToId)(subject);
     predicate = predicate && (0, _N3DataFactory.termToId)(predicate);
     object = object && (0, _N3DataFactory.termToId)(object);
     graph = graph && (0, _N3DataFactory.termToId)(graph);
 
-    const quads = [],
-          graphs = this._getGraphs(graph),
+    const graphs = this._getGraphs(graph),
           ids = this._ids;
 
     let content, subjectId, predicateId, objectId; // Translate IRIs to internal index keys.
 
-    if (isString(subject) && !(subjectId = ids[subject]) || isString(predicate) && !(predicateId = ids[predicate]) || isString(object) && !(objectId = ids[object])) return quads;
+    if (isString(subject) && !(subjectId = ids[subject]) || isString(predicate) && !(predicateId = ids[predicate]) || isString(object) && !(objectId = ids[object])) return;
 
     for (const graphId in graphs) {
       // Only if the specified graph contains triples, there can be results
@@ -392,16 +394,14 @@ class N3Store {
         // Choose the optimal index, based on what fields are present
         if (subjectId) {
           if (objectId) // If subject and object are given, the object index will be the fastest
-            this._findInIndex(content.objects, objectId, subjectId, predicateId, 'object', 'subject', 'predicate', graphId, null, quads);else // If only subject and possibly predicate are given, the subject index will be the fastest
-            this._findInIndex(content.subjects, subjectId, predicateId, null, 'subject', 'predicate', 'object', graphId, null, quads);
+            yield* this._findInIndex(content.objects, objectId, subjectId, predicateId, 'object', 'subject', 'predicate', graphId, null, true);else // If only subject and possibly predicate are given, the subject index will be the fastest
+            yield* this._findInIndex(content.subjects, subjectId, predicateId, null, 'subject', 'predicate', 'object', graphId, null, true);
         } else if (predicateId) // If only predicate and possibly object are given, the predicate index will be the fastest
-          this._findInIndex(content.predicates, predicateId, objectId, null, 'predicate', 'object', 'subject', graphId, null, quads);else if (objectId) // If only object is given, the object index will be the fastest
-          this._findInIndex(content.objects, objectId, null, null, 'object', 'subject', 'predicate', graphId, null, quads);else // If nothing is given, iterate subjects and predicates first
-          this._findInIndex(content.subjects, null, null, null, 'subject', 'predicate', 'object', graphId, null, quads);
+          yield* this._findInIndex(content.predicates, predicateId, objectId, null, 'predicate', 'object', 'subject', graphId, null, true);else if (objectId) // If only object is given, the object index will be the fastest
+          yield* this._findInIndex(content.objects, objectId, null, null, 'object', 'subject', 'predicate', graphId, null, true);else // If nothing is given, iterate subjects and predicates first
+          yield* this._findInIndex(content.subjects, null, null, null, 'subject', 'predicate', 'object', graphId, null, true);
       }
     }
-
-    return quads;
   } // ### `match` returns a new dataset that is comprised of all quads in the current instance matching the given arguments.
   // The logic described in Quad Matching is applied for each quad in this dataset to check if it should be included in the output dataset.
   // Note: This method always returns a new DatasetCore, even if that dataset contains no quads.
@@ -480,45 +480,7 @@ class N3Store {
 
 
   some(callback, subject, predicate, object, graph) {
-    // Convert terms to internal string representation
-    subject = subject && (0, _N3DataFactory.termToId)(subject);
-    predicate = predicate && (0, _N3DataFactory.termToId)(predicate);
-    object = object && (0, _N3DataFactory.termToId)(object);
-    graph = graph && (0, _N3DataFactory.termToId)(graph);
-
-    const graphs = this._getGraphs(graph),
-          ids = this._ids;
-
-    let content, subjectId, predicateId, objectId; // Translate IRIs to internal index keys.
-
-    if (isString(subject) && !(subjectId = ids[subject]) || isString(predicate) && !(predicateId = ids[predicate]) || isString(object) && !(objectId = ids[object])) return false;
-
-    for (const graphId in graphs) {
-      // Only if the specified graph contains triples, there can be results
-      if (content = graphs[graphId]) {
-        // Choose the optimal index, based on what fields are present
-        if (subjectId) {
-          if (objectId) {
-            // If subject and object are given, the object index will be the fastest
-            if (this._findInIndex(content.objects, objectId, subjectId, predicateId, 'object', 'subject', 'predicate', graphId, callback, null)) return true;
-          } else // If only subject and possibly predicate are given, the subject index will be the fastest
-            if (this._findInIndex(content.subjects, subjectId, predicateId, null, 'subject', 'predicate', 'object', graphId, callback, null)) return true;
-        } else if (predicateId) {
-          // If only predicate and possibly object are given, the predicate index will be the fastest
-          if (this._findInIndex(content.predicates, predicateId, objectId, null, 'predicate', 'object', 'subject', graphId, callback, null)) {
-            return true;
-          }
-        } else if (objectId) {
-          // If only object is given, the object index will be the fastest
-          if (this._findInIndex(content.objects, objectId, null, null, 'object', 'subject', 'predicate', graphId, callback, null)) {
-            return true;
-          }
-        } else // If nothing is given, iterate subjects and predicates first
-          if (this._findInIndex(content.subjects, null, null, null, 'subject', 'predicate', 'object', graphId, callback, null)) {
-            return true;
-          }
-      }
-    }
+    for (const quad of this.readQuads(subject, predicate, object, graph)) if (callback(quad)) return true;
 
     return false;
   } // ### `getSubjects` returns all subjects that match the pattern.
@@ -772,7 +734,7 @@ class N3Store {
 
 
   *[Symbol.iterator]() {
-    yield* this.getQuads();
+    yield* this.readQuads();
   }
 
 } // Determines whether the argument is a string
@@ -825,7 +787,7 @@ class DatasetCoreAndReadableStream extends _readableStream.Readable {
   }
 
   _read() {
-    for (const quad of this.filtered.getQuads()) this.push(quad);
+    for (const quad of this) this.push(quad);
 
     this.push(null);
   }
@@ -847,7 +809,7 @@ class DatasetCoreAndReadableStream extends _readableStream.Readable {
   }
 
   *[Symbol.iterator]() {
-    yield* this.filtered.getQuads();
+    yield* this._filtered || this.n3Store.readQuads(this.subject, this.predicate, this.object, this.graph);
   }
 
 }

package/lib/N3Util.js

@@ -50,7 +50,7 @@ function inDefaultGraph(quad) {
 
 function prefix(iri, factory) {
   return prefixes({
-    '': iri
+    '': iri.value || iri
   }, factory)('');
 } // Creates a function that allows registering and expanding prefixes
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n3",
-  "version": "1.13.0",
+  "version": "1.16.0",
   "description": "Lightning fast, asynchronous, streaming Turtle / N3 / RDF library.",
   "author": "Ruben Verborgh <ruben.verborgh@gmail.com>",
   "keywords": [

package/src/N3DataFactory.js

@@ -35,12 +35,6 @@ export class Term {
     return this.id;
   }
 
-  // ### Implement hashCode for Immutable.js, since we implement `equals`
-  // https://immutable-js.com/docs/v4.0.0/ValueObject/#hashCode()
-  get hashCode() {
-    return 0;
-  }
-
   // ### Returns whether this object represents the same term as the other
   equals(other) {
     // If both terms were created by this library,
@@ -52,6 +46,12 @@ export class Term {
                       this.value    === other.value;
   }
 
+  // ### Implement hashCode for Immutable.js, since we implement `equals`
+  // https://immutable-js.com/docs/v4.0.0/ValueObject/#hashCode()
+  hashCode() {
+    return 0;
+  }
+
   // ### Returns a plain object representation of this term
   toJSON() {
     return {

package/src/N3Lexer.js

@@ -78,16 +78,17 @@ export default class N3Lexer {
   _tokenizeToEnd(callback, inputFinished) {
     // Continue parsing as far as possible; the loop will return eventually
     let input = this._input;
-    const outputComments = this._comments;
+    let currentLineLength = input.length;
     while (true) {
       // Count and skip whitespace lines
       let whiteSpaceMatch, comment;
       while (whiteSpaceMatch = this._newline.exec(input)) {
         // Try to find a comment
-        if (outputComments && (comment = this._comment.exec(whiteSpaceMatch[0])))
-          callback(null, { line: this._line, type: 'comment', value: comment[1], prefix: '' });
+        if (this._comments && (comment = this._comment.exec(whiteSpaceMatch[0])))
+          emitToken('comment', comment[1], '', this._line, whiteSpaceMatch[0].length);
         // Advance the input
         input = input.substr(whiteSpaceMatch[0].length, input.length);
+        currentLineLength = input.length;
         this._line++;
       }
       // Skip whitespace on current line
@@ -99,9 +100,10 @@ export default class N3Lexer {
         // If the input is finished, emit EOF
         if (inputFinished) {
           // Try to find a final comment
-          if (outputComments && (comment = this._comment.exec(input)))
-            callback(null, { line: this._line, type: 'comment', value: comment[1], prefix: '' });
-          callback(input = null, { line: this._line, type: 'eof', value: '', prefix: '' });
+          if (this._comments && (comment = this._comment.exec(input)))
+            emitToken('comment', comment[1], '', this._line, input.length);
+          input = null;
+          emitToken('eof', '', '', this._line, 0);
         }
         return this._input = input;
       }
@@ -345,14 +347,23 @@ export default class N3Lexer {
       }
 
       // Emit the parsed token
-      const token = { line: line, type: type, value: value, prefix: prefix };
-      callback(null, token);
+      const length = matchLength || match[0].length;
+      const token = emitToken(type, value, prefix, line, length);
       this.previousToken = token;
       this._previousMarker = type;
+
       // Advance to next part to tokenize
-      input = input.substr(matchLength || match[0].length, input.length);
+      input = input.substr(length, input.length);
     }
 
+    // Emits the token through the callback
+    function emitToken(type, value, prefix, line, length) {
+      const start = input ? currentLineLength - input.length : currentLineLength;
+      const end = start + length;
+      const token = { type, value, prefix, line, start, end };
+      callback(null, token);
+      return token;
+    }
     // Signals the syntax error through the callback
     function reportSyntaxError(self) { callback(self._syntaxError(/^\S*/.exec(input)[0])); }
   }

package/src/N3Store.js

@@ -84,15 +84,13 @@ export default class N3Store {
   // `name0`, `name1`, and `name2` are the names of the keys at each level,
   // used when reconstructing the resulting quad
   // (for instance: _subject_, _predicate_, and _object_).
-  // Finally, `graph` will be the graph of the created quads.
-  // If `callback` is given, each result is passed through it
-  // and iteration halts when it returns truthy for any quad.
-  // If instead `array` is given, each result is added to the array.
-  _findInIndex(index0, key0, key1, key2, name0, name1, name2, graph, callback, array) {
+  // Finally, `graphId` will be the graph of the created quads.
+  *_findInIndex(index0, key0, key1, key2, name0, name1, name2, graphId) {
     let tmp, index1, index2;
     // Depending on the number of variables, keys or reverse index are faster
     const varCount = !key0 + !key1 + !key2,
         entityKeys = varCount > 1 ? Object.keys(this._ids) : this._entities;
+    const graph = termFromId(graphId, this._factory);
 
     // If a key is specified, use only that part of index 0.
     if (key0) (tmp = index0, index0 = {})[key0] = tmp[key0];
@@ -114,18 +112,12 @@ export default class N3Store {
               parts[name0] = termFromId(entity0, this._factory);
               parts[name1] = termFromId(entity1, this._factory);
               parts[name2] = termFromId(entityKeys[values[l]], this._factory);
-              const quad = this._factory.quad(
-                parts.subject, parts.predicate, parts.object, termFromId(graph, this._factory));
-              if (array)
-                array.push(quad);
-              else if (callback(quad))
-                return true;
+              yield this._factory.quad(parts.subject, parts.predicate, parts.object, graph);
             }
           }
         }
       }
     }
-    return array;
   }
 
   // ### `_loop` executes the callback on all keys of index 0
@@ -274,11 +266,11 @@ export default class N3Store {
     return this;
   }
 
-  // ### `has` determines whether a dataset includes a certain quad.
-  // Returns true or false as appropriate.
-  has(quad) {
-    const quads = this.getQuads(quad.subject, quad.predicate, quad.object, quad.graph);
-    return quads.length !== 0;
+  // ### `has` determines whether a dataset includes a certain quad or quad pattern.
+  has(subjectOrQuad, predicate, object, graph) {
+    if (subjectOrQuad && subjectOrQuad.subject)
+      ({ subject: subjectOrQuad, predicate, object, graph } = subjectOrQuad);
+    return !this.readQuads(subjectOrQuad, predicate, object, graph).next().done;
   }
 
   // ### `import` adds a stream of quads to the store
@@ -341,7 +333,7 @@ export default class N3Store {
     const stream = new Readable({ objectMode: true });
 
     stream._read = () => {
-      for (const quad of this.getQuads(subject, predicate, object, graph))
+      for (const quad of this.readQuads(subject, predicate, object, graph))
         stream.push(quad);
       stream.push(null);
     };
@@ -357,20 +349,26 @@ export default class N3Store {
   // ### `getQuads` returns an array of quads matching a pattern.
   // Setting any field to `undefined` or `null` indicates a wildcard.
   getQuads(subject, predicate, object, graph) {
+    return [...this.readQuads(subject, predicate, object, graph)];
+  }
+
+  // ### `readQuads` returns an generator of quads matching a pattern.
+  // Setting any field to `undefined` or `null` indicates a wildcard.
+  *readQuads(subject, predicate, object, graph) {
     // Convert terms to internal string representation
     subject = subject && termToId(subject);
     predicate = predicate && termToId(predicate);
     object = object && termToId(object);
     graph = graph && termToId(graph);
 
-    const quads = [], graphs = this._getGraphs(graph), ids = this._ids;
+    const graphs = this._getGraphs(graph), ids = this._ids;
     let content, subjectId, predicateId, objectId;
 
     // Translate IRIs to internal index keys.
     if (isString(subject)   && !(subjectId   = ids[subject])   ||
         isString(predicate) && !(predicateId = ids[predicate]) ||
         isString(object)    && !(objectId    = ids[object]))
-      return quads;
+      return;
 
     for (const graphId in graphs) {
       // Only if the specified graph contains triples, there can be results
@@ -379,28 +377,27 @@ export default class N3Store {
         if (subjectId) {
           if (objectId)
             // If subject and object are given, the object index will be the fastest
-            this._findInIndex(content.objects, objectId, subjectId, predicateId,
-                              'object', 'subject', 'predicate', graphId, null, quads);
+            yield* this._findInIndex(content.objects, objectId, subjectId, predicateId,
+                              'object', 'subject', 'predicate', graphId, null, true);
           else
             // If only subject and possibly predicate are given, the subject index will be the fastest
-            this._findInIndex(content.subjects, subjectId, predicateId, null,
-                              'subject', 'predicate', 'object', graphId, null, quads);
+            yield* this._findInIndex(content.subjects, subjectId, predicateId, null,
+                              'subject', 'predicate', 'object', graphId, null, true);
         }
         else if (predicateId)
           // If only predicate and possibly object are given, the predicate index will be the fastest
-          this._findInIndex(content.predicates, predicateId, objectId, null,
-                            'predicate', 'object', 'subject', graphId, null, quads);
+          yield* this._findInIndex(content.predicates, predicateId, objectId, null,
+                            'predicate', 'object', 'subject', graphId, null, true);
         else if (objectId)
           // If only object is given, the object index will be the fastest
-          this._findInIndex(content.objects, objectId, null, null,
-                            'object', 'subject', 'predicate', graphId, null, quads);
+          yield* this._findInIndex(content.objects, objectId, null, null,
+                            'object', 'subject', 'predicate', graphId, null, true);
         else
           // If nothing is given, iterate subjects and predicates first
-          this._findInIndex(content.subjects, null, null, null,
-                            'subject', 'predicate', 'object', graphId, null, quads);
+          yield* this._findInIndex(content.subjects, null, null, null,
+                            'subject', 'predicate', 'object', graphId, null, true);
       }
     }
-    return quads;
   }
 
   // ### `match` returns a new dataset that is comprised of all quads in the current instance matching the given arguments.
@@ -481,60 +478,9 @@ export default class N3Store {
   // and returns `true` if it returns truthy for any of them.
   // Setting any field to `undefined` or `null` indicates a wildcard.
   some(callback, subject, predicate, object, graph) {
-    // Convert terms to internal string representation
-    subject = subject && termToId(subject);
-    predicate = predicate && termToId(predicate);
-    object = object && termToId(object);
-    graph = graph && termToId(graph);
-
-    const graphs = this._getGraphs(graph), ids = this._ids;
-    let content, subjectId, predicateId, objectId;
-
-    // Translate IRIs to internal index keys.
-    if (isString(subject)   && !(subjectId   = ids[subject])   ||
-        isString(predicate) && !(predicateId = ids[predicate]) ||
-        isString(object)    && !(objectId    = ids[object]))
-      return false;
-
-    for (const graphId in graphs) {
-      // Only if the specified graph contains triples, there can be results
-      if (content = graphs[graphId]) {
-        // Choose the optimal index, based on what fields are present
-        if (subjectId) {
-          if (objectId) {
-          // If subject and object are given, the object index will be the fastest
-            if (this._findInIndex(content.objects, objectId, subjectId, predicateId,
-                                  'object', 'subject', 'predicate', graphId, callback, null))
-              return true;
-          }
-          else
-            // If only subject and possibly predicate are given, the subject index will be the fastest
-            if (this._findInIndex(content.subjects, subjectId, predicateId, null,
-                                  'subject', 'predicate', 'object', graphId, callback, null))
-              return true;
-        }
-        else if (predicateId) {
-          // If only predicate and possibly object are given, the predicate index will be the fastest
-          if (this._findInIndex(content.predicates, predicateId, objectId, null,
-                                'predicate', 'object', 'subject', graphId, callback, null)) {
-            return true;
-          }
-        }
-        else if (objectId) {
-          // If only object is given, the object index will be the fastest
-          if (this._findInIndex(content.objects, objectId, null, null,
-                                'object', 'subject', 'predicate', graphId, callback, null)) {
-            return true;
-          }
-        }
-        else
-        // If nothing is given, iterate subjects and predicates first
-        if (this._findInIndex(content.subjects, null, null, null,
-                              'subject', 'predicate', 'object', graphId, callback, null)) {
-          return true;
-        }
-      }
-    }
+    for (const quad of this.readQuads(subject, predicate, object, graph))
+      if (callback(quad))
+        return true;
     return false;
   }
 
@@ -820,7 +766,7 @@ export default class N3Store {
   // Can be used where iterables are expected: for...of loops, array spread operator,
   // `yield*`, and destructuring assignment (order is not guaranteed).
   *[Symbol.iterator]() {
-    yield* this.getQuads();
+    yield* this.readQuads();
   }
 }
 
@@ -851,7 +797,7 @@ class DatasetCoreAndReadableStream extends Readable {
   }
 
   _read() {
-    for (const quad of this.filtered.getQuads())
+    for (const quad of this)
       this.push(quad);
     this.push(null);
   }
@@ -873,6 +819,6 @@ class DatasetCoreAndReadableStream extends Readable {
   }
 
   *[Symbol.iterator]() {
-    yield* this.filtered.getQuads();
+    yield* this._filtered || this.n3Store.readQuads(this.subject, this.predicate, this.object, this.graph);
   }
 }

package/src/N3Util.js

@@ -34,7 +34,7 @@ export function inDefaultGraph(quad) {
 
 // Creates a function that prepends the given IRI to a local name
 export function prefix(iri, factory) {
-  return prefixes({ '': iri }, factory)('');
+  return prefixes({ '': iri.value || iri }, factory)('');
 }
 
 // Creates a function that allows registering and expanding prefixes