n3 1.26.0 → 2.0.0-beta.2

package/lib/N3Parser.js

@@ -34,10 +34,6 @@ class N3Parser {
     if (!(this._supportsNamedGraphs = !(isTurtle || isN3))) this._readPredicateOrNamedGraph = this._readPredicate;
     // Support triples in other graphs
     this._supportsQuads = !(isTurtle || isTriG || isNTriples || isN3);
-    // Whether the log:isImpliedBy predicate is supported
-    this._isImpliedBy = options.isImpliedBy;
-    // Support nesting of triples
-    this._supportsRDFStar = format === '' || /star|\*$/.test(format);
     // Disable relative IRIs in N-Triples or N-Quads mode
     if (isLineMode) this._resolveRelativeIRI = iri => {
       return null;
@@ -45,11 +41,13 @@ class N3Parser {
     this._blankNodePrefix = typeof options.blankNodePrefix !== 'string' ? '' : options.blankNodePrefix.replace(/^(?!_:)/, '_:');
     this._lexer = options.lexer || new _N3Lexer.default({
       lineMode: isLineMode,
-      n3: isN3,
-      isImpliedBy: this._isImpliedBy
+      n3: isN3
     });
     // Disable explicit quantifiers by default
     this._explicitQuantifiers = !!options.explicitQuantifiers;
+    // Disable parsing of unsupported versions by default
+    this._parseUnsupportedVersions = !!options.parseUnsupportedVersions;
+    this._version = options.version;
   }
 
   // ## Static class methods
@@ -126,6 +124,12 @@ class N3Parser {
     }
   }
 
+  // ### `_readBeforeTopContext` is called once only at the start of parsing.
+  _readBeforeTopContext(token) {
+    if (this._version && !this._isValidVersion(this._version)) return this._error(`Detected unsupported version as media type parameter: "${this._version}"`, token);
+    return this._readInTopContext(token);
+  }
+
   // ### `_readInTopContext` reads a token when in the top context
   _readInTopContext(token) {
     switch (token.type) {
@@ -144,6 +148,11 @@ class N3Parser {
         this._sparqlStyle = true;
       case '@base':
         return this._readBaseIRI;
+      // It could be a version declaration
+      case 'VERSION':
+        this._sparqlStyle = true;
+      case '@version':
+        return this._readVersion;
       // It could be a graph
       case '{':
         if (this._supportsNamedGraphs) {
@@ -203,6 +212,11 @@ class N3Parser {
         this._saveContext('blank', this._graph, this._subject = this._factory.blankNode(), null, null);
         return this._readBlankNodeHead;
       case '(':
+        const stack = this._contextStack,
+          parent = stack.length && stack[stack.length - 1];
+        if (parent.type === '<<') {
+          return this._error('Unexpected list in reified triple', token);
+        }
         // Start a new list
         this._saveContext('list', this._graph, this.RDF_NIL, null, null);
         this._subject = null;
@@ -234,8 +248,12 @@ class N3Parser {
           return this._completeSubjectLiteral;
         } else this._subject = this._factory.literal(token.value, this._factory.namedNode(token.prefix));
         break;
+      case '<<(':
+        if (!this._n3Mode) return this._error('Disallowed triple term as subject', token);
+        this._saveContext('<<(', this._graph, null, null, null);
+        this._graph = null;
+        return this._readSubject;
       case '<<':
-        if (!this._supportsRDFStar) return this._error('Unexpected RDF-star syntax', token);
         this._saveContext('<<', this._graph, null, null, null);
         this._graph = null;
         return this._readSubject;
@@ -263,6 +281,7 @@ class N3Parser {
       case '.':
       case ']':
       case '}':
+      case '|}':
         // Expected predicate didn't come, must have been trailing semicolon
         if (this._predicate === null) return this._error(`Unexpected ${type}`, token);
         this._subject = null;
@@ -302,6 +321,11 @@ class N3Parser {
         this._saveContext('blank', this._graph, this._subject, this._predicate, this._subject = this._factory.blankNode());
         return this._readBlankNodeHead;
       case '(':
+        const stack = this._contextStack,
+          parent = stack.length && stack[stack.length - 1];
+        if (parent.type === '<<') {
+          return this._error('Unexpected list in reified triple', token);
+        }
         // Start a new list
         this._saveContext('list', this._graph, this._subject, this._predicate, this.RDF_NIL);
         this._subject = null;
@@ -311,8 +335,11 @@ class N3Parser {
         if (!this._n3Mode) return this._error('Unexpected graph', token);
         this._saveContext('formula', this._graph, this._subject, this._predicate, this._graph = this._factory.blankNode());
         return this._readSubject;
+      case '<<(':
+        this._saveContext('<<(', this._graph, this._subject, this._predicate, null);
+        this._graph = null;
+        return this._readSubject;
       case '<<':
-        if (!this._supportsRDFStar) return this._error('Unexpected RDF-star syntax', token);
         this._saveContext('<<', this._graph, this._subject, this._predicate, null);
         this._graph = null;
         return this._readSubject;
@@ -344,6 +371,11 @@ class N3Parser {
       this._subject = null;
       return this._readBlankNodeTail(token);
     } else {
+      const stack = this._contextStack,
+        parentParent = stack.length > 1 && stack[stack.length - 2];
+      if (parentParent.type === '<<') {
+        return this._error('Unexpected compound blank node expression in reified triple', token);
+      }
       this._predicate = null;
       return this._readPredicate(token);
     }
@@ -445,6 +477,11 @@ class N3Parser {
         if (!this._n3Mode) return this._error('Unexpected graph', token);
         this._saveContext('formula', this._graph, this._subject, this._predicate, this._graph = this._factory.blankNode());
         return this._readSubject;
+      case '<<':
+        this._saveContext('<<', this._graph, null, null, null);
+        this._graph = null;
+        next = this._readSubject;
+        break;
       default:
         if ((item = this._readEntity(token)) === undefined) return;
     }
@@ -452,6 +489,9 @@ class N3Parser {
     // Create a new blank node if no item head was assigned yet
     if (list === null) this._subject = list = this._factory.blankNode();
 
+    // When reading a reified triple, store the list as subject in the stack, as this will be overridden when reading the triple.
+    if (token.type === '<<') stack[stack.length - 1].subject = this._subject;
+
     // Is this the first element of the list?
     if (previousList === null) {
       // This list is either the subject or the object of its parent
@@ -487,51 +527,82 @@ class N3Parser {
   }
 
   // ### `_completeLiteral` completes a literal with an optional datatype or language
-  _completeLiteral(token) {
+  _completeLiteral(token, component) {
     // Create a simple string literal by default
     let literal = this._factory.literal(this._literalValue);
+    let readCb;
     switch (token.type) {
       // Create a datatyped literal
       case 'type':
       case 'typeIRI':
         const datatype = this._readEntity(token);
         if (datatype === undefined) return; // No datatype means an error occurred
+        if (datatype.value === _IRIs.default.rdf.langString || datatype.value === _IRIs.default.rdf.dirLangString) {
+          return this._error('Detected illegal (directional) languaged-tagged string with explicit datatype', token);
+        }
         literal = this._factory.literal(this._literalValue, datatype);
         token = null;
         break;
       // Create a language-tagged string
       case 'langcode':
+        if (token.value.length > 8) return this._error('Detected language tag of length larger than 8', token);
         literal = this._factory.literal(this._literalValue, token.value);
+        this._literalLanguage = token.value;
         token = null;
+        readCb = this._readDirCode.bind(this, component);
         break;
     }
     return {
       token,
-      literal
+      literal,
+      readCb
     };
   }
+  _readDirCode(component, listItem, token) {
+    // Attempt to read a dircode
+    if (token.type === 'dircode') {
+      const term = this._factory.literal(this._literalValue, {
+        language: this._literalLanguage,
+        direction: token.value
+      });
+      if (component === 'subject') this._subject = term;else this._object = term;
+      this._literalLanguage = undefined;
+      token = null;
+    }
+    if (component === 'subject') return token === null ? this._readPredicateOrNamedGraph : this._readPredicateOrNamedGraph(token);
+    return this._completeObjectLiteralPost(token, listItem);
+  }
 
   // Completes a literal in subject position
   _completeSubjectLiteral(token) {
-    this._subject = this._completeLiteral(token).literal;
+    const completed = this._completeLiteral(token, 'subject');
+    this._subject = completed.literal;
+
+    // Postpone completion if the literal is only partially completed (such as lang+dir).
+    if (completed.readCb) return completed.readCb.bind(this, false);
     return this._readPredicateOrNamedGraph;
   }
 
   // Completes a literal in object position
   _completeObjectLiteral(token, listItem) {
-    const completed = this._completeLiteral(token);
+    const completed = this._completeLiteral(token, 'object');
     if (!completed) return;
     this._object = completed.literal;
 
+    // Postpone completion if the literal is only partially completed (such as lang+dir).
+    if (completed.readCb) return completed.readCb.bind(this, listItem);
+    return this._completeObjectLiteralPost(completed.token, listItem);
+  }
+  _completeObjectLiteralPost(token, listItem) {
     // If this literal was part of a list, write the item
     // (we could also check the context stack, but passing in a flag is faster)
     if (listItem) this._emit(this._subject, this.RDF_FIRST, this._object, this._graph);
     // If the token was consumed, continue with the rest of the input
-    if (completed.token === null) return this._getContextEndReader();
+    if (token === null) return this._getContextEndReader();
     // Otherwise, consume the token now
     else {
       this._readCallback = this._getContextEndReader();
-      return this._readCallback(completed.token);
+      return this._readCallback(token);
     }
   }
 
@@ -552,7 +623,8 @@ class N3Parser {
   // ### `_readPunctuation` reads punctuation between quads or quad parts
   _readPunctuation(token) {
     let next,
-      graph = this._graph;
+      graph = this._graph,
+      startingAnnotation = false;
     const subject = this._subject,
       inversePredicate = this._inversePredicate;
     switch (token.type) {
@@ -564,6 +636,7 @@ class N3Parser {
       // A dot just ends the statement, without sharing anything with the next
       case '.':
         this._subject = null;
+        this._tripleTerm = null;
         next = this._contextStack.length ? this._readSubject : this._readInTopContext;
         if (inversePredicate) this._inversePredicate = false;
         break;
@@ -575,19 +648,23 @@ class N3Parser {
       case ',':
         next = this._readObject;
         break;
+      // ~ is allowed in the annotation syntax
+      case '~':
+        next = this._readReifierInAnnotation;
+        startingAnnotation = true;
+        break;
       // {| means that the current triple is annotated with predicate-object pairs.
       case '{|':
-        if (!this._supportsRDFStar) return this._error('Unexpected RDF-star syntax', token);
-        // Continue using the last triple as quoted triple subject for the predicate-object pairs.
-        const predicate = this._predicate,
-          object = this._object;
-        this._subject = this._factory.quad(subject, predicate, object, this.DEFAULTGRAPH);
+        // Continue using the last triple as reified triple subject for the predicate-object pairs.
+        this._subject = this._readTripleTerm();
+        startingAnnotation = true;
         next = this._readPredicate;
         break;
-      // |} means that the current quoted triple in annotation syntax is finalized.
+      // |} means that the current reified triple in annotation syntax is finalized.
       case '|}':
-        if (this._subject.termType !== 'Quad') return this._error('Unexpected asserted triple closing', token);
+        if (!this._annotation) return this._error('Unexpected annotation syntax closing', token);
         this._subject = null;
+        this._annotation = false;
         next = this._readPunctuation;
         break;
       default:
@@ -599,11 +676,14 @@ class N3Parser {
         return this._error(`Expected punctuation to follow "${this._object.id}"`, token);
     }
     // A quad has been completed now, so return it
-    if (subject !== null) {
+    if (subject !== null && (!startingAnnotation || startingAnnotation && !this._annotation)) {
       const predicate = this._predicate,
         object = this._object;
       if (!inversePredicate) this._emit(subject, predicate, object, graph);else this._emit(object, predicate, subject, graph);
     }
+    if (startingAnnotation) {
+      this._annotation = true;
+    }
     return next;
   }
 
@@ -657,6 +737,20 @@ class N3Parser {
     return this._readDeclarationPunctuation;
   }
 
+  // ### `_isValidVersion` checks if the given version is valid for this parser to handle.
+  _isValidVersion(version) {
+    return this._parseUnsupportedVersions || N3Parser.SUPPORTED_VERSIONS.includes(version);
+  }
+
+  // ### `_readVersion` reads version string declaration
+  _readVersion(token) {
+    if (token.type !== 'literal') return this._error('Expected literal to follow version declaration', token);
+    if (token.end - token.start !== token.value.length + 2) return this._error('Version declarations must use single quotes', token);
+    this._versionCallback(token.value);
+    if (!this._isValidVersion(token.value)) return this._error(`Detected unsupported version: "${token.value}"`, token);
+    return this._readDeclarationPunctuation;
+  }
+
   // ### `_readNamedGraphLabel` reads the label of a named graph
   _readNamedGraphLabel(token) {
     switch (token.type) {
@@ -792,22 +886,13 @@ class N3Parser {
     return this._readPath;
   }
 
-  // ### `_readRDFStarTailOrGraph` reads the graph of a nested RDF-star quad or the end of a nested RDF-star triple
-  _readRDFStarTailOrGraph(token) {
-    if (token.type !== '>>') {
-      // An entity means this is a quad (only allowed if not already inside a graph)
-      if (this._supportsQuads && this._graph === null && (this._graph = this._readEntity(token)) !== undefined) return this._readRDFStarTail;
-      return this._error(`Expected >> to follow "${this._object.id}"`, token);
-    }
-    return this._readRDFStarTail(token);
-  }
-
-  // ### `_readRDFStarTail` reads the end of a nested RDF-star triple
-  _readRDFStarTail(token) {
-    if (token.type !== '>>') return this._error(`Expected >> but got ${token.type}`, token);
+  // ### `_readTripleTermTail` reads the end of a triple term
+  _readTripleTermTail(token) {
+    if (token.type !== ')>>') return this._error(`Expected )>> but got ${token.type}`, token);
     // Read the quad and restore the previous context
     const quad = this._factory.quad(this._subject, this._predicate, this._object, this._graph || this.DEFAULTGRAPH);
-    this._restoreContext('<<', token);
+    this._restoreContext('<<(', token);
+
     // If the triple was the subject, continue by reading the predicate.
     if (this._subject === null) {
       this._subject = quad;
@@ -820,6 +905,77 @@ class N3Parser {
     }
   }
 
+  // ### `_readReifiedTripleTailOrReifier` reads a reifier or the end of a nested reified triple
+  _readReifiedTripleTailOrReifier(token) {
+    if (token.type === '~') {
+      return this._readReifier;
+    }
+    return this._readReifiedTripleTail(token);
+  }
+
+  // ### `_readReifiedTripleTail` reads the end of a nested reified triple
+  _readReifiedTripleTail(token) {
+    if (token.type !== '>>') return this._error(`Expected >> but got ${token.type}`, token);
+    // Read the triple term and restore the previous context
+    this._tripleTerm = null;
+    const reifier = this._readTripleTerm();
+    this._restoreContext('<<', token);
+
+    // // If we're in a list, continue processing that list
+    const stack = this._contextStack,
+      parent = stack.length && stack[stack.length - 1];
+    if (parent && parent.type === 'list') {
+      this._emit(this._subject, this.RDF_FIRST, reifier, this._graph);
+      return this._getContextEndReader();
+    }
+    // If the triple was the subject, continue by reading the predicate.
+    else if (this._subject === null) {
+      this._subject = reifier;
+      return this._readPredicateOrReifierTripleEnd;
+    }
+    // If the triple was the object, read context end.
+    else {
+      this._object = reifier;
+      return this._getContextEndReader();
+    }
+  }
+  _readPredicateOrReifierTripleEnd(token) {
+    if (token.type === '.') {
+      this._subject = null;
+      return this._readPunctuation(token);
+    }
+    return this._readPredicate(token);
+  }
+
+  // ### `_readReifier` reads the triple term identifier after a tilde when in a reifying triple.
+  _readReifier(token) {
+    this._reifier = this._readEntity(token);
+    return this._readReifiedTripleTail;
+  }
+
+  // ### `_readReifier` reads the optional triple term identifier after a tilde when in annotation syntax.
+  _readReifierInAnnotation(token) {
+    // If next token is a reifier, read it as such.
+    if (token.type === 'IRI' || token.type === 'typeIRI' || token.type === 'type' || token.type === 'prefixed' || token.type === 'blank' || token.type === 'var') {
+      this._reifier = this._readEntity(token);
+      return this._readPunctuation;
+    }
+    // Otherwise, emit and assert triple term.
+    this._readTripleTerm();
+    this._subject = null;
+    return this._readPunctuation(token);
+  }
+  _readTripleTerm() {
+    const stack = this._contextStack,
+      parent = stack.length && stack[stack.length - 1];
+    const parentGraph = parent ? parent.graph : undefined;
+    const reifier = this._reifier || this._factory.blankNode();
+    this._reifier = null;
+    this._tripleTerm = this._tripleTerm || this._factory.quad(this._subject, this._predicate, this._object);
+    this._emit(reifier, this.RDF_REIFIES, this._tripleTerm, parentGraph || this.DEFAULTGRAPH);
+    return reifier;
+  }
+
   // ### `_getContextEndReader` gets the next reader function at the end of a context
   _getContextEndReader() {
     const contextStack = this._contextStack;
@@ -831,8 +987,10 @@ class N3Parser {
         return this._readListItem;
       case 'formula':
         return this._readFormulaTail;
+      case '<<(':
+        return this._readTripleTermTail;
       case '<<':
-        return this._readRDFStarTailOrGraph;
+        return this._readReifiedTripleTailOrReifier;
     }
   }
 
@@ -947,25 +1105,28 @@ class N3Parser {
   // ## Public methods
 
   // ### `parse` parses the N3 input and emits each parsed quad through the onQuad callback.
-  parse(input, quadCallback, prefixCallback) {
+  parse(input, quadCallback, prefixCallback, versionCallback) {
     // The second parameter accepts an object { onQuad: ..., onPrefix: ..., onComment: ...}
     // As a second and third parameter it still accepts a separate quadCallback and prefixCallback for backward compatibility as well
-    let onQuad, onPrefix, onComment;
-    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment)) {
+    let onQuad, onPrefix, onComment, onVersion;
+    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion)) {
       onQuad = quadCallback.onQuad;
       onPrefix = quadCallback.onPrefix;
       onComment = quadCallback.onComment;
+      onVersion = quadCallback.onVersion;
     } else {
       onQuad = quadCallback;
       onPrefix = prefixCallback;
+      onVersion = versionCallback;
     }
     // The read callback is the next function to be executed when a token arrives.
     // We start reading in the top context.
-    this._readCallback = this._readInTopContext;
+    this._readCallback = this._readBeforeTopContext;
     this._sparqlStyle = false;
     this._prefixes = Object.create(null);
     this._prefixes._ = this._blankNodePrefix ? this._blankNodePrefix.substr(2) : `b${blankNodePrefix++}_`;
     this._prefixCallback = onPrefix || noop;
+    this._versionCallback = onVersion || noop;
     this._inversePredicate = false;
     this._quantified = Object.create(null);
 
@@ -1017,14 +1178,15 @@ function initDataFactory(parser, factory) {
   parser.RDF_FIRST = factory.namedNode(_IRIs.default.rdf.first);
   parser.RDF_REST = factory.namedNode(_IRIs.default.rdf.rest);
   parser.RDF_NIL = factory.namedNode(_IRIs.default.rdf.nil);
+  parser.RDF_REIFIES = factory.namedNode(_IRIs.default.rdf.reifies);
   parser.N3_FORALL = factory.namedNode(_IRIs.default.r.forAll);
   parser.N3_FORSOME = factory.namedNode(_IRIs.default.r.forSome);
   parser.ABBREVIATIONS = {
     'a': factory.namedNode(_IRIs.default.rdf.type),
     '=': factory.namedNode(_IRIs.default.owl.sameAs),
-    '>': factory.namedNode(_IRIs.default.log.implies),
-    '<': factory.namedNode(_IRIs.default.log.isImpliedBy)
+    '>': factory.namedNode(_IRIs.default.log.implies)
   };
   parser.QUANTIFIERS_GRAPH = factory.namedNode('urn:n3:quantifiers');
 }
+N3Parser.SUPPORTED_VERSIONS = ['1.2', '1.2-basic', '1.1'];
 initDataFactory(N3Parser.prototype, _N3DataFactory.default);

package/lib/N3Store.js

@@ -10,7 +10,8 @@ var _IRIs = _interopRequireDefault(require("./IRIs"));
 var _N3Util = require("./N3Util");
 var _N3Writer = _interopRequireDefault(require("./N3Writer"));
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 // **N3Store** objects store N3 quads by graph in memory.
 
 const ITERATOR = Symbol('iter');
@@ -146,7 +147,7 @@ class N3Store {
     this._graphs = Object.create(null);
 
     // Shift parameters if `quads` is not given
-    if (!options && quads && !quads[0] && !(typeof quads.match === 'function')) options = quads, quads = null;
+    if (!options && quads && !quads[0]) options = quads, quads = null;
     options = options || {};
     this._factory = options.factory || _N3DataFactory.default;
     this._entityIndex = options.entityIndex || new N3EntityIndex({
@@ -158,7 +159,7 @@ class N3Store {
     this._termToNewNumericId = this._entityIndex._termToNewNumericId.bind(this._entityIndex);
 
     // Add quads if passed
-    if (quads) this.addAll(quads);
+    if (quads) this.addQuads(quads);
   }
 
   // ## Public properties
@@ -578,7 +579,7 @@ 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) {
-    for (const quad of this.readQuads(subject, predicate, object, graph)) if (callback(quad, this)) return true;
+    for (const quad of this.readQuads(subject, predicate, object, graph)) if (callback(quad)) return true;
     return false;
   }
 
@@ -1082,28 +1083,26 @@ class DatasetCoreAndReadableStream extends _readableStream.Readable {
       if (subject && !(subjectId = newStore._termToNumericId(subject)) || predicate && !(predicateId = newStore._termToNumericId(predicate)) || object && !(objectId = newStore._termToNumericId(object))) return newStore;
       const graphs = n3Store._getGraphs(graph);
       for (const graphKey in graphs) {
-        let subjects, predicates, objects, content;
-        if (content = graphs[graphKey]) {
-          if (!subjectId && predicateId) {
-            if (predicates = indexMatch(content.predicates, [predicateId, objectId, subjectId])) {
-              subjects = indexMatch(content.subjects, [subjectId, predicateId, objectId]);
-              objects = indexMatch(content.objects, [objectId, subjectId, predicateId]);
-            }
-          } else if (objectId) {
-            if (objects = indexMatch(content.objects, [objectId, subjectId, predicateId])) {
-              subjects = indexMatch(content.subjects, [subjectId, predicateId, objectId]);
-              predicates = indexMatch(content.predicates, [predicateId, objectId, subjectId]);
-            }
-          } else if (subjects = indexMatch(content.subjects, [subjectId, predicateId, objectId])) {
-            predicates = indexMatch(content.predicates, [predicateId, objectId, subjectId]);
-            objects = indexMatch(content.objects, [objectId, subjectId, predicateId]);
+        let subjects, predicates, objects;
+        if (!subjectId && predicateId) {
+          if (predicates = indexMatch(graphs[graphKey].predicates, [predicateId, objectId, subjectId])) {
+            subjects = indexMatch(graphs[graphKey].subjects, [subjectId, predicateId, objectId]);
+            objects = indexMatch(graphs[graphKey].objects, [objectId, subjectId, predicateId]);
+          }
+        } else if (objectId) {
+          if (objects = indexMatch(graphs[graphKey].objects, [objectId, subjectId, predicateId])) {
+            subjects = indexMatch(graphs[graphKey].subjects, [subjectId, predicateId, objectId]);
+            predicates = indexMatch(graphs[graphKey].predicates, [predicateId, objectId, subjectId]);
           }
-          if (subjects) newStore._graphs[graphKey] = {
-            subjects,
-            predicates,
-            objects
-          };
+        } else if (subjects = indexMatch(graphs[graphKey].subjects, [subjectId, predicateId, objectId])) {
+          predicates = indexMatch(graphs[graphKey].predicates, [predicateId, objectId, subjectId]);
+          objects = indexMatch(graphs[graphKey].objects, [objectId, subjectId, predicateId]);
         }
+        if (subjects) newStore._graphs[graphKey] = {
+          subjects,
+          predicates,
+          objects
+        };
       }
       newStore._size = null;
     }

package/lib/N3Util.js

@@ -8,7 +8,6 @@ exports.isBlankNode = isBlankNode;
 exports.isDefaultGraph = isDefaultGraph;
 exports.isLiteral = isLiteral;
 exports.isNamedNode = isNamedNode;
-exports.isQuad = isQuad;
 exports.isVariable = isVariable;
 exports.prefix = prefix;
 exports.prefixes = prefixes;
@@ -36,11 +35,6 @@ function isVariable(term) {
   return !!term && term.termType === 'Variable';
 }
 
-// Tests whether the given term represents a quad
-function isQuad(term) {
-  return !!term && term.termType === 'Quad';
-}
-
 // Tests whether the given term represents the default graph
 function isDefaultGraph(term) {
   return !!term && term.termType === 'DefaultGraph';

package/lib/N3Writer.js

@@ -7,9 +7,8 @@ exports.default = void 0;
 var _IRIs = _interopRequireDefault(require("./IRIs"));
 var _N3DataFactory = _interopRequireWildcard(require("./N3DataFactory"));
 var _N3Util = require("./N3Util");
-var _BaseIRI = _interopRequireDefault(require("./BaseIRI"));
-var _Util = require("./Util");
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // **N3Writer** writes N3 documents.
 
@@ -78,7 +77,8 @@ class N3Writer {
       this._prefixIRIs = Object.create(null);
       options.prefixes && this.addPrefixes(options.prefixes);
       if (options.baseIRI) {
-        this._baseIri = new _BaseIRI.default(options.baseIRI);
+        this._baseMatcher = new RegExp(`^${escapeRegex(options.baseIRI)}${options.baseIRI.endsWith('/') ? '' : '[#?]'}`);
+        this._baseLength = options.baseIRI.length;
       }
     } else {
       this._lineMode = true;
@@ -156,9 +156,7 @@ class N3Writer {
     }
     let iri = entity.value;
     // Use relative IRIs if requested and possible
-    if (this._baseIri) {
-      iri = this._baseIri.toRelative(iri);
-    }
+    if (this._baseMatcher && this._baseMatcher.test(iri)) iri = iri.substr(this._baseLength);
     // Escape special characters
     if (escape.test(iri)) iri = iri.replace(escapeAll, characterReplacer);
     // Try to represent the IRI as prefixed name
@@ -173,7 +171,8 @@ class N3Writer {
     if (escape.test(value)) value = value.replace(escapeAll, characterReplacer);
 
     // Write a language-tagged literal
-    if (literal.language) return `"${value}"@${literal.language}`;
+    const direction = literal.direction ? `--${literal.direction}` : '';
+    if (literal.language) return `"${value}"@${literal.language}${direction}`;
 
     // Write dedicated literals per data type
     if (this._lineMode) {
@@ -285,7 +284,7 @@ class N3Writer {
         IRIlist += IRIlist ? `|${prefixIRI}` : prefixIRI;
         prefixList += (prefixList ? '|' : '') + this._prefixIRIs[prefixIRI];
       }
-      IRIlist = (0, _Util.escapeRegex)(IRIlist, /[\]\/\(\)\*\+\?\.\\\$]/g, '\\$&');
+      IRIlist = escapeRegex(IRIlist, /[\]\/\(\)\*\+\?\.\\\$]/g, '\\$&');
       this._prefixRegex = new RegExp(`^(?:${prefixList})[^\/]*$|` + `^(${IRIlist})([_a-zA-Z0-9][\\-_a-zA-Z0-9]*)$`);
     }
     // End a prefix block with a newline
@@ -381,4 +380,7 @@ function characterReplacer(character) {
     }
   }
   return result;
+}
+function escapeRegex(regex) {
+  return regex.replace(/[\]\/\(\)\*\+\?\.\\\$]/g, '\\$&');
 }