n3 1.9.0 → 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';
@@ -470,6 +470,11 @@ class N3Lexer {
       previousToken: this.previousToken
     };
     return err;
+  } // ### Strips off any starting UTF BOM mark.
+
+
+  _readStartingBom(input) {
+    return input.startsWith('\ufeff') ? input.substr(1) : input;
   } // ## Public methods
   // ### `tokenize` starts the transformation of an N3 document into an array of tokens.
   // The input can be a string or a stream.
@@ -479,49 +484,49 @@ class N3Lexer {
     this._line = 1; // If the input is a string, continuously emit tokens through the callback until the end
 
     if (typeof input === 'string') {
-      this._input = input; // If a callback was passed, asynchronously call it
+      this._input = this._readStartingBom(input); // If a callback was passed, asynchronously call it
 
       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._input = '';
-        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
-
-
-            if (data[data.length - 1] & 0x80) {
-              this._pendingBuffer = data;
-            } // Otherwise, tokenize as far as possible
-            else {
-                this._input += data;
+      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._tokenizeToEnd(callback, false);
-              }
+      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;
+
+            this._tokenizeToEnd(callback, false);
           }
-        }); // Parses until the end
+        }
+      }); // Parses until the end
 
-        input.on('end', () => {
-          if (this._input !== null) 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

@@ -13,9 +13,9 @@ var _IRIs = _interopRequireDefault(require("./IRIs"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 // **N3Store** objects store N3 quads by graph in memory.
 // ## Constructor
@@ -224,7 +224,15 @@ class N3Store {
       }
     };
   } // ## Public methods
-  // ### `addQuad` adds a new quad to the store.
+  // ### `add` adds the specified quad to the dataset.
+  // Returns the dataset instance it was called on.
+  // Existing quads, as defined in Quad.equals, will be ignored.
+
+
+  add(quad) {
+    this.addQuad(quad);
+    return this;
+  } // ### `addQuad` adds a new quad to the store.
   // Returns if the quad index has changed, if the quad did not already exist.
 
 
@@ -273,6 +281,20 @@ class N3Store {
 
   addQuads(quads) {
     for (let i = 0; i < quads.length; i++) this.addQuad(quads[i]);
+  } // ### `delete` removes the specified quad from the dataset.
+  // Returns the dataset instance it was called on.
+
+
+  delete(quad) {
+    this.removeQuad(quad);
+    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;
   } // ### `import` adds a stream of quads to the store
 
 
@@ -329,7 +351,17 @@ class N3Store {
 
 
   removeMatches(subject, predicate, object, graph) {
-    return this.remove(this.match(subject, predicate, object, graph));
+    const stream = new _readableStream.Readable({
+      objectMode: true
+    });
+
+    stream._read = () => {
+      for (const quad of this.getQuads(subject, predicate, object, graph)) stream.push(quad);
+
+      stream.push(null);
+    };
+
+    return this.remove(stream);
   } // ### `deleteGraph` removes all triples with the given graph from the store
 
 
@@ -370,22 +402,16 @@ class N3Store {
     }
 
     return quads;
-  } // ### `match` returns a stream of quads matching a pattern.
+  } // ### `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.
+  // Note: Since a DatasetCore is an unordered set, the order of the quads within the returned sequence is arbitrary.
   // Setting any field to `undefined` or `null` indicates a wildcard.
+  // For backwards compatibility, the object return also implements the Readable stream interface.
 
 
   match(subject, predicate, object, graph) {
-    const stream = new _readableStream.Readable({
-      objectMode: true
-    }); // Initialize stream once it is being read
-
-    stream._read = () => {
-      for (const quad of this.getQuads(subject, predicate, object, graph)) stream.push(quad);
-
-      stream.push(null);
-    };
-
-    return stream;
+    return new DatasetCoreAndReadableStream(this, subject, predicate, object, graph);
   } // ### `countQuads` returns the number of quads matching a pattern.
   // Setting any field to `undefined` or `null` indicates a wildcard.
 
@@ -651,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;
@@ -702,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.
 
@@ -720,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
 
 
@@ -740,6 +766,13 @@ class N3Store {
 
     if (remove) this.removeQuads(toRemove);
     return lists;
+  } // ### Store is an iterable.
+  // 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();
   }
 
 } // Determines whether the argument is a string
@@ -749,4 +782,72 @@ exports.default = N3Store;
 
 function isString(s) {
   return typeof s === 'string' || s instanceof String;
+}
+/**
+ * A class that implements both DatasetCore and Readable.
+ */
+
+
+class DatasetCoreAndReadableStream extends _readableStream.Readable {
+  constructor(n3Store, subject, predicate, object, graph) {
+    super({
+      objectMode: true
+    });
+    Object.assign(this, {
+      n3Store,
+      subject,
+      predicate,
+      object,
+      graph
+    });
+  }
+
+  get filtered() {
+    if (!this._filtered) {
+      const {
+        n3Store,
+        graph,
+        object,
+        predicate,
+        subject
+      } = this;
+      const quads = n3Store.getQuads(subject, predicate, object, graph);
+      this._filtered = new N3Store(quads, {
+        factory: n3Store._factory
+      });
+    }
+
+    return this._filtered;
+  }
+
+  get size() {
+    return this.filtered.size;
+  }
+
+  _read() {
+    for (const quad of this.filtered.getQuads()) this.push(quad);
+
+    this.push(null);
+  }
+
+  add(quad) {
+    return this.filtered.add(quad);
+  }
+
+  delete(quad) {
+    return this.filtered.delete(quad);
+  }
+
+  has(quad) {
+    return this.filtered.has(quad);
+  }
+
+  match(subject, predicate, object, graph) {
+    return new DatasetCoreAndReadableStream(this.filtered, subject, predicate, object, graph);
+  }
+
+  *[Symbol.iterator]() {
+    yield* this.filtered.getQuads();
+  }
+
 }

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

@@ -11,9 +11,9 @@ var _N3DataFactory = _interopRequireWildcard(require("./N3DataFactory"));
 
 var _N3Util = require("./N3Util");
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
@@ -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"));
 
@@ -125,8 +125,8 @@ exports.Util = Util;
 
 var _N3DataFactory = _interopRequireWildcard(require("./N3DataFactory"));
 
-function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; }
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n3",
-  "version": "1.9.0",
+  "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/N3Lexer.js

@@ -429,6 +429,11 @@ export default class N3Lexer {
     return err;
   }
 
+  // ### Strips off any starting UTF BOM mark.
+  _readStartingBom(input) {
+    return input.startsWith('\ufeff') ? input.substr(1) : input;
+  }
+
   // ## Public methods
 
   // ### `tokenize` starts the transformation of an N3 document into an array of tokens.
@@ -438,7 +443,7 @@ export default class N3Lexer {
 
     // If the input is a string, continuously emit tokens through the callback until the end
     if (typeof input === 'string') {
-      this._input = input;
+      this._input = this._readStartingBom(input);
       // If a callback was passed, asynchronously call it
       if (typeof callback === 'function')
         queueMicrotask(() => this._tokenizeToEnd(callback, true));
@@ -453,7 +458,6 @@ export default class N3Lexer {
     }
     // Otherwise, the input must be a stream
     else {
-      this._input = '';
       this._pendingBuffer = null;
       if (typeof input.setEncoding === 'function')
         input.setEncoding('utf8');
@@ -471,14 +475,18 @@ export default class N3Lexer {
           }
           // Otherwise, tokenize as far as possible
           else {
-            this._input += data;
+            // 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);
           }
         }
       });
       // Parses until the end
       input.on('end', () => {
-        if (this._input !== null)
+        if (typeof this._input === 'string')
           this._tokenizeToEnd(callback, true);
       });
       input.on('error', callback);

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

package/src/N3Store.js

@@ -211,6 +211,14 @@ export default class N3Store {
 
   // ## Public methods
 
+  // ### `add` adds the specified quad to the dataset.
+  // Returns the dataset instance it was called on.
+  // Existing quads, as defined in Quad.equals, will be ignored.
+  add(quad) {
+    this.addQuad(quad);
+    return this;
+  }
+
   // ### `addQuad` adds a new quad to the store.
   // Returns if the quad index has changed, if the quad did not already exist.
   addQuad(subject, predicate, object, graph) {
@@ -259,6 +267,20 @@ export default class N3Store {
       this.addQuad(quads[i]);
   }
 
+  // ### `delete` removes the specified quad from the dataset.
+  // Returns the dataset instance it was called on.
+  delete(quad) {
+    this.removeQuad(quad);
+    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;
+  }
+
   // ### `import` adds a stream of quads to the store
   import(stream) {
     stream.on('data', quad => { this.addQuad(quad); });
@@ -316,7 +338,15 @@ export default class N3Store {
   // ### `removeMatches` removes all matching quads from the store
   // Setting any field to `undefined` or `null` indicates a wildcard.
   removeMatches(subject, predicate, object, graph) {
-    return this.remove(this.match(subject, predicate, object, graph));
+    const stream = new Readable({ objectMode: true });
+
+    stream._read = () => {
+      for (const quad of this.getQuads(subject, predicate, object, graph))
+        stream.push(quad);
+      stream.push(null);
+    };
+
+    return this.remove(stream);
   }
 
   // ### `deleteGraph` removes all triples with the given graph from the store
@@ -373,19 +403,14 @@ export default class N3Store {
     return quads;
   }
 
-  // ### `match` returns a stream of quads matching a pattern.
+  // ### `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.
+  // Note: Since a DatasetCore is an unordered set, the order of the quads within the returned sequence is arbitrary.
   // Setting any field to `undefined` or `null` indicates a wildcard.
+  // For backwards compatibility, the object return also implements the Readable stream interface.
   match(subject, predicate, object, graph) {
-    const stream = new Readable({ objectMode: true });
-
-    // Initialize stream once it is being read
-    stream._read = () => {
-      for (const quad of this.getQuads(subject, predicate, object, graph))
-        stream.push(quad);
-      stream.push(null);
-    };
-
-    return stream;
+    return new DatasetCoreAndReadableStream(this, subject, predicate, object, graph);
   }
 
   // ### `countQuads` returns the number of quads matching a pattern.
@@ -790,9 +815,64 @@ export default class N3Store {
       this.removeQuads(toRemove);
     return lists;
   }
+
+  // ### Store is an iterable.
+  // 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();
+  }
 }
 
 // Determines whether the argument is a string
 function isString(s) {
   return typeof s === 'string' || s instanceof String;
 }
+
+/**
+ * A class that implements both DatasetCore and Readable.
+ */
+class DatasetCoreAndReadableStream extends Readable {
+  constructor(n3Store, subject, predicate, object, graph) {
+    super({ objectMode: true });
+    Object.assign(this, { n3Store, subject, predicate, object, graph });
+  }
+
+  get filtered() {
+    if (!this._filtered) {
+      const { n3Store, graph, object, predicate, subject } = this;
+      const quads = n3Store.getQuads(subject, predicate, object, graph);
+      this._filtered = new N3Store(quads, { factory: n3Store._factory });
+    }
+    return this._filtered;
+  }
+  get size() {
+    return this.filtered.size;
+  }
+
+  _read() {
+    for (const quad of this.filtered.getQuads())
+      this.push(quad);
+    this.push(null);
+  }
+
+  add(quad) {
+    return this.filtered.add(quad);
+  }
+
+  delete(quad) {
+    return this.filtered.delete(quad);
+  }
+
+  has(quad) {
+    return this.filtered.has(quad);
+  }
+
+  match(subject, predicate, object, graph) {
+    return new DatasetCoreAndReadableStream(this.filtered, subject, predicate, object, graph);
+  }
+
+  *[Symbol.iterator]() {
+    yield* this.filtered.getQuads();
+  }
+}