n3 3.0.0-alpha.5 → 3.0.0-alpha.7

package/lib/N3Lexer.js

@@ -116,8 +116,8 @@ class N3Lexer {
     this._blank = /_:((?:[0-9A-Z_a-z\xc0-\xd6\xd8-\xf6\xf8-\u02ff\u0370-\u037d\u037f-\u1fff\u200c\u200d\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd]|[\ud800-\udb7f][\udc00-\udfff])(?:\.?[\-0-9A-Z_a-z\xb7\xc0-\xd6\xd8-\xf6\xf8-\u037d\u037f-\u1fff\u200c\u200d\u203f\u2040\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd]|[\ud800-\udb7f][\udc00-\udfff])*)(?:[ \t]+|(?=\.?[,;:!\^\s#()\[\]\{\}"'<>]))/y;
     this._number = /[\-+]?(?:(\d+\.\d*|\.?\d+)[eE][\-+]?\d+|(?=\.?\d)\d*(?:(\.)\d+)?)(?=\.?[,;:!\^\s#()\[\]\{\}"'<>])/y;
     this._boolean = /(?:true|false)(?=[.,;!\^\s#()\[\]\{\}"'<>])/y;
-    this._atKeyword = /@[a-z]+(?=[\s#<:])/iy;
-    this._keyword = /(?:PREFIX|BASE|VERSION|GRAPH)(?=[\s#<])/iy;
+    this._atKeyword = /@[a-z]+(?=[\s#<:"'])/iy;
+    this._keyword = /(?:PREFIX|BASE|VERSION|GRAPH)(?=[\s#<"'])/iy;
     this._n3Verb = /(?:has|is|of)(?=[\s#()\[\]\{\}"'<>?_+\-0-9])/y;
     this._n3Id = /id(?=[\s#<])/y;
     this._shortPredicates = /a(?=[\s#()\[\]\{\}"'<>])/y;
@@ -135,6 +135,8 @@ class N3Lexer {
       for (const key in this) {
         if (!(key in lineModeRegExps) && this[key] instanceof RegExp) this[key] = invalidRegExp;
       }
+      // The only keyword in N-Triples and N-Quads is VERSION, which is case-sensitive
+      this._keyword = /VERSION(?=[\s#<"])/y;
     }
     // When not in line mode, enable N3 functionality by default
     else {
@@ -236,7 +238,8 @@ class N3Lexer {
         matchLength = 0,
         lexicalLength = 0,
         finalLineLength = 0,
-        inconclusive = false;
+        inconclusive = false,
+        tripleQuoted = false;
       switch (firstChar) {
         case '^':
           // A datatype marker separated from its type cannot be followed by another marker
@@ -310,7 +313,8 @@ class N3Lexer {
             ({
               value,
               matchLength,
-              finalLineLength
+              finalLineLength,
+              tripleQuoted
             } = this._parseLiteral(input, pos));
             if (value === null) return reportSyntaxError(this, input, pos);
           }
@@ -328,7 +332,8 @@ class N3Lexer {
               ({
                 value,
                 matchLength,
-                finalLineLength
+                finalLineLength,
+                tripleQuoted
               } = this._parseLiteral(input, pos));
               if (value === null) return reportSyntaxError(this, input, pos);
             }
@@ -521,7 +526,21 @@ class N3Lexer {
           line,
           start,
           end: finalLineLength,
-          endLine: this._line
+          endLine: this._line,
+          tripleQuoted
+        };
+        callback(null, token);
+      }
+      // Triple-quoted strings are marked, since version declarations do not allow them
+      else if (tripleQuoted) {
+        token = {
+          type,
+          value,
+          prefix,
+          line,
+          start,
+          end: start + length,
+          tripleQuoted
         };
         callback(null, token);
       } else token = emitToken(type, value, prefix, line, start, lexicalLength || length);
@@ -671,7 +690,8 @@ class N3Lexer {
           return {
             value: this._unescape(raw, stringEscapeReplacements),
             matchLength,
-            finalLineLength
+            finalLineLength,
+            tripleQuoted: openingLength === 3
           };
         }
         closingPos++;
@@ -681,14 +701,34 @@ class N3Lexer {
     return {
       value: '',
       matchLength: 0,
-      finalLineLength: 0
+      finalLineLength: 0,
+      tripleQuoted: false
     };
   }
 
+  // ### `_tryTokenizeToEnd` tokenizes as far as possible, reporting failures through the callback
+  _tryTokenizeToEnd(callback, inputFinished) {
+    // Keep track of errors thrown by the callback, which must reach the caller unchanged
+    let callbackError;
+    try {
+      this._tokenizeToEnd((error, token) => {
+        try {
+          return callback(error, token);
+        } catch (thrown) {
+          throw callbackError = thrown;
+        }
+      }, inputFinished);
+    } catch (error) {
+      // Matching an extremely long token can exhaust the regular expression stack
+      if (error === callbackError || !(error instanceof RangeError)) throw error;
+      callback(this._syntaxError(null, `Token too long on line ${this._line}.`));
+    }
+  }
+
   // ### `_syntaxError` creates a syntax error for the given issue
-  _syntaxError(issue) {
+  _syntaxError(issue, message = `Unexpected "${issue}" on line ${this._line}.`) {
     this._input = null;
-    const err = new Error(`Unexpected "${issue}" on line ${this._line}.`);
+    const err = new Error(message);
     err.context = {
       token: undefined,
       line: this._line,
@@ -729,13 +769,13 @@ class N3Lexer {
       this._input = this._readStartingBom(input);
       // If a callback was passed, asynchronously call it
       if (typeof callback === 'function') queueMicrotask(() => {
-        if (this._tokenization === tokenization) this._tokenizeToEnd(callback, true);
+        if (this._tokenization === tokenization) this._tryTokenizeToEnd(callback, true);
       });
       // If no callback was passed, tokenize synchronously and return
       else {
         const tokens = [];
         let error;
-        this._tokenizeToEnd((e, t) => e ? error = e : tokens.push(t), true);
+        this._tryTokenizeToEnd((e, t) => e ? error = e : tokens.push(t), true);
         if (error) throw error;
         return tokens;
       }
@@ -762,7 +802,7 @@ class N3Lexer {
           // Tokenize as far as possible. When a previous attempt left a long unfinished token,
           // wait until the buffered input has doubled, so the token is not rescanned for every chunk.
           if (this._input.length >= retryLength) {
-            this._tokenizeToEnd(callback, false);
+            this._tryTokenizeToEnd(callback, false);
             retryLength = this._input !== null && this._input.length > MIN_RESCAN_LENGTH ? 2 * this._input.length : 0;
           }
         }
@@ -773,7 +813,7 @@ class N3Lexer {
           // Decode any incomplete character left at the end
           const rest = decoder ? decoder.decode() : '';
           if (rest) this._input = typeof this._input === 'string' ? this._input + rest : rest;
-          if (typeof this._input === 'string') this._tokenizeToEnd(callback, true);
+          if (typeof this._input === 'string') this._tryTokenizeToEnd(callback, true);
         }
       });
       input.on('error', error => {

package/lib/N3Parser.js

@@ -11,6 +11,10 @@ function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e
 // **N3Parser** parses N3 documents.
 
 let blankNodePrefix = 0;
+// Detects `.` and `..` path segments in an IRI
+const dotSegments = /(^|\/)\.\.?($|[/#?])/;
+// Detects `.` and `..` segments in the path of an IRI, ignoring its query and fragment
+const pathDotSegments = /^[^?#]*(?:^|\/)\.\.?(?:$|[/#?])/;
 
 // ## Constructor
 class N3Parser {
@@ -92,6 +96,7 @@ class N3Parser {
     if (!baseIRI) {
       this._base = '';
       this._basePath = '';
+      this._basePathHasDotSegments = false;
     } else {
       // Remove fragment if present
       const fragmentPos = baseIRI.indexOf('#');
@@ -108,6 +113,8 @@ class N3Parser {
       // If the base has an authority but an empty path,
       // relative IRIs merge under the path '/' (RFC 3986 §5.2.3)
       if (baseIRI[2] !== undefined && (base.length === this._baseRoot.length || base[this._baseRoot.length] === '?')) this._basePath = `${this._baseRoot}/`;
+      // Check once whether resolving against the base path needs to remove dot segments
+      this._basePathHasDotSegments = dotSegments.test(this._basePath);
     }
   }
 
@@ -154,7 +161,7 @@ class N3Parser {
     // Prefix and base declarations are scoped to their formula,
     // so record prefix changes to undo them when the formula ends
     if (type === 'formula') {
-      context.base = [this._base, this._basePath, this._baseRoot, this._baseScheme];
+      context.base = [this._base, this._basePath, this._baseRoot, this._baseScheme, this._basePathHasDotSegments];
       this._prefixChanges = [];
     }
     this._contextStack.push(context);
@@ -194,7 +201,7 @@ class N3Parser {
     if (this._n3Mode) {
       this._inversePredicate = context.inverse;
       this._expectOf = context.expectOf;
-      if (type === 'formula') [this._base, this._basePath, this._baseRoot, this._baseScheme] = context.base;
+      if (type === 'formula') [this._base, this._basePath, this._baseRoot, this._baseScheme, this._basePathHasDotSegments] = context.base;
       if (this._prefixChanges !== context.prefixChanges) {
         undoChanges(this._prefixes, this._prefixChanges);
         this._prefixChanges = context.prefixChanges;
@@ -1026,7 +1033,8 @@ class N3Parser {
   // ### `_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);
+    // Only short strings are allowed, so no numbers or booleans (which have a datatype prefix)
+    if (token.prefix !== '' || token.tripleQuoted) 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;
@@ -1455,14 +1463,17 @@ class N3Parser {
       // Resolve all other IRIs at the base IRI's path
       default:
         // Relative IRIs cannot contain a colon in the first path segment
-        return /^[^/:]*:/.test(iri) ? null : this._removeDotSegments(this._basePath + iri);
+        if (/^[^/:]*:/.test(iri)) return null;
+        // Only scan the joined IRI for dot segments if either part can contain them,
+        // as the base path can be long and the joined IRI would need to be copied
+        return this._basePathHasDotSegments || pathDotSegments.test(iri) ? this._removeDotSegments(this._basePath + iri) : this._basePath + iri;
     }
   }
 
   // ### `_removeDotSegments` resolves './' and '../' path segments in an IRI as per RFC3986
   _removeDotSegments(iri) {
     // Don't modify the IRI if it does not contain any dot segments
-    if (!/(^|\/)\.\.?($|[/#?])/.test(iri)) return iri;
+    if (!dotSegments.test(iri)) return iri;
 
     // Start with an imaginary slash before the IRI in order to resolve trailing './' and '../'
     const length = iri.length;

package/lib/N3Store.js

@@ -572,12 +572,67 @@ class N3Store {
     return !this.readQuads(subjectOrQuad, predicate, object, graph).next().done;
   }
 
-  // ### `import` adds a stream of quads to the store
+  // ### `import` adds a stream of quads to the store.
+  // It returns the stream, wrapped such that it can also be awaited
+  // as a promise of the store (per the RDF/JS `Dataset.import` signature).
   import(stream) {
     stream.on('data', quad => {
       this.addQuad(quad);
     });
-    return stream;
+
+    // Only track completion once awaited, so unawaited imports keep the stream's behavior
+    const store = this;
+    let promise = null;
+    function completion() {
+      return promise || (promise = new Promise((resolve, reject) => {
+        let stopListening = null;
+        function settle(error) {
+          stopListening();
+          error ? reject(error) : resolve(store);
+        }
+        try {
+          stopListening = (0, _readableStream.finished)(stream, {
+            readable: true,
+            writable: false
+          }, settle);
+        }
+        // RDF/JS streams that are not Node.js streams only signal their end and errors
+        // and must be awaited before they finish
+        catch (_unused) {
+          stopListening = () => {
+            if (stream.removeListener) {
+              stream.removeListener('end', onFinish);
+              stream.removeListener('error', settle);
+            }
+          };
+          function onFinish() {
+            settle();
+          }
+          stream.on('end', onFinish);
+          stream.on('error', settle);
+        }
+      }));
+    }
+    const thenable = {
+      then(onFulfilled, onRejected) {
+        return completion().then(onFulfilled, onRejected);
+      },
+      catch(onRejected) {
+        return completion().catch(onRejected);
+      },
+      finally(onFinally) {
+        return completion().finally(onFinally);
+      }
+    };
+    // Return a wrapper that behaves as the stream, but is also awaitable
+    return new Proxy(stream, {
+      get(target, property) {
+        if (property === 'then' || property === 'catch' || property === 'finally') return thenable[property];
+        const value = target[property];
+        // Methods run on the stream itself, which may rely on private fields
+        return typeof value === 'function' ? value.bind(target) : value;
+      }
+    });
   }
 
   // ### `removeQuad` removes a quad from the store if it exists
@@ -617,8 +672,11 @@ class N3Store {
   }
 
   // ### `removeQuads` removes multiple quads from the store
+  // returns `true` if all quads were removed, `false` if some were not found
   removeQuads(quads) {
-    for (let i = 0; i < quads.length; i++) this.removeQuad(quads[i]);
+    let removed = true;
+    for (let i = 0; i < quads.length; i++) removed = this.removeQuad(quads[i]) && removed;
+    return removed;
   }
 
   // ### `remove` removes a stream of quads from the store

package/lib/N3Writer.js

@@ -41,6 +41,9 @@ const escape = /["\\\t\n\r\b\f\u0000-\u0019\ud800-\udbff]/,
     '\f': '\\f'
   };
 
+// Characters that a version label cannot contain
+const invalidVersionLabel = /["\\\u0000-\u001f\u007f]|[\ud800-\udbff](?![\udc00-\udfff])|(?:^|[^\ud800-\udbff])[\udc00-\udfff]/;
+
 // ## Placeholder class to represent already pretty-printed terms
 class SerializedTerm extends _N3DataFactory.Term {
   // Pretty-printed nodes are not equal to any other node
@@ -80,12 +83,17 @@ class N3Writer {
       this._endStream = options.end === undefined ? true : !!options.end;
     }
 
+    // A version label is written as-is, so it cannot contain characters that need escaping,
+    // nor unpaired surrogates (which cannot be encoded)
+    if (options.version && invalidVersionLabel.test(options.version)) throw new Error(`Invalid version label: ${JSON.stringify(options.version)}`);
+
     // Initialize writer, depending on the format
     this._subject = null;
     if (!/triple|quad/i.test(options.format)) {
       this._lineMode = false;
       this._escape = escape, this._escapeAll = escapeAll, this._characterReplacer = characterReplacer;
       this._graph = DEFAULTGRAPH;
+      if (options.version) this._write(`@version "${options.version}".\n`);
       this._prefixIRIs = Object.create(null);
       // Escaped prefix IRIs and names for the prefix matcher, computed once per prefix
       this._prefixPatterns = Object.create(null);
@@ -100,6 +108,7 @@ class N3Writer {
       // N-Triples and N-Quads are written in their canonical form
       this._escape = canonicalEscape, this._escapeAll = canonicalEscapeAll;
       this._characterReplacer = canonicalCharacterReplacer;
+      if (options.version) this._write(`VERSION "${options.version}"\n`);
     }
   }
 
@@ -115,6 +124,15 @@ class N3Writer {
     this._outputStream.write(string, 'utf8', callback);
   }
 
+  // ### `_endStatement` finishes a pending statement and closes an open graph block
+  _endStatement() {
+    if (this._subject !== null) {
+      this._write(this._inDefaultGraph ? '.\n' : '\n}\n');
+      this._subject = null;
+      this._graph = DEFAULTGRAPH;
+    }
+  }
+
   // ### `_writeQuad` writes the quad to the output stream
   _writeQuad(subject, predicate, object, graph, done) {
     try {
@@ -313,10 +331,7 @@ class N3Writer {
       if (typeof iri !== 'string') iri = iri.value;
       hasPrefixes = true;
       // Finish a possible pending quad
-      if (this._subject !== null) {
-        this._write(this._inDefaultGraph ? '.\n' : '\n}\n');
-        this._subject = null, this._graph = '';
-      }
+      this._endStatement();
       // Store and write the prefix
       this._prefixIRIs[iri] = prefix += ':';
       this._prefixPatterns[iri] = (0, _Util.escapeRegex)(iri);
@@ -390,10 +405,7 @@ class N3Writer {
   // ### `end` signals the end of the output stream
   end(done) {
     // Finish a possible pending quad
-    if (this._subject !== null) {
-      this._write(this._inDefaultGraph ? '.\n' : '\n}\n');
-      this._subject = null;
-    }
+    this._endStatement();
     // Disallow further writing
     this._write = this._blockedWrite;
 

package/package.json

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

package/src/N3Lexer.js

@@ -81,8 +81,8 @@ export default class N3Lexer {
     this._blank = /_:((?:[0-9A-Z_a-z\xc0-\xd6\xd8-\xf6\xf8-\u02ff\u0370-\u037d\u037f-\u1fff\u200c\u200d\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd]|[\ud800-\udb7f][\udc00-\udfff])(?:\.?[\-0-9A-Z_a-z\xb7\xc0-\xd6\xd8-\xf6\xf8-\u037d\u037f-\u1fff\u200c\u200d\u203f\u2040\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd]|[\ud800-\udb7f][\udc00-\udfff])*)(?:[ \t]+|(?=\.?[,;:!\^\s#()\[\]\{\}"'<>]))/y;
     this._number = /[\-+]?(?:(\d+\.\d*|\.?\d+)[eE][\-+]?\d+|(?=\.?\d)\d*(?:(\.)\d+)?)(?=\.?[,;:!\^\s#()\[\]\{\}"'<>])/y;
     this._boolean = /(?:true|false)(?=[.,;!\^\s#()\[\]\{\}"'<>])/y;
-    this._atKeyword = /@[a-z]+(?=[\s#<:])/iy;
-    this._keyword = /(?:PREFIX|BASE|VERSION|GRAPH)(?=[\s#<])/iy;
+    this._atKeyword = /@[a-z]+(?=[\s#<:"'])/iy;
+    this._keyword = /(?:PREFIX|BASE|VERSION|GRAPH)(?=[\s#<"'])/iy;
     this._n3Verb = /(?:has|is|of)(?=[\s#()\[\]\{\}"'<>?_+\-0-9])/y;
     this._n3Id = /id(?=[\s#<])/y;
     this._shortPredicates = /a(?=[\s#()\[\]\{\}"'<>])/y;
@@ -101,6 +101,8 @@ export default class N3Lexer {
         if (!(key in lineModeRegExps) && this[key] instanceof RegExp)
           this[key] = invalidRegExp;
       }
+      // The only keyword in N-Triples and N-Quads is VERSION, which is case-sensitive
+      this._keyword = /VERSION(?=[\s#<"])/y;
     }
     // When not in line mode, enable N3 functionality by default
     else {
@@ -208,7 +210,7 @@ export default class N3Lexer {
       const line = this._line, firstChar = input[pos];
       let type = '', value = '', prefix = '',
           match = null, matchLength = 0, lexicalLength = 0,
-          finalLineLength = 0, inconclusive = false;
+          finalLineLength = 0, inconclusive = false, tripleQuoted = false;
       switch (firstChar) {
       case '^':
         // A datatype marker separated from its type cannot be followed by another marker
@@ -293,7 +295,7 @@ export default class N3Lexer {
           value = match[1];
         // Try to find a literal wrapped in three pairs of quotes
         else {
-          ({ value, matchLength, finalLineLength } = this._parseLiteral(input, pos));
+          ({ value, matchLength, finalLineLength, tripleQuoted } = this._parseLiteral(input, pos));
           if (value === null)
             return reportSyntaxError(this, input, pos);
         }
@@ -310,7 +312,7 @@ export default class N3Lexer {
             value = match[1];
           // Try to find a literal wrapped in three pairs of quotes
           else {
-            ({ value, matchLength, finalLineLength } = this._parseLiteral(input, pos));
+            ({ value, matchLength, finalLineLength, tripleQuoted } = this._parseLiteral(input, pos));
             if (value === null)
               return reportSyntaxError(this, input, pos);
           }
@@ -550,10 +552,15 @@ export default class N3Lexer {
       if (finalLineLength) {
         token = {
           type, value, prefix, line, start,
-          end: finalLineLength, endLine: this._line,
+          end: finalLineLength, endLine: this._line, tripleQuoted,
         };
         callback(null, token);
       }
+      // Triple-quoted strings are marked, since version declarations do not allow them
+      else if (tripleQuoted) {
+        token = { type, value, prefix, line, start, end: start + length, tripleQuoted };
+        callback(null, token);
+      }
       else
         token = emitToken(type, value, prefix, line, start, lexicalLength || length);
       this.previousToken = token;
@@ -705,19 +712,44 @@ export default class N3Lexer {
             break;
           this._line += lineCount;
           const finalLineLength = lineCount === 0 ? 0 : lines[lines.length - 1].length + openingLength;
-          return { value: this._unescape(raw, stringEscapeReplacements), matchLength, finalLineLength };
+          return {
+            value: this._unescape(raw, stringEscapeReplacements), matchLength, finalLineLength,
+            tripleQuoted: openingLength === 3,
+          };
         }
         closingPos++;
       }
       this._literalClosingPos = input.length - pos - openingLength + 1;
     }
-    return { value: '', matchLength: 0, finalLineLength: 0 };
+    return { value: '', matchLength: 0, finalLineLength: 0, tripleQuoted: false };
+  }
+
+  // ### `_tryTokenizeToEnd` tokenizes as far as possible, reporting failures through the callback
+  _tryTokenizeToEnd(callback, inputFinished) {
+    // Keep track of errors thrown by the callback, which must reach the caller unchanged
+    let callbackError;
+    try {
+      this._tokenizeToEnd((error, token) => {
+        try {
+          return callback(error, token);
+        }
+        catch (thrown) {
+          throw (callbackError = thrown);
+        }
+      }, inputFinished);
+    }
+    catch (error) {
+      // Matching an extremely long token can exhaust the regular expression stack
+      if (error === callbackError || !(error instanceof RangeError))
+        throw error;
+      callback(this._syntaxError(null, `Token too long on line ${this._line}.`));
+    }
   }
 
   // ### `_syntaxError` creates a syntax error for the given issue
-  _syntaxError(issue) {
+  _syntaxError(issue, message = `Unexpected "${issue}" on line ${this._line}.`) {
     this._input = null;
-    const err = new Error(`Unexpected "${issue}" on line ${this._line}.`);
+    const err = new Error(message);
     err.context = {
       token: undefined,
       line: this._line,
@@ -760,13 +792,13 @@ export default class N3Lexer {
       if (typeof callback === 'function')
         queueMicrotask(() => {
           if (this._tokenization === tokenization)
-            this._tokenizeToEnd(callback, true);
+            this._tryTokenizeToEnd(callback, true);
         });
       // If no callback was passed, tokenize synchronously and return
       else {
         const tokens = [];
         let error;
-        this._tokenizeToEnd((e, t) => e ? (error = e) : tokens.push(t), true);
+        this._tryTokenizeToEnd((e, t) => e ? (error = e) : tokens.push(t), true);
         if (error) throw error;
         return tokens;
       }
@@ -793,7 +825,7 @@ export default class N3Lexer {
           // Tokenize as far as possible. When a previous attempt left a long unfinished token,
           // wait until the buffered input has doubled, so the token is not rescanned for every chunk.
           if (this._input.length >= retryLength) {
-            this._tokenizeToEnd(callback, false);
+            this._tryTokenizeToEnd(callback, false);
             retryLength = this._input !== null && this._input.length > MIN_RESCAN_LENGTH ?
               2 * this._input.length : 0;
           }
@@ -807,7 +839,7 @@ export default class N3Lexer {
           if (rest)
             this._input = typeof this._input === 'string' ? this._input + rest : rest;
           if (typeof this._input === 'string')
-            this._tokenizeToEnd(callback, true);
+            this._tryTokenizeToEnd(callback, true);
         }
       });
       input.on('error', error => {

package/src/N3Parser.js

@@ -4,6 +4,10 @@ import N3DataFactory from './N3DataFactory';
 import namespaces from './IRIs';
 
 let blankNodePrefix = 0;
+// Detects `.` and `..` path segments in an IRI
+const dotSegments = /(^|\/)\.\.?($|[/#?])/;
+// Detects `.` and `..` segments in the path of an IRI, ignoring its query and fragment
+const pathDotSegments = /^[^?#]*(?:^|\/)\.\.?(?:$|[/#?])/;
 
 // ## Constructor
 export default class N3Parser {
@@ -84,6 +88,7 @@ export default class N3Parser {
     if (!baseIRI) {
       this._base = '';
       this._basePath = '';
+      this._basePathHasDotSegments = false;
     }
     else {
       // Remove fragment if present
@@ -104,6 +109,8 @@ export default class N3Parser {
       // relative IRIs merge under the path '/' (RFC 3986 §5.2.3)
       if (baseIRI[2] !== undefined && (base.length === this._baseRoot.length || base[this._baseRoot.length] === '?'))
         this._basePath = `${this._baseRoot}/`;
+      // Check once whether resolving against the base path needs to remove dot segments
+      this._basePathHasDotSegments = dotSegments.test(this._basePath);
     }
   }
 
@@ -141,7 +148,8 @@ export default class N3Parser {
     // Prefix and base declarations are scoped to their formula,
     // so record prefix changes to undo them when the formula ends
     if (type === 'formula') {
-      context.base = [this._base, this._basePath, this._baseRoot, this._baseScheme];
+      context.base = [this._base, this._basePath, this._baseRoot, this._baseScheme,
+        this._basePathHasDotSegments];
       this._prefixChanges = [];
     }
     this._contextStack.push(context);
@@ -183,7 +191,8 @@ export default class N3Parser {
       this._inversePredicate = context.inverse;
       this._expectOf = context.expectOf;
       if (type === 'formula')
-        [this._base, this._basePath, this._baseRoot, this._baseScheme] = context.base;
+        [this._base, this._basePath, this._baseRoot, this._baseScheme,
+          this._basePathHasDotSegments] = context.base;
       if (this._prefixChanges !== context.prefixChanges) {
         undoChanges(this._prefixes, this._prefixChanges);
         this._prefixChanges = context.prefixChanges;
@@ -1112,7 +1121,8 @@ export default class N3Parser {
   _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)
+    // Only short strings are allowed, so no numbers or booleans (which have a datatype prefix)
+    if (token.prefix !== '' || token.tripleQuoted)
       return this._error('Version declarations must use single quotes', token);
     this._versionCallback(token.value);
     if (!this._isValidVersion(token.value))
@@ -1576,14 +1586,19 @@ export default class N3Parser {
     // Resolve all other IRIs at the base IRI's path
     default:
       // Relative IRIs cannot contain a colon in the first path segment
-      return (/^[^/:]*:/.test(iri)) ? null : this._removeDotSegments(this._basePath + iri);
+      if (/^[^/:]*:/.test(iri))
+        return null;
+      // Only scan the joined IRI for dot segments if either part can contain them,
+      // as the base path can be long and the joined IRI would need to be copied
+      return this._basePathHasDotSegments || pathDotSegments.test(iri) ?
+        this._removeDotSegments(this._basePath + iri) : this._basePath + iri;
     }
   }
 
   // ### `_removeDotSegments` resolves './' and '../' path segments in an IRI as per RFC3986
   _removeDotSegments(iri) {
     // Don't modify the IRI if it does not contain any dot segments
-    if (!/(^|\/)\.\.?($|[/#?])/.test(iri))
+    if (!dotSegments.test(iri))
       return iri;
 
     // Start with an imaginary slash before the IRI in order to resolve trailing './' and '../'