n3 1.25.2 → 2.0.0-beta.1

package/src/N3Parser.js

@@ -27,16 +27,12 @@ export default class N3Parser {
       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; };
     this._blankNodePrefix = typeof options.blankNodePrefix !== 'string' ? '' :
                               options.blankNodePrefix.replace(/^(?!_:)/, '_:');
-    this._lexer = options.lexer || new N3Lexer({ lineMode: isLineMode, n3: isN3, isImpliedBy: this._isImpliedBy });
+    this._lexer = options.lexer || new N3Lexer({ lineMode: isLineMode, n3: isN3 });
     // Disable explicit quantifiers by default
     this._explicitQuantifiers = !!options.explicitQuantifiers;
   }
@@ -135,6 +131,11 @@ export default 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) {
@@ -199,6 +200,10 @@ export default class N3Parser {
                         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;
@@ -239,9 +244,13 @@ export default class N3Parser {
         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;
@@ -271,6 +280,7 @@ export default 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);
@@ -317,6 +327,10 @@ export default class N3Parser {
                         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;
@@ -328,9 +342,11 @@ export default class N3Parser {
       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;
@@ -366,6 +382,10 @@ export default class N3Parser {
       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);
     }
@@ -475,6 +495,11 @@ export default class N3Parser {
       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;
@@ -484,6 +509,10 @@ export default class N3Parser {
     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
@@ -524,9 +553,10 @@ export default 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
@@ -534,43 +564,82 @@ export default class N3Parser {
     case 'typeIRI':
       const datatype = this._readEntity(token);
       if (datatype === undefined) return; // No datatype means an error occurred
+      if (datatype.value === namespaces.rdf.langString || datatype.value === namespaces.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 };
+    return { token, 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)
+    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);
     }
   }
 
@@ -592,7 +661,7 @@ export default class N3Parser {
 
   // ### `_readPunctuation` reads punctuation between quads or quad parts
   _readPunctuation(token) {
-    let next, graph = this._graph;
+    let next, graph = this._graph, startingAnnotation = false;
     const subject = this._subject, inversePredicate = this._inversePredicate;
     switch (token.type) {
     // A closing brace ends a graph
@@ -605,6 +674,7 @@ export default 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;
@@ -616,20 +686,24 @@ export default 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:
@@ -641,13 +715,16 @@ export default 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;
   }
 
@@ -705,6 +782,16 @@ export default class N3Parser {
     return this._readDeclarationPunctuation;
   }
 
+  // ### `_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._prefixCallback(token.value);
+    return this._readDeclarationPunctuation;
+  }
+
   // ### `_readNamedGraphLabel` reads the label of a named graph
   _readNamedGraphLabel(token) {
     switch (token.type) {
@@ -853,25 +940,15 @@ export default 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._graph || this.DEFAULTGRAPH);
+    this._restoreContext('<<(', token);
+
     // If the triple was the subject, continue by reading the predicate.
     if (this._subject === null) {
       this._subject = quad;
@@ -884,6 +961,78 @@ export default 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;
@@ -897,8 +1046,10 @@ export default class N3Parser {
       return this._readListItem;
     case 'formula':
       return this._readFormulaTail;
+    case '<<(':
+      return this._readTripleTermTail;
     case '<<':
-      return this._readRDFStarTailOrGraph;
+      return this._readReifiedTripleTailOrReifier;
     }
   }
 
@@ -1013,18 +1164,20 @@ export default 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.
@@ -1034,6 +1187,7 @@ export default class N3Parser {
     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);
 
@@ -1089,16 +1243,16 @@ function initDataFactory(parser, factory) {
   parser.DEFAULTGRAPH = factory.defaultGraph();
 
   // Set common named nodes
-  parser.RDF_FIRST  = factory.namedNode(namespaces.rdf.first);
-  parser.RDF_REST   = factory.namedNode(namespaces.rdf.rest);
-  parser.RDF_NIL    = factory.namedNode(namespaces.rdf.nil);
-  parser.N3_FORALL  = factory.namedNode(namespaces.r.forAll);
-  parser.N3_FORSOME = factory.namedNode(namespaces.r.forSome);
+  parser.RDF_FIRST   = factory.namedNode(namespaces.rdf.first);
+  parser.RDF_REST    = factory.namedNode(namespaces.rdf.rest);
+  parser.RDF_NIL     = factory.namedNode(namespaces.rdf.nil);
+  parser.RDF_REIFIES = factory.namedNode(namespaces.rdf.reifies);
+  parser.N3_FORALL   = factory.namedNode(namespaces.r.forAll);
+  parser.N3_FORSOME  = factory.namedNode(namespaces.r.forSome);
   parser.ABBREVIATIONS = {
     'a': factory.namedNode(namespaces.rdf.type),
     '=': factory.namedNode(namespaces.owl.sameAs),
     '>': factory.namedNode(namespaces.log.implies),
-    '<': factory.namedNode(namespaces.log.isImpliedBy),
   };
   parser.QUANTIFIERS_GRAPH = factory.namedNode('urn:n3:quantifiers');
 }

package/src/N3Store.js

@@ -163,7 +163,7 @@ export default class N3Store {
     this._graphs = Object.create(null);
 
     // Shift parameters if `quads` is not given
-    if (!options && quads && !quads[0] && !(typeof quads.match === 'function'))
+    if (!options && quads && !quads[0])
       options = quads, quads = null;
     options = options || {};
     this._factory = options.factory || N3DataFactory;
@@ -175,7 +175,7 @@ export default class N3Store {
 
     // Add quads if passed
     if (quads)
-      this.addAll(quads);
+      this.addQuads(quads);
   }
 
   // ## Public properties
@@ -601,7 +601,7 @@ export default class N3Store {
   // 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))
+      if (callback(quad))
         return true;
     return false;
   }
@@ -1134,28 +1134,27 @@ class DatasetCoreAndReadableStream extends Readable {
 
       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]);
-            }
+        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 (subjects = indexMatch(content.subjects, [subjectId, predicateId, objectId])) {
-            predicates = indexMatch(content.predicates, [predicateId, objectId, subjectId]);
-            objects = indexMatch(content.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/src/N3Writer.js

@@ -2,8 +2,6 @@
 import namespaces from './IRIs';
 import { default as N3DataFactory, Term } from './N3DataFactory';
 import { isDefaultGraph } from './N3Util';
-import BaseIRI from './BaseIRI';
-import { escapeRegex } from './Util';
 
 const DEFAULTGRAPH = N3DataFactory.defaultGraph();
 
@@ -60,7 +58,9 @@ export default class N3Writer {
       this._prefixIRIs = Object.create(null);
       options.prefixes && this.addPrefixes(options.prefixes);
       if (options.baseIRI) {
-        this._baseIri = new BaseIRI(options.baseIRI);
+        this._baseMatcher = new RegExp(`^${escapeRegex(options.baseIRI)
+            }${options.baseIRI.endsWith('/') ? '' : '[#?]'}`);
+        this._baseLength = options.baseIRI.length;
       }
     }
     else {
@@ -153,9 +153,8 @@ export default 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);
@@ -173,8 +172,9 @@ export default class N3Writer {
       value = value.replace(escapeAll, characterReplacer);
 
     // Write a language-tagged literal
+    const direction = literal.direction ? `--${literal.direction}` : '';
     if (literal.language)
-      return `"${value}"@${literal.language}`;
+      return `"${value}"@${literal.language}${direction}`;
 
     // Write dedicated literals per data type
     if (this._lineMode) {
@@ -395,3 +395,7 @@ function characterReplacer(character) {
   }
   return result;
 }
+
+function escapeRegex(regex) {
+  return regex.replace(/[\]\/\(\)\*\+\?\.\\\$]/g, '\\$&');
+}

package/src/index.js

@@ -7,7 +7,6 @@ import Reasoner, { getRulesFromDataset } from './N3Reasoner';
 import StreamParser from './N3StreamParser';
 import StreamWriter from './N3StreamWriter';
 import * as Util from './N3Util';
-import BaseIRI from './BaseIRI';
 
 import {
   default as DataFactory,
@@ -37,7 +36,6 @@ export {
   StreamWriter,
   Util,
   Reasoner,
-  BaseIRI,
 
   DataFactory,
 
@@ -67,7 +65,6 @@ export default {
   StreamWriter,
   Util,
   Reasoner,
-  BaseIRI,
 
   DataFactory,