n3 2.11.8 → 2.12.1

package/lib/N3Lexer.js

@@ -93,6 +93,9 @@ function isSeparatorCode(code) {
   return code === SPACE || code === TAB || code === LF || code === CR || code === HASH;
 }
 
+// Words with a fixed meaning in the grammar, which cannot name an additional directive
+const reservedWords = /^(?:prefix|base|version|graph|forsome|forall|iri|a|true|false|has|is|of|id)$/i;
+
 // Unfinished input in a stream up to this length is tokenized again with every chunk
 const MIN_RESCAN_LENGTH = 1024;
 
@@ -137,6 +140,18 @@ class N3Lexer {
     else {
       this._n3Mode = options.n3 !== false;
     }
+    // Recognize additional directive keywords, such as MESSAGE
+    // (the @-form of a directive is always tokenized as an @-keyword)
+    this._directive = null;
+    if (options.directives && options.directives.length !== 0) {
+      for (const name of options.directives) {
+        if (!/^[a-z]+$/i.test(name) || reservedWords.test(name)) throw new Error(`Invalid directive name: "${name}"`);
+      }
+      this._directive = new RegExp(`(?:${options.directives.join('|')})(?=[\\s#<])`, 'iy');
+      this._directiveMaxLength = Math.max(...options.directives.map(name => name.length));
+      // The first characters of directive names, so other words skip the regular expression
+      this._directiveStarts = options.directives.map(name => name[0].toLowerCase() + name[0].toUpperCase()).join('');
+    }
     // Don't output comment tokens by default
     this.comments = !!options.comments;
     // Cache the last tested closing position of long literals
@@ -457,6 +472,9 @@ class N3Lexer {
       if (inconclusive) {
         // Try to find a prefix
         if ((this._previousMarker === '@prefix' || this._previousMarker === 'PREFIX') && (match = execAt(this._prefix, input, pos))) type = 'prefix', value = match[1] || '';
+        // Try to find an additional directive keyword
+        // (at the end of the input, only a short final word can be one)
+        else if (this._directive !== null && this._directiveStarts.includes(firstChar) && ((match = execAt(this._directive, input, pos)) || inputFinished && input.length - pos <= this._directiveMaxLength && (match = execAtEnd(this._directive, input, pos)))) type = match[0].toUpperCase();
         // Try to find a prefixed name. Since it can contain (but not end with) a dot,
         // we always need a non-dot character before deciding it is a prefixed name.
         // Therefore, try inserting a space if we're at the end of the input.
@@ -508,7 +526,8 @@ class N3Lexer {
         callback(null, token);
       } else token = emitToken(type, value, prefix, line, start, lexicalLength || length);
       this.previousToken = token;
-      this._previousMarker = type;
+      // The string of a version declaration cannot take a language tag, so a following @keyword is a keyword
+      this._previousMarker = type === 'literal' && (this._previousMarker === 'VERSION' || this._previousMarker === '@version') ? 'version' : type;
 
       // Advance to next part to tokenize
       pos = Math.min(pos + length, input.length);
@@ -666,10 +685,29 @@ class N3Lexer {
     };
   }
 
+  // ### `_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,
@@ -710,13 +748,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;
       }
@@ -743,7 +781,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;
           }
         }
@@ -754,7 +792,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

@@ -53,10 +53,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;
@@ -238,8 +245,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);
     }
   }
@@ -1514,12 +1526,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 {
@@ -1537,6 +1550,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);

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,6 +18,9 @@ const {
   rdf,
   xsd
 } = _IRIs.default;
+const {
+  hasOwnProperty
+} = Object.prototype;
 
 // Characters that require escaping in Turtle, TriG, and N3,
 // where characters outside the Basic Multilingual Plane are escaped as well
@@ -38,6 +41,14 @@ const escape = /["\\\t\n\r\b\f\u0000-\u0019\ud800-\udbff]/,
     '\f': '\\f'
   };
 
+// A local name (PN_LOCAL) as written in a prefixed name, without backslash escapes,
+// so that it denotes the same characters as the IRI it is taken from.
+// Characters outside the Basic Multilingual Plane are escaped before matching, so they never occur.
+const localNameStart = 'A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF' + '\\u200C\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD_:0-9',
+  localNameChar = `${localNameStart}\\-\\u00B7\\u0300-\\u036F\\u203F\\u2040`,
+  percent = '%[0-9A-Fa-f]{2}',
+  localName = new RegExp(`^(?:(?:[${localNameStart}]|${percent})` + `(?:(?:[${localNameChar}.]|${percent})*(?:[${localNameChar}]|${percent}))?)?$`);
+
 // ## Placeholder class to represent already pretty-printed terms
 class SerializedTerm extends _N3DataFactory.Term {
   // Pretty-printed nodes are not equal to any other node
@@ -175,7 +186,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}`;
@@ -189,7 +200,11 @@ class N3Writer {
     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 || this._createPrefixRegex()).exec(iri) : null;
-    return !prefixMatch ? `<${iri}>` : !prefixMatch[1] ? iri : this._prefixIRIs[prefixMatch[1]] + prefixMatch[2];
+    if (!prefixMatch) return `<${iri}>`;
+    // An IRI that starts with a registered prefix IRI
+    if (prefixMatch[1]) return this._prefixIRIs[prefixMatch[1]] + prefixMatch[2];
+    // An IRI that already looks like a prefixed name, if the rest is a valid local name
+    return localName.test(iri.slice(prefixMatch[0].length)) ? iri : `<${iri}>`;
   }
 
   // ### `_encodeLiteral` represents a literal
@@ -338,7 +353,7 @@ class N3Writer {
       IRIlist += IRIlist ? `|${IRIpattern}` : IRIpattern;
       prefixList += prefixList ? `|${prefixPattern}` : prefixPattern;
     }
-    return this._prefixRegex = new RegExp(`^(?:${prefixList})[^/]*$|` + `^(${IRIlist})([_a-zA-Z0-9](?:\\.?[\\-_a-zA-Z0-9])*)$`);
+    return this._prefixRegex = new RegExp(`^(${IRIlist})([_a-zA-Z0-9](?:\\.?[\\-_a-zA-Z0-9])*)$|` + `^(?:${prefixList})`);
   }
 
   // ### `blank` creates a blank node with the given content

package/package.json

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

package/src/N3Lexer.js

@@ -58,6 +58,9 @@ function isSeparatorCode(code) {
   return code === SPACE || code === TAB || code === LF || code === CR || code === HASH;
 }
 
+// Words with a fixed meaning in the grammar, which cannot name an additional directive
+const reservedWords = /^(?:prefix|base|version|graph|forsome|forall|iri|a|true|false|has|is|of|id)$/i;
+
 // Unfinished input in a stream up to this length is tokenized again with every chunk
 const MIN_RESCAN_LENGTH = 1024;
 
@@ -103,6 +106,19 @@ export default class N3Lexer {
     else {
       this._n3Mode = options.n3 !== false;
     }
+    // Recognize additional directive keywords, such as MESSAGE
+    // (the @-form of a directive is always tokenized as an @-keyword)
+    this._directive = null;
+    if (options.directives && options.directives.length !== 0) {
+      for (const name of options.directives) {
+        if (!/^[a-z]+$/i.test(name) || reservedWords.test(name))
+          throw new Error(`Invalid directive name: "${name}"`);
+      }
+      this._directive = new RegExp(`(?:${options.directives.join('|')})(?=[\\s#<])`, 'iy');
+      this._directiveMaxLength = Math.max(...options.directives.map(name => name.length));
+      // The first characters of directive names, so other words skip the regular expression
+      this._directiveStarts = options.directives.map(name => name[0].toLowerCase() + name[0].toUpperCase()).join('');
+    }
     // Don't output comment tokens by default
     this.comments = !!options.comments;
     // Cache the last tested closing position of long literals
@@ -486,6 +502,13 @@ export default class N3Lexer {
         if ((this._previousMarker === '@prefix' || this._previousMarker === 'PREFIX') &&
             (match = execAt(this._prefix, input, pos)))
           type = 'prefix', value = match[1] || '';
+        // Try to find an additional directive keyword
+        // (at the end of the input, only a short final word can be one)
+        else if (this._directive !== null && this._directiveStarts.includes(firstChar) &&
+                 ((match = execAt(this._directive, input, pos)) ||
+                 inputFinished && input.length - pos <= this._directiveMaxLength &&
+                 (match = execAtEnd(this._directive, input, pos))))
+          type = match[0].toUpperCase();
         // Try to find a prefixed name. Since it can contain (but not end with) a dot,
         // we always need a non-dot character before deciding it is a prefixed name.
         // Therefore, try inserting a space if we're at the end of the input.
@@ -534,7 +557,8 @@ export default class N3Lexer {
       else
         token = emitToken(type, value, prefix, line, start, lexicalLength || length);
       this.previousToken = token;
-      this._previousMarker = type;
+      // The string of a version declaration cannot take a language tag, so a following @keyword is a keyword
+      this._previousMarker = type === 'literal' && (this._previousMarker === 'VERSION' || this._previousMarker === '@version') ? 'version' : type;
 
       // Advance to next part to tokenize
       pos = Math.min(pos + length, input.length);
@@ -690,10 +714,32 @@ export default class N3Lexer {
     return { value: '', matchLength: 0, finalLineLength: 0 };
   }
 
+  // ### `_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,
@@ -736,13 +782,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;
       }
@@ -769,7 +815,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;
           }
@@ -783,7 +829,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

@@ -46,7 +46,16 @@ export default class N3Parser {
       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 });
+    // 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({
+      lineMode: isLineMode, n3: isN3, isImpliedBy: this._isImpliedBy, directives: options.directives,
+    });
     // Disable explicit quantifiers by default
     this._explicitQuantifiers = !!options.explicitQuantifiers;
     // Disable formula-only blank node scoping by default
@@ -228,8 +237,13 @@ export default 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);
     }
   }
@@ -1634,13 +1648,14 @@ export default 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;
+    let onQuad, onPrefix, onComment, onVersion, onDirective, onToken, onTokenEnd;
     if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion ||
-                         quadCallback.onToken || quadCallback.onTokenEnd)) {
+                         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;
     }
@@ -1661,6 +1676,7 @@ export default class N3Parser {
       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);

package/src/N3StreamParser.js

@@ -16,6 +16,8 @@ export default class N3StreamParser extends Transform {
       onQuad: (error, quad) => { error && this.emit('error', error) || quad && this.push(quad); },
         // 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)

package/src/N3Writer.js

@@ -8,6 +8,7 @@ import { escapeRegex } from './Util';
 const DEFAULTGRAPH = N3DataFactory.defaultGraph();
 
 const { rdf, xsd } = namespaces;
+const { hasOwnProperty } = Object.prototype;
 
 // Characters that require escaping in Turtle, TriG, and N3,
 // where characters outside the Basic Multilingual Plane are escaped as well
@@ -23,6 +24,16 @@ const escape    = /["\\\t\n\r\b\f\u0000-\u0019\ud800-\udbff]/,
       '\n': '\\n', '\r': '\\r', '\b': '\\b', '\f': '\\f',
     };
 
+// A local name (PN_LOCAL) as written in a prefixed name, without backslash escapes,
+// so that it denotes the same characters as the IRI it is taken from.
+// Characters outside the Basic Multilingual Plane are escaped before matching, so they never occur.
+const localNameStart = 'A-Za-z\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF' +
+                       '\\u200C\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD_:0-9',
+    localNameChar = `${localNameStart}\\-\\u00B7\\u0300-\\u036F\\u203F\\u2040`,
+    percent = '%[0-9A-Fa-f]{2}',
+    localName = new RegExp(`^(?:(?:[${localNameStart}]|${percent})` +
+                           `(?:(?:[${localNameChar}.]|${percent})*(?:[${localNameChar}]|${percent}))?)?$`);
+
 // ## Placeholder class to represent already pretty-printed terms
 class SerializedTerm extends Term {
   // Pretty-printed nodes are not equal to any other node
@@ -173,7 +184,7 @@ export default 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))
+      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 Term)
@@ -190,8 +201,13 @@ export default class N3Writer {
       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 || this._createPrefixRegex()).exec(iri) : null;
-    return !prefixMatch ? `<${iri}>` :
-           (!prefixMatch[1] ? iri : this._prefixIRIs[prefixMatch[1]] + prefixMatch[2]);
+    if (!prefixMatch)
+      return `<${iri}>`;
+    // An IRI that starts with a registered prefix IRI
+    if (prefixMatch[1])
+      return this._prefixIRIs[prefixMatch[1]] + prefixMatch[2];
+    // An IRI that already looks like a prefixed name, if the rest is a valid local name
+    return localName.test(iri.slice(prefixMatch[0].length)) ? iri : `<${iri}>`;
   }
 
   // ### `_encodeLiteral` represents a literal
@@ -351,8 +367,8 @@ export default class N3Writer {
       IRIlist += IRIlist ? `|${IRIpattern}` : IRIpattern;
       prefixList += prefixList ? `|${prefixPattern}` : prefixPattern;
     }
-    return this._prefixRegex = new RegExp(`^(?:${prefixList})[^/]*$|` +
-                                          `^(${IRIlist})([_a-zA-Z0-9](?:\\.?[\\-_a-zA-Z0-9])*)$`);
+    return this._prefixRegex = new RegExp(`^(${IRIlist})([_a-zA-Z0-9](?:\\.?[\\-_a-zA-Z0-9])*)$|` +
+                                          `^(?:${prefixList})`);
   }
 
   // ### `blank` creates a blank node with the given content