n3 3.0.0-alpha.4 → 3.0.0-alpha.6

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 {
@@ -54,10 +58,17 @@ class N3Parser {
       return null;
     };
     this._blankNodePrefix = typeof options.blankNodePrefix !== 'string' ? '' : options.blankNodePrefix.replace(/^(?!_:)/, '_:');
+    // Map the token types of additional directives (@name and NAME) to their names
+    this._directives = null;
+    if (options.directives) {
+      this._directives = Object.create(null);
+      for (const name of options.directives) this._directives[`@${name.toLowerCase()}`] = this._directives[name.toUpperCase()] = name;
+    }
     this._lexer = options.lexer || new _N3Lexer.default({
       lineMode: isLineMode,
       n3: isN3,
-      isImpliedBy: this._isImpliedBy
+      isImpliedBy: this._isImpliedBy,
+      directives: options.directives
     });
     // Disable explicit quantifiers by default
     this._explicitQuantifiers = !!options.explicitQuantifiers;
@@ -66,6 +77,9 @@ class N3Parser {
     // Disable parsing of unsupported versions by default
     this._parseUnsupportedVersions = !!options.parseUnsupportedVersions;
     this._version = options.version;
+    // Maximum nesting depth of triple terms (default 1024; Infinity disables the limit)
+    const maxTripleTermDepth = options.maxTripleTermDepth;
+    this._maxTripleTermDepth = maxTripleTermDepth === Infinity || Number.isInteger(maxTripleTermDepth) && maxTripleTermDepth >= 0 ? maxTripleTermDepth : 1024;
   }
 
   // ## Static class methods
@@ -82,6 +96,7 @@ class N3Parser {
     if (!baseIRI) {
       this._base = '';
       this._basePath = '';
+      this._basePathHasDotSegments = false;
     } else {
       // Remove fragment if present
       const fragmentPos = baseIRI.indexOf('#');
@@ -91,12 +106,31 @@ class N3Parser {
       const queryPos = baseIRI.indexOf('?');
       const path = queryPos < 0 ? baseIRI : baseIRI.substr(0, queryPos);
       this._basePath = baseIRI.indexOf('/') < 0 ? baseIRI : path.substr(0, path.lastIndexOf('/') + 1);
-      baseIRI = baseIRI.match(/^(?:([a-z][a-z0-9+.-]*:))?(?:\/\/[^\/]*)?/i);
+      const base = baseIRI;
+      baseIRI = baseIRI.match(/^(?:([a-z][a-z0-9+.-]*:))?(\/\/[^\/?#]*)?/i);
       this._baseRoot = baseIRI[0];
       this._baseScheme = baseIRI[1];
+      // 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);
     }
   }
 
+  // ### `_enterTripleTerm` stores the current parsing context when entering a triple term,
+  // failing if triple terms nest deeper than the maximum depth
+  _enterTripleTerm(type, subject, predicate, token) {
+    if (this._tripleTermDepth >= this._maxTripleTermDepth) {
+      this._error(`Triple terms nested deeper than ${this._maxTripleTermDepth} level${this._maxTripleTermDepth === 1 ? '' : 's'}`, token);
+      return false;
+    }
+    this._tripleTermDepth++;
+    this._saveContext(type, this._graph, subject, predicate, null);
+    this._graph = null;
+    return true;
+  }
+
   // ### `_saveContext` stores the current parsing context
   // when entering a new scope (list, blank node, formula)
   _saveContext(type, graph, subject, predicate, object) {
@@ -127,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);
@@ -167,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;
@@ -219,8 +253,13 @@ class N3Parser {
         }
       case 'GRAPH':
         if (this._supportsNamedGraphs) return this._readNamedGraphLabel;
-      // Otherwise, the next token must be a subject
+      // Otherwise, the next token must be a subject, unless it is an additional directive
       default:
+        if (this._directives !== null && token.type in this._directives && this._graph === null) {
+          this._sparqlStyle = token.type[0] !== '@';
+          this._directiveCallback(this._directives[token.type]);
+          return this._readDeclarationPunctuation;
+        }
         return this._readSubject(token);
     }
   }
@@ -339,13 +378,9 @@ class N3Parser {
         }
       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;
+        return this._enterTripleTerm('<<(', null, null, token) && this._readSubject;
       case '<<':
-        this._saveContext('<<', this._graph, null, null, null);
-        this._graph = null;
-        return this._readSubject;
+        return this._enterTripleTerm('<<', null, null, token) && this._readSubject;
       default:
         // Read the subject entity
         if ((this._subject = this._readEntity(token)) === undefined) return;
@@ -468,13 +503,9 @@ class N3Parser {
         this._saveContext('formula', this._graph, this._subject, this._predicate, this._graph = this._factory.blankNode());
         return this._readInFormulaContext;
       case '<<(':
-        this._saveContext('<<(', this._graph, this._subject, this._predicate, null);
-        this._graph = null;
-        return this._readSubject;
+        return this._enterTripleTerm('<<(', this._subject, this._predicate, token) && this._readSubject;
       case '<<':
-        this._saveContext('<<', this._graph, this._subject, this._predicate, null);
-        this._graph = null;
-        return this._readSubject;
+        return this._enterTripleTerm('<<', this._subject, this._predicate, token) && this._readSubject;
       default:
         // Read the object entity
         if ((this._object = this._readEntity(token)) === undefined) return;
@@ -669,13 +700,8 @@ class N3Parser {
         this._subject = null;
         return this._readInFormulaContext;
       case '<<(':
-        this._saveContext('<<(', this._graph, null, null, null);
-        this._graph = null;
-        next = this._readSubject;
-        break;
       case '<<':
-        this._saveContext('<<', this._graph, null, null, null);
-        this._graph = null;
+        if (!this._enterTripleTerm(token.type, null, null, token)) return;
         next = this._readSubject;
         break;
       default:
@@ -1007,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;
@@ -1167,6 +1194,7 @@ class N3Parser {
     // Read the quad and restore the previous context
     const quad = this._createQuad(this._subject, this._predicate, this._object, this._graph, this._inversePredicate);
     this._restoreContext('<<(', token);
+    this._tripleTermDepth--;
 
     // If we're in a list, continue processing that list
     const stack = this._contextStack,
@@ -1202,6 +1230,7 @@ class N3Parser {
     this._tripleTerm = null;
     const reifier = this._readTripleTerm();
     this._restoreContext('<<', token);
+    this._tripleTermDepth--;
 
     // // If we're in a list, continue processing that list
     const stack = this._contextStack,
@@ -1426,19 +1455,25 @@ class N3Parser {
         }
       // Resolve root-relative IRIs at the root of the base IRI
       case '/':
-        // Resolve scheme-relative IRIs to the scheme
-        return (iri[1] === '/' ? this._baseScheme : this._baseRoot) + this._removeDotSegments(iri);
+        // Resolve scheme-relative IRIs to the scheme,
+        // keeping the reference's authority intact (RFC 3986 §5.2.4)
+        if (iri[1] !== '/') return this._baseRoot + this._removeDotSegments(iri);
+        // Without a base scheme, a leading ':' marks where the authority starts
+        return this._baseScheme ? this._removeDotSegments(this._baseScheme + iri) : this._removeDotSegments(`:${iri}`).substr(1);
       // 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;
@@ -1454,8 +1489,8 @@ class N3Parser {
           if (pathStart < 0) {
             // Skip two slashes before the authority
             if (iri[++i] === '/' && iri[++i] === '/')
-              // Skip to slash after the authority
-              while ((pathStart = i + 1) < length && iri[pathStart] !== '/') i = pathStart;
+              // Skip to the end of the authority
+              while ((pathStart = i + 1) < length && iri[pathStart] !== '/' && iri[pathStart] !== '?' && iri[pathStart] !== '#') i = pathStart;
           }
           break;
         // Don't modify a query string or fragment
@@ -1503,12 +1538,13 @@ class N3Parser {
   parse(input, quadCallback, prefixCallback, versionCallback) {
     // The second parameter also accepts an object of named callbacks.
     // As a second and third parameter it still accepts a separate quadCallback and prefixCallback for backward compatibility as well
-    let onQuad, onPrefix, onComment, onVersion, onToken, onTokenEnd;
-    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion || quadCallback.onToken || quadCallback.onTokenEnd)) {
+    let onQuad, onPrefix, onComment, onVersion, onDirective, onToken, onTokenEnd;
+    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion || quadCallback.onDirective || quadCallback.onToken || quadCallback.onTokenEnd)) {
       onQuad = quadCallback.onQuad;
       onPrefix = quadCallback.onPrefix;
       onComment = quadCallback.onComment;
       onVersion = quadCallback.onVersion;
+      onDirective = quadCallback.onDirective;
       onToken = quadCallback.onToken;
       onTokenEnd = quadCallback.onTokenEnd;
     } else {
@@ -1526,6 +1562,7 @@ class N3Parser {
     if (this._n3Mode && this._implicitEmptyPrefix && this._base) this._prefixes[''] = this._resolveIRI('#');
     this._prefixCallback = onPrefix || noop;
     this._versionCallback = onVersion || noop;
+    this._directiveCallback = onDirective || noop;
     this._inversePredicate = false;
     this._expectOf = false;
     this._quantified = Object.create(null);
@@ -1533,6 +1570,7 @@ class N3Parser {
     this._prefixChanges = null;
     this._quantifiedChanges = null;
     this._emptyFormula = false;
+    this._tripleTermDepth = 0;
     let readToken = token => {
       return this._readCallback = this._readCallback(token);
     };

package/lib/N3Reasoner.js

@@ -154,7 +154,7 @@ class N3Reasoner {
     premise,
     conclusion
   }) {
-    const varMapping = {};
+    const varMapping = Object.create(null);
     const toId = value => value.termType === 'Variable' ?
     // If the term is a variable, then create an empty object that values can be placed into
     varMapping[value.value] = varMapping[value.value] || {} :

package/lib/N3Store.js

@@ -116,6 +116,31 @@ function difference(s1, s2, depth = 4) {
   return target;
 }
 
+// Returns the key of a term in the entity index.
+// Keys mark the term type by their first character, so the IRI of a named node
+// that starts with such a marker (as relative IRIs can) is wrapped in < and >.
+const markedIRI = /^[?_"[.<]/;
+function entityKey(term) {
+  // Strings are term ids, which only need wrapping when they are IRIs starting with <
+  if (typeof term === 'string') return term.charCodeAt(0) !== 0x3C || term === '<>' ? term : `<${term}>`;
+  // IDs of IRIs usually start with a lowercase scheme letter, which never marks a term type
+  const id = (0, _N3DataFactory.termToId)(term);
+  if (id.charCodeAt(0) >= 0x61 || !term) return id;
+  // Keys of quoted triples are built from the keys of their components
+  if (term.termType === 'Quad') return JSON.stringify(quadKeyParts(term));
+  return term.termType !== 'NamedNode' || !markedIRI.test(term.value) ? id : `<${term.value}>`;
+}
+
+// Returns the keys of the components of a quad, nested like the parts of its internal id
+function quadKeyParts(quad) {
+  const parts = [nestedKey(quad.subject), nestedKey(quad.predicate), nestedKey(quad.object)];
+  if (quad.graph && !(0, _N3Util.isDefaultGraph)(quad.graph)) parts.push(nestedKey(quad.graph));
+  return parts;
+}
+function nestedKey(term) {
+  return term.termType === 'Quad' ? quadKeyParts(term) : entityKey(term);
+}
+
 // ## Constructor
 class N3EntityIndex {
   constructor(options = {}) {
@@ -132,6 +157,9 @@ class N3EntityIndex {
     this._factory = options.factory || _N3DataFactory.default;
   }
   _termFromId(id) {
+    // A key in < and > is a named node
+    if (id[0] === '<') return this._factory.namedNode(id.substring(1, id.length - 1));
+    // A key starting with . is a quoted triple
     if (id[0] === '.') {
       const entities = this._entities;
       const terms = id.split('.');
@@ -148,12 +176,25 @@ class N3EntityIndex {
       let g;
       return s && p && o && ((0, _N3Util.isDefaultGraph)(term.graph) || (g = this._termToNumericId(term.graph))) && this._ids[g ? `.${s}.${p}.${o}.${g}` : `.${s}.${p}.${o}`];
     }
-    return this._ids[(0, _N3DataFactory.termToId)(term)];
+    return typeof term === 'string' ? this._stringToNumericId(term) : this._ids[entityKey(term)];
+  }
+
+  // Returns the numeric id of a term given as a string id
+  _stringToNumericId(term) {
+    // The string is the key unless it is an IRI starting with <. Read the first character
+    // from the stored key after a match, which is cheaper than from a concatenated string.
+    const id = this._ids[term];
+    if (id ? this._entities[id].charCodeAt(0) !== 0x3C : term.charCodeAt(0) !== 0x3C) return id;
+    return term === '<>' ? id : this._ids[`<${term}>`];
   }
   _termToNewNumericId(term) {
+    if (typeof term === 'string') return this._stringToNumericId(term) || this._addEntity(entityKey(term));
     // This assumes that no graph term is present - we may wish to error if there is one
-    const str = term && term.termType === 'Quad' ? `.${this._termToNewNumericId(term.subject)}.${this._termToNewNumericId(term.predicate)}.${this._termToNewNumericId(term.object)}${(0, _N3Util.isDefaultGraph)(term.graph) ? '' : `.${this._termToNewNumericId(term.graph)}`}` : (0, _N3DataFactory.termToId)(term);
-    return this._ids[str] || (this._ids[this._entities[++this._id] = str] = this._id);
+    const str = term && term.termType === 'Quad' ? `.${this._termToNewNumericId(term.subject)}.${this._termToNewNumericId(term.predicate)}.${this._termToNewNumericId(term.object)}${(0, _N3Util.isDefaultGraph)(term.graph) ? '' : `.${this._termToNewNumericId(term.graph)}`}` : entityKey(term);
+    return this._ids[str] || this._addEntity(str);
+  }
+  _addEntity(key) {
+    return this._ids[this._entities[++this._id] = key] = this._id;
   }
   createBlankNode(suggestedName) {
     let name, index;
@@ -576,8 +617,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
@@ -1305,7 +1349,7 @@ function intersectMatchPatterns(left, right) {
   for (let i = 0; i < 4; i++) {
     const leftTerm = left[i],
       rightTerm = right[i];
-    if (leftTerm === null || leftTerm === undefined) result[i] = rightTerm;else if (rightTerm === null || rightTerm === undefined || (0, _N3DataFactory.termToId)(leftTerm) === (0, _N3DataFactory.termToId)(rightTerm)) result[i] = leftTerm;else return false;
+    if (leftTerm === null || leftTerm === undefined) result[i] = rightTerm;else if (rightTerm === null || rightTerm === undefined || entityKey(leftTerm) === entityKey(rightTerm)) result[i] = leftTerm;else return false;
   }
   return result;
 }
@@ -1368,7 +1412,7 @@ class DatasetCoreAndReadableStream extends _readableStream.Readable {
       object,
       graph
     } = this;
-    return !this._matchesNothing && (subject === null || subject === undefined || (0, _N3DataFactory.termToId)(subject) === (0, _N3DataFactory.termToId)(quad.subject)) && (predicate === null || predicate === undefined || (0, _N3DataFactory.termToId)(predicate) === (0, _N3DataFactory.termToId)(quad.predicate)) && (object === null || object === undefined || (0, _N3DataFactory.termToId)(object) === (0, _N3DataFactory.termToId)(quad.object)) && (graph === null || graph === undefined || (0, _N3DataFactory.termToId)(graph) === (0, _N3DataFactory.termToId)(quad.graph));
+    return !this._matchesNothing && (subject === null || subject === undefined || entityKey(subject) === entityKey(quad.subject)) && (predicate === null || predicate === undefined || entityKey(predicate) === entityKey(quad.predicate)) && (object === null || object === undefined || entityKey(object) === entityKey(quad.object)) && (graph === null || graph === undefined || entityKey(graph) === entityKey(quad.graph));
   }
 
   // ### `_assertMatchesPattern` rejects a Quad outside this view.

package/lib/N3StreamParser.js

@@ -28,6 +28,10 @@ class N3StreamParser extends _readableStream.Transform {
       // Emit prefixes through the `prefix` event
       onPrefix: (prefix, uri) => {
         this.emit('prefix', prefix, uri);
+      },
+      // Emit additional directives through the `directive` event
+      onDirective: name => {
+        this.emit('directive', name);
       }
     };
     if (options && options.comments) callbacks.onComment = comment => {

package/lib/N3Writer.js

@@ -18,10 +18,19 @@ const {
   rdf,
   xsd
 } = _IRIs.default;
+const {
+  hasOwnProperty
+} = Object.prototype;
 
-// Characters in literals that require escaping
+// Characters that require escaping in Turtle, TriG, and N3,
+// where characters outside the Basic Multilingual Plane are escaped as well
 const escape = /["\\\t\n\r\b\f\u0000-\u0019\ud800-\udbff]/,
   escapeAll = /["\\\t\n\r\b\f\u0000-\u0019]|[\ud800-\udbff][\udc00-\udfff]/g,
+  // Characters that require escaping in canonical N-Triples and N-Quads:
+  // U+0000–U+001F, `"`, `\`, U+007F, U+FFFE, and U+FFFF.
+  // A negated class is as fast to test as a shorter class listing characters.
+  canonicalEscape = /[^ !#-\[\]-~\u0080-\uFFFD]/,
+  canonicalEscapeAll = /[^ !#-\[\]-~\u0080-\uFFFD]/g,
   escapedCharacters = {
     '\\': '\\\\',
     '"': '\\"',
@@ -32,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
@@ -71,12 +83,20 @@ 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);
       if (options.baseIRI) {
         this._baseIri = new _BaseIRI.default(options.baseIRI);
         if (options.writeBase !== false) this._write(`@base <${options.baseIRI}>.\n`);
@@ -85,6 +105,10 @@ class N3Writer {
     } else {
       this._lineMode = true;
       this._writeQuad = this._writeQuadLine;
+      // 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`);
     }
   }
 
@@ -100,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 {
@@ -163,7 +196,7 @@ class N3Writer {
     // A blank node or list is represented as-is
     if (entity.termType !== 'NamedNode') {
       // If it is a list head, pretty-print it
-      if (this._lists && entity.value in this._lists) entity = this.list(this._lists[entity.value]);
+      if (this._lists && hasOwnProperty.call(this._lists, entity.value)) entity = this.list(this._lists[entity.value]);
       // Terms from this library already hold their serialization as id
       if (entity instanceof _N3DataFactory.Term) return entity.id;
       return entity.termType === 'Variable' ? `?${entity.value}` : `_:${entity.value}`;
@@ -174,9 +207,9 @@ class N3Writer {
       iri = this._baseIri.toRelative(iri);
     }
     // Escape special characters
-    if (escape.test(iri)) iri = iri.replace(escapeAll, characterReplacer);
+    if (this._escape.test(iri)) iri = iri.replace(this._escapeAll, this._characterReplacer);
     // Try to represent the IRI as prefixed name, unless no prefixes were added
-    const prefixMatch = this._hasPrefixes ? this._prefixRegex.exec(iri) : null;
+    const prefixMatch = this._hasPrefixes ? (this._prefixRegex || this._createPrefixRegex()).exec(iri) : null;
     return !prefixMatch ? `<${iri}>` : this._prefixIRIs[prefixMatch[1]] + prefixMatch[2];
   }
 
@@ -184,7 +217,7 @@ class N3Writer {
   _encodeLiteral(literal) {
     // Escape special characters
     let value = literal.value;
-    if (escape.test(value)) value = value.replace(escapeAll, characterReplacer);
+    if (this._escape.test(value)) value = value.replace(this._escapeAll, this._characterReplacer);
 
     // Write a language-tagged literal
     const language = literal.language;
@@ -254,7 +287,9 @@ class N3Writer {
     object,
     graph
   }) {
-    return `<<(${this._encodeSubject(subject)} ${this._encodePredicate(predicate)} ${this._encodeObject(object)}${(0, _N3Util.isDefaultGraph)(graph) ? '' : ` ${this._encodeIriOrBlank(graph)}`})>>`;
+    // Canonical N-Triples and N-Quads put spaces inside the delimiters
+    const space = this._lineMode ? ' ' : '';
+    return `<<(${space}${this._encodeSubject(subject)} ${this._encodePredicate(predicate)} ${this._encodeObject(object)}${(0, _N3Util.isDefaultGraph)(graph) ? '' : ` ${this._encodeIriOrBlank(graph)}`}${space})>>`;
   }
 
   // ### `_blockedWrite` replaces `_write` after the writer has been closed
@@ -296,26 +331,29 @@ 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);
       this._write(`@prefix ${prefix} <${iri}>.\n`);
     }
-    // Recreate the prefix matcher
+    // Recreate the prefix matcher when it is next needed, so that adding
+    // prefixes one by one does not rebuild it for every prefix
     if (hasPrefixes) {
       this._hasPrefixes = true;
-      let IRIlist = '';
-      for (const prefixIRI in this._prefixIRIs) IRIlist += IRIlist ? `|${prefixIRI}` : prefixIRI;
-      IRIlist = (0, _Util.escapeRegex)(IRIlist, /[\]\/\(\)\*\+\?\.\\\$]/g, '\\$&');
-      this._prefixRegex = new RegExp(`^(${IRIlist})([_a-zA-Z0-9](?:\\.?[\\-_a-zA-Z0-9])*)$`);
+      this._prefixRegex = null;
     }
     // End a prefix block with a newline
     this._write(hasPrefixes ? '\n' : '', done);
   }
 
+  // ### `_createPrefixRegex` creates the matcher for the current prefixes
+  _createPrefixRegex() {
+    let IRIlist = '';
+    for (const prefixIRI in this._prefixPatterns) IRIlist += IRIlist ? `|${this._prefixPatterns[prefixIRI]}` : this._prefixPatterns[prefixIRI];
+    return this._prefixRegex = new RegExp(`^(${IRIlist})([_a-zA-Z0-9](?:\\.?[\\-_a-zA-Z0-9])*)$`);
+  }
+
   // ### `blank` creates a blank node with the given content
   blank(predicate, object) {
     let children = predicate,
@@ -367,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;
 
@@ -405,4 +440,15 @@ function characterReplacer(character) {
     }
   }
   return result;
+}
+
+// Replaces a character by its canonical N-Triples escape:
+// a short escape where one exists, and an upper-case `\uXXXX` escape otherwise
+function canonicalCharacterReplacer(character) {
+  let result = escapedCharacters[character];
+  if (result === undefined) {
+    result = character.charCodeAt(0).toString(16).toUpperCase();
+    result = '\\u0000'.substr(0, 6 - result.length) + result;
+  }
+  return result;
 }

package/lib/Util.js

@@ -5,5 +5,5 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.escapeRegex = escapeRegex;
 function escapeRegex(regex) {
-  return regex.replace(/[\]\/\(\)\*\+\?\.\\\$]/g, '\\$&');
+  return regex.replace(/[.*+?^${}()|[\]\\/-]/g, '\\$&');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n3",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0-alpha.6",
   "description": "Lightning fast, asynchronous, streaming Turtle / N3 / RDF library.",
   "author": "Ruben Verborgh <ruben.verborgh@gmail.com>",
   "keywords": [
@@ -60,44 +60,17 @@
     "test": "jest",
     "lint": "eslint src perf test spec",
     "prepare": "npm run build",
-    "spec": "npm run spec-1-1 && npm run spec-1-2 && npm run spec-n3",
-    "spec-1-1": "npm run spec-1-1-turtle && npm run spec-1-1-ntriples && npm run spec-1-1-nquads && npm run spec-1-1-trig",
+    "spec": "node spec/run.js",
     "spec-1-1-earl": "npm run spec-1-1-earl-turtle && npm run spec-1-1-earl-ntriples && npm run spec-1-1-earl-nquads && npm run spec-1-1-earl-trig",
-    "spec-1-1-ntriples": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-n-triples/manifest.ttl -i '{ \"format\": \"n-triples\" }' -c .rdf-test-suite-cache/",
-    "spec-1-1-nquads": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-n-quads/manifest.ttl -i '{ \"format\": \"n-quads\" }' -c .rdf-test-suite-cache/",
-    "spec-1-1-turtle": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-turtle/manifest.ttl -i '{ \"format\": \"turtle\" }' -c .rdf-test-suite-cache/ --skip \"(bad-numeric-escape|bareword_decimal)\"",
-    "spec-1-1-trig": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-trig/manifest.ttl -i '{ \"format\": \"trig\" }' -c .rdf-test-suite-cache/  --skip \"(bad-numeric-escape|IRI-resolution-01)\"",
     "spec-1-1-earl-ntriples": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-n-triples/manifest.ttl -i '{ \"format\": \"n-triples\" }' -c .rdf-test-suite-cache/ -o earl -p spec/earl-meta.json > spec/earl-ntriples.ttl",
     "spec-1-1-earl-nquads": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-n-quads/manifest.ttl -i '{ \"format\": \"n-quads\" }' -c .rdf-test-suite-cache/ -o earl -p spec/earl-meta.json > spec/earl-nquads.ttl",
     "spec-1-1-earl-turtle": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-turtle/manifest.ttl -i '{ \"format\": \"turtle\" }' -c .rdf-test-suite-cache/ -o earl -p spec/earl-meta.json > spec/earl-turtle.ttl",
     "spec-1-1-earl-trig": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-trig/manifest.ttl -i '{ \"format\": \"trig\" }' -c .rdf-test-suite-cache/ -o earl -p spec/earl-meta.json > spec/earl-trig.ttl",
-    "spec-1-2": "npm run spec-1-2-turtle && npm run spec-1-2-ntriples && npm run spec-1-2-nquads && npm run spec-1-2-trig && npm run spec-1-2-turtle-eval && npm run spec-1-2-trig-eval",
     "spec-1-2-earl": "npm run spec-1-2-earl-turtle && npm run spec-1-2-earl-ntriples && npm run spec-1-2-earl-nquads && npm run spec-1-2-earl-trig",
-    "spec-1-2-ntriples": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-n-triples/syntax/manifest.ttl -i '{ \"format\": \"n-triples\" }' -c .rdf-test-suite-cache/",
-    "spec-1-2-nquads": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-n-quads/syntax/manifest.ttl -i '{ \"format\": \"n-quads\" }' -c .rdf-test-suite-cache/",
-    "spec-1-2-turtle": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-turtle/syntax/manifest.ttl -i '{ \"format\": \"turtle\" }' -c .rdf-test-suite-cache/",
-    "spec-1-2-trig": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-trig/syntax/manifest.ttl -i '{ \"format\": \"trig\" }' -c .rdf-test-suite-cache/",
-    "spec-1-2-turtle-eval": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-turtle/eval/manifest.ttl -i '{ \"format\": \"turtle\" }' -c .rdf-test-suite-cache/",
-    "spec-1-2-trig-eval": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-trig/eval/manifest.ttl -i '{ \"format\": \"trig\" }' -c .rdf-test-suite-cache/",
     "spec-1-2-earl-ntriples": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-n-triples/syntax/manifest.ttl -i '{ \"format\": \"n-triples\" }' -c .rdf-test-suite-cache/ -o earl -p spec/earl-meta.json > spec/earl-ntriples.ttl",
     "spec-1-2-earl-nquads": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-n-quads/syntax/manifest.ttl -i '{ \"format\": \"n-quads\" }' -c .rdf-test-suite-cache/ -o earl -p spec/earl-meta.json > spec/earl-nquads.ttl",
     "spec-1-2-earl-turtle": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-turtle/syntax/manifest.ttl -i '{ \"format\": \"turtle\" }' -c .rdf-test-suite-cache/ -o earl -p spec/earl-meta.json > spec/earl-turtle.ttl",
     "spec-1-2-earl-trig": "rdf-test-suite spec/parser.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-trig/syntax/manifest.ttl -i '{ \"format\": \"trig\" }' -c .rdf-test-suite-cache/ -o earl -p spec/earl-meta.json > spec/earl-trig.ttl",
-    "spec-writer": "npm run spec-writer-1-1-turtle && npm run spec-writer-1-1-ntriples && npm run spec-writer-1-1-nquads && npm run spec-writer-1-1-trig && npm run spec-writer-1-2-turtle && npm run spec-writer-1-2-ntriples && npm run spec-writer-1-2-nquads && npm run spec-writer-1-2-trig && npm run spec-writer-1-2-turtle-eval && npm run spec-writer-1-2-trig-eval",
-    "spec-writer-1-1-turtle": "rdf-test-suite spec/writer.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-turtle/manifest.ttl -i '{ \"format\": \"turtle\" }' -c .rdf-test-suite-cache/ --skip \"(bad-numeric-escape|bareword_decimal)\"",
-    "spec-writer-1-1-ntriples": "rdf-test-suite spec/writer.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-n-triples/manifest.ttl -i '{ \"format\": \"n-triples\" }' -c .rdf-test-suite-cache/",
-    "spec-writer-1-1-nquads": "rdf-test-suite spec/writer.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-n-quads/manifest.ttl -i '{ \"format\": \"n-quads\" }' -c .rdf-test-suite-cache/",
-    "spec-writer-1-1-trig": "rdf-test-suite spec/writer.js https://w3c.github.io/rdf-tests/rdf/rdf11/rdf-trig/manifest.ttl -i '{ \"format\": \"trig\" }' -c .rdf-test-suite-cache/ --skip \"(bad-numeric-escape|IRI-resolution-01)\"",
-    "spec-writer-1-2-turtle": "rdf-test-suite spec/writer.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-turtle/syntax/manifest.ttl -i '{ \"format\": \"turtle\" }' -c .rdf-test-suite-cache/",
-    "spec-writer-1-2-ntriples": "rdf-test-suite spec/writer.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-n-triples/syntax/manifest.ttl -i '{ \"format\": \"n-triples\" }' -c .rdf-test-suite-cache/",
-    "spec-writer-1-2-nquads": "rdf-test-suite spec/writer.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-n-quads/syntax/manifest.ttl -i '{ \"format\": \"n-quads\" }' -c .rdf-test-suite-cache/",
-    "spec-writer-1-2-trig": "rdf-test-suite spec/writer.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-trig/syntax/manifest.ttl -i '{ \"format\": \"trig\" }' -c .rdf-test-suite-cache/",
-    "spec-writer-1-2-turtle-eval": "rdf-test-suite spec/writer.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-turtle/eval/manifest.ttl -i '{ \"format\": \"turtle\" }' -c .rdf-test-suite-cache/",
-    "spec-writer-1-2-trig-eval": "rdf-test-suite spec/writer.js https://w3c.github.io/rdf-tests/rdf/rdf12/rdf-trig/eval/manifest.ttl -i '{ \"format\": \"trig\" }' -c .rdf-test-suite-cache/",
-    "spec-n3": "npm run spec-n3-parser && npm run spec-n3-extended",
-    "spec-n3-fetch": "sh scripts/fetch-n3-tests.sh",
-    "spec-n3-parser": "npm run spec-n3-fetch && rdf-test-suite spec/parser.js https://w3c-cg.github.io/N3/tests/N3Tests/manifest-parser.ttl -i '{ \"format\": \"text/n3\" }' -m 'https://w3c-cg.github.io/N3/tests/~.n3-tests/tests/'",
-    "spec-n3-extended": "npm run spec-n3-fetch && rdf-test-suite spec/parser.js https://w3c-cg.github.io/N3/tests/N3Tests/manifest-extended.ttl -i '{ \"format\": \"text/n3\" }' -m 'https://w3c-cg.github.io/N3/tests/~.n3-tests/tests/'",
     "spec-clean": "rm -rf .rdf-test-suite-cache/ .n3-tests/",
     "docs": "cd src && docco *.js -o ../docs && cd .."
   },