n3 2.13.4 → 2.13.5

package/lib/N3Lexer.js

@@ -15,7 +15,33 @@ const SPACE = 0x20,
   TAB = 0x09,
   LF = 0x0A,
   CR = 0x0D,
-  HASH = 0x23;
+  HASH = 0x23,
+  DOT = 0x2E,
+  COLON = 0x3A,
+  ZERO = 0x30,
+  NINE = 0x39,
+  PERCENT = 0x25,
+  BACKSLASH = 0x5C;
+
+// Whitespace as matched by `\s`
+function isWhitespace(charCode) {
+  return charCode === SPACE || charCode >= TAB && charCode <= CR || charCode >= 0xA0 && (charCode === 0xA0 || charCode === 0x1680 || charCode >= 0x2000 && charCode <= 0x200A || charCode === 0x2028 || charCode === 0x2029 || charCode === 0x202F || charCode === 0x205F || charCode === 0x3000 || charCode === 0xFEFF);
+}
+// Characters that can directly follow a name: whitespace and punctuation
+// (the lookahead `[,;!\^\s#()\[\]\{\}"'<>]` of the former regular expressions)
+const asciiDelimiters = new Uint8Array(0x80);
+for (const char of ',;!^#()[]{}"\'<> \t\n\v\f\r') asciiDelimiters[char.charCodeAt(0)] = 1;
+function isDelimiter(charCode) {
+  return charCode < 0x80 ? asciiDelimiters[charCode] === 1 : isWhitespace(charCode);
+}
+// Whether a name can end before the given position: it must be followed by
+// a delimiter, optionally after a dot. At the end of finished input, it can always end.
+function canEndName(input, pos, inputFinished) {
+  let charCode = input.charCodeAt(pos);
+  if (charCode === DOT) charCode = input.charCodeAt(++pos);
+  if (pos >= input.length) return inputFinished;
+  return isDelimiter(charCode);
+}
 
 // Fixed escape sequences allowed in string literals (ECHAR)
 const stringEscapeReplacements = {
@@ -52,9 +78,87 @@ const localNameEscapeReplacements = {
   '%': '%'
 };
 const illegalIriChars = /[\x00-\x20<>\\"\{\}\|\^\`]/;
-// Characters that cannot occur in a prefixed name, not even escaped
-// (global, so that testAt searches the rest of the input from a position)
-const nonPrefixedNameChar = /[\s<>"{}|^`]/g;
+
+// Character classes of names, as bit flags for ASCII characters
+const PREFIX_START = 1,
+  // PN_CHARS_BASE
+  LOCAL_START = 2,
+  // PN_CHARS_U, digits, and colon
+  NAME_CHAR = 4,
+  // PN_CHARS
+  LOCAL_CHAR = 8,
+  // PN_CHARS and colon
+  LOCAL_ESCAPE = 16; // characters that can be escaped in local names (PN_LOCAL_ESC)
+const asciiNameClasses = new Uint8Array(0x80);
+for (let charCode = 0; charCode < 0x80; charCode++) {
+  const char = String.fromCharCode(charCode);
+  const letter = char >= 'A' && char <= 'Z' || char >= 'a' && char <= 'z';
+  const nameChar = letter || char === '_' || char === '-' || char >= '0' && char <= '9';
+  asciiNameClasses[charCode] = (letter ? PREFIX_START : 0) | (nameChar && char !== '-' || char === ':' ? LOCAL_START : 0) | (nameChar ? NAME_CHAR : 0) | (nameChar || char === ':' ? LOCAL_CHAR : 0) | (char in localNameEscapeReplacements ? LOCAL_ESCAPE : 0);
+}
+// Returns the length (0, 1, or 2 code units) of the character at the given position
+// if it is in the given name character class
+function nameCharLength(input, pos, charClass) {
+  const charCode = input.charCodeAt(pos);
+  if (charCode < 0x80) return (asciiNameClasses[charCode] & charClass) !== 0 ? 1 : 0;
+  // Characters from U+10000 to U+EFFFF consist of a surrogate pair
+  if (charCode >= 0xD800 && charCode <= 0xDB7F) {
+    const low = input.charCodeAt(pos + 1);
+    return low >= 0xDC00 && low <= 0xDFFF ? 2 : 0;
+  }
+  // PN_CHARS has some characters that PN_CHARS_BASE does not
+  if (charClass >= NAME_CHAR && (charCode === 0xB7 || charCode >= 0x300 && charCode <= 0x36F || charCode === 0x203F || charCode === 0x2040)) return 1;
+  // PN_CHARS_BASE
+  return charCode >= 0xC0 && charCode <= 0x1FFF && charCode !== 0xD7 && charCode !== 0xF7 && (charCode < 0x300 || charCode >= 0x370 && charCode !== 0x37E) || charCode >= 0x200C && charCode <= 0x200D || charCode >= 0x2070 && charCode <= 0x218F || charCode >= 0x2C00 && charCode <= 0x2FEF || charCode >= 0x3001 && charCode <= 0xD7FF || charCode >= 0xF900 && charCode <= 0xFDCF || charCode >= 0xFDF0 && charCode <= 0xFFFD ? 1 : 0;
+}
+function isLocalEscape(charCode) {
+  return charCode < 0x80 && (asciiNameClasses[charCode] & LOCAL_ESCAPE) !== 0;
+}
+function isHexDigit(charCode) {
+  return charCode >= ZERO && charCode <= NINE || charCode >= 0x41 && charCode <= 0x46 || charCode >= 0x61 && charCode <= 0x66;
+}
+// Returns the end of the prefix (PN_PREFIX) at the given position,
+// which can contain single dots, but not start or end with one
+function skipPrefix(input, pos) {
+  let length = nameCharLength(input, pos, PREFIX_START);
+  while (length !== 0) {
+    pos += length;
+    const next = input.charCodeAt(pos) === DOT ? pos + 1 : pos;
+    // Most names are ASCII, so look those up without a call
+    const charCode = input.charCodeAt(next);
+    length = charCode < 0x80 ? (asciiNameClasses[charCode] & NAME_CHAR) !== 0 ? 1 : 0 : nameCharLength(input, next, NAME_CHAR);
+    if (length !== 0) pos = next;
+  }
+  return pos;
+}
+// Returns the end of the local name (PN_LOCAL) at the given position,
+// which can contain dots, but not start or end with one
+function skipLocalName(input, pos) {
+  let end = pos,
+    charClass = LOCAL_START;
+  while (true) {
+    // Most names are ASCII, so look those up without a call
+    const charCode = input.charCodeAt(pos);
+    let length = charCode < 0x80 ? (asciiNameClasses[charCode] & charClass) !== 0 ? 1 : 0 : nameCharLength(input, pos, charClass);
+    // Percent-encoded character (PERCENT)
+    if (length === 0 && charCode === PERCENT && isHexDigit(input.charCodeAt(pos + 1)) && isHexDigit(input.charCodeAt(pos + 2))) length = 3;
+    // Escaped character (PN_LOCAL_ESC)
+    else if (length === 0 && charCode === BACKSLASH && isLocalEscape(input.charCodeAt(pos + 1))) length = 2;
+    if (length !== 0) {
+      end = pos += length;
+      charClass = LOCAL_CHAR;
+    }
+    // Dots are allowed after the first character, but not at the end
+    else if (charCode === DOT && charClass === LOCAL_CHAR) pos++;else return end;
+  }
+}
+// Returns the end of the prefixed name at the given position, or -1 if there is none
+function skipPrefixedName(input, pos, inputFinished) {
+  const colon = skipPrefix(input, pos);
+  if (input.charCodeAt(colon) !== COLON) return -1;
+  const end = skipLocalName(input, colon + 1);
+  return canEndName(input, end, inputFinished) ? end : -1;
+}
 
 // A valid code point is a Unicode scalar value: at most U+10FFFF and not a surrogate
 function isValidCodePoint(charCode) {
@@ -110,8 +214,6 @@ class N3Lexer {
     this._simpleQuotedString = /"([^"\\\r\n]*)"(?=[^"])/y; // string without escape sequences
     this._simpleApostropheString = /'([^'\\\r\n]*)'(?=[^'])/y;
     this._langcode = /@([a-z]+(?:-[a-z0-9]+)*)(?=[^a-z0-9])/iy;
-    this._prefix = /((?:[A-Za-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])*)?:(?=[#\s<])/y;
-    this._prefixed = /((?:[A-Za-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])*)?:((?:(?:[0-9:A-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-fA-F]{2}|\\[!#-\/;=?\-@_~])(?:(?:[\.\-0-9:A-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]|%[0-9a-fA-F]{2}|\\[!#-\/;=?\-@_~])*(?:[\-0-9:A-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]|%[0-9a-fA-F]{2}|\\[!#-\/;=?\-@_~]))?)?)(?:[ \t]+|(?=\.?[,;!\^\s#()\[\]\{\}"'<>]))/y;
     this._variable = /\?(?:(?:[A-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-9:A-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])*)(?=[.,;!\^\s#()\[\]\{\}"'<>])/y;
     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;
@@ -476,17 +578,22 @@ class N3Lexer {
       // Some first characters do not allow an immediate decision, so inspect more
       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] || '';
+        let end;
+        if ((this._previousMarker === '@prefix' || this._previousMarker === 'PREFIX') && input.charCodeAt(end = skipPrefix(input, pos)) === COLON && end + 1 < input.length && (input[end + 1] === '#' || input[end + 1] === '<' || isWhitespace(input.charCodeAt(end + 1)))) {
+          type = 'prefix', value = input.slice(pos, end);
+          matchLength = end + 1 - pos;
+        }
         // 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.
-        else if ((match = execAt(this._prefixed, input, pos)) || inputFinished && (match = execAtEnd(this._prefixed, input, pos))) {
-          type = 'prefixed', prefix = match[1] || '';
-          value = this._unescape(match[2], localNameEscapeReplacements);
-          lexicalLength = prefix.length + match[2].length + 1;
+        // we always need a non-dot character before deciding it is a prefixed name,
+        // except at the end of the input.
+        else if (!this._lineMode && (end = skipPrefixedName(input, pos, inputFinished)) >= 0) {
+          const colon = input.indexOf(':', pos);
+          type = 'prefixed', prefix = input.slice(pos, colon);
+          value = this._unescape(input.slice(colon + 1, end), localNameEscapeReplacements);
+          matchLength = end - pos;
         }
       }
 
@@ -595,25 +702,17 @@ class N3Lexer {
     if (!verb) return null;
 
     // Most verb boundaries cannot be part of a prefix, so keep the common path fast.
+    // U+1680 and U+FEFF are whitespace to the regular expression but name characters.
     const next = input[pos + verb[0].length];
-    if (next !== '-' && next !== '_' && (next < '0' || next > '9')) return verb;
+    if (next !== '-' && next !== '_' && (next < '0' || next > '9') && next !== '\u1680' && next !== '\ufeff') return verb;
 
     // A prefix can start with a verb and continue with characters that are also
     // valid verb boundaries. Prefer the longer prefixed name when it is complete.
-    if (execAt(this._prefixed, input, pos)) return null;
-    // Appending to the input only matters when a prefixed name could run up to
-    // its end, which a character that cannot occur in prefixed names rules out.
-    // This avoids copying the rest of the document for every such verb.
-    if (testAt(nonPrefixedNameChar, input, pos)) return verb;
-    if (execAtEnd(this._prefixed, input, pos)) return null;
-
-    // If a stream chunk ends partway through such a prefix, wait for the colon
-    // instead of prematurely emitting the verb. Appending ": " lets the prefix
-    // grammar determine whether all input seen so far can be a complete prefix.
-    if (!inputFinished) {
-      const prefix = execAt(this._prefix, `${input.slice(pos)}: `, 0);
-      if (prefix) return null;
-    }
+    if (skipPrefixedName(input, pos, true) >= 0) return null;
+
+    // If a stream chunk ends partway through such a prefix,
+    // wait for the colon instead of prematurely emitting the verb.
+    if (!inputFinished && skipPrefix(input, pos) === input.length) return null;
     return verb;
   }
 

package/lib/N3Reasoner.js

@@ -44,6 +44,7 @@ class N3Reasoner {
       if (!store._addToIndex(graphItem.subjects, subject, predicate, object)) return;
       store._addToIndex(graphItem.predicates, predicate, object, subject);
       store._addToIndex(graphItem.objects, object, subject, predicate);
+      this._indexed++;
     }
     // Count genuinely new derivations and fail past the budget. The check comes
     // after all three indexes are updated, so a caught error leaves the store
@@ -176,7 +177,7 @@ class N3Reasoner {
     };
   }
   reason(rules) {
-    this._derivations = 0;
+    this._derivations = this._indexed = 0;
     if (!Array.isArray(rules)) {
       rules = getRulesFromDataset(rules);
     }
@@ -236,9 +237,9 @@ class N3Reasoner {
         this._reasonGraphNaive(rules, graphs[graphId]);
       }
     } finally {
-      // Invalidate the cached size even if a derivation budget was exceeded,
-      // so a caught budget error leaves the store fully consistent.
-      this._store._size = null;
+      // Count the quads added directly to the indexes, even if a derivation
+      // budget was exceeded, so a caught budget error leaves the store consistent
+      if (this._store._size !== null) this._store._size += this._indexed;
     }
   }
 }

package/lib/N3Store.js

@@ -31,11 +31,15 @@ function hasInIndex(index0, key0, key1, key2) {
   const index2 = index1 && index1[key1];
   return !!index2 && key2 in index2;
 }
+
+// The number of index leaves that the last `merge` call added
+let mergedLeaves = 0;
 function merge(target, source, depth = 4) {
   let size = target[SIZE] || 0;
   for (const key in source) {
     if (!(key in target)) {
       size++;
+      if (depth === 0) mergedLeaves++;
       target[key] = depth === 0 ? null : merge(Object.create(null), source[key], depth - 1);
     }
     // Merge into the existing object in place,
@@ -216,8 +220,14 @@ class N3EntityIndex {
   }
 }
 
-// ## Constructor
+// Returns the size of a store from this copy of N3 if it is known without counting,
+// or null otherwise
 exports.N3EntityIndex = N3EntityIndex;
+function knownSize(dataset) {
+  return dataset instanceof N3Store ? dataset._size : null;
+}
+
+// ## Constructor
 class N3Store {
   constructor(quads, options) {
     // The number of quads is initially zero
@@ -248,16 +258,10 @@ class N3Store {
 
   // ### `size` returns the number of quads in the store
   get size() {
-    // Return the quad count if if was cached
-    let size = this._size;
-    if (size !== null) return size;
-
-    // Calculate the number of quads by counting to the deepest level
-    size = 0;
-    const graphs = this._graphs;
-    let subjects, subject;
-    for (const graphKey in graphs) for (const subjectKey in subjects = graphs[graphKey].subjects) for (const predicateKey in subject = subjects[subjectKey]) size += subject[predicateKey][SIZE];
-    return this._size = size;
+    // The quad count is kept up to date by every change,
+    // except by reasoners from earlier versions of N3, which set it to null
+    if (this._size === null) this._size = this.countQuads();
+    return this._size;
   }
 
   // ## Private methods
@@ -534,9 +538,7 @@ class N3Store {
     if (!this._addToIndex(graphItem.subjects, subject, predicate, object)) return false;
     this._addToIndex(graphItem.predicates, predicate, object, subject);
     this._addToIndex(graphItem.objects, object, subject, predicate);
-
-    // The cached quad count is now invalid
-    this._size = null;
+    if (this._size !== null) this._size++;
     return true;
   }
 
@@ -734,9 +736,12 @@ class N3Store {
         } else if (predicate) {
           // If only predicate and possibly object are given, the predicate index will be the fastest
           count += this._countInIndex(content.predicates, predicateId, objectId, subjectId);
-        } else {
-          // If only object is possibly given, the object index will be the fastest
+        } else if (object) {
+          // If only object is given, the object index will be the fastest
           count += this._countInIndex(content.objects, objectId, subjectId, predicateId);
+        } else {
+          // Without a pattern, the subject index sums the fewest leaf counts
+          count += this._countInIndex(content.subjects);
         }
       }
     }
@@ -1022,9 +1027,11 @@ class N3Store {
     if (Array.isArray(quads)) this.addQuads(quads);
     // Index merging bypasses observer notifications
     else if (this._observers === null && quads instanceof N3Store && quads._entityIndex === this._entityIndex) {
-      if (quads._size !== 0) {
+      if (quads.size !== 0) {
+        // Each new quad adds one leaf to each of the three indexes
+        mergedLeaves = 0;
         this._graphs = merge(this._graphs, quads._graphs);
-        this._size = null; // Invalidate the cached size
+        if (this._size !== null) this._size += mergedLeaves / 3;
       }
     } else {
       for (const quad of quads) this.add(quad);
@@ -1041,18 +1048,27 @@ class N3Store {
   contains(other) {
     if (other instanceof DatasetCoreAndReadableStream) other = other.filtered;
     if (other === this) return true;
-    if (!(other instanceof N3Store) || this._entityIndex !== other._entityIndex) return other.every(quad => this.has(quad));
+    if (!(other instanceof N3Store) || this._entityIndex !== other._entityIndex) {
+      // A larger set cannot be a subset, but only compare sizes that are known without counting
+      const otherSize = knownSize(other),
+        thisSize = this._size;
+      if (otherSize !== null && thisSize !== null && otherSize > thisSize) return false;
+      return other.every(quad => this.has(quad));
+    }
+
+    // At every level, the index of the subset cannot have more entries
     const g1 = this._graphs,
       g2 = other._graphs;
-    let s1, s2, p1, p2, o1;
+    let s1, s2, p1, p2, o1, o2;
     for (const graph in g2) {
       if (!(s1 = g1[graph])) return false;
       s1 = s1.subjects;
-      for (const subject in s2 = g2[graph].subjects) {
-        if (!(p1 = s1[subject])) return false;
-        for (const predicate in p2 = s2[subject]) {
-          if (!(o1 = p1[predicate])) return false;
-          for (const object in p2[predicate]) if (!(object in o1)) return false;
+      if ((s2 = g2[graph].subjects)[SIZE] > s1[SIZE]) return false;
+      for (const subject in s2) {
+        if (!(p1 = s1[subject]) || (p2 = s2[subject])[SIZE] > p1[SIZE]) return false;
+        for (const predicate in p2) {
+          if (!(o1 = p1[predicate]) || (o2 = p2[predicate])[SIZE] > o1[SIZE]) return false;
+          for (const object in o2) if (!(object in o1)) return false;
         }
       }
     }
@@ -1132,7 +1148,7 @@ class N3Store {
         entityIndex: this._entityIndex
       });
       store._graphs = merge(Object.create(null), this._graphs);
-      store._size = this._size;
+      store._size = this.size;
       return store;
     } else if (other instanceof N3Store && this._entityIndex === other._entityIndex) {
       const store = new N3Store({
@@ -1145,6 +1161,21 @@ class N3Store {
       }
       return store;
     }
+
+    // Test the quads of the smaller dataset against the larger one
+    // when both sizes are known without counting
+    const otherSize = knownSize(other),
+      thisSize = this._size;
+    if (otherSize !== null && thisSize !== null && otherSize < thisSize && typeof other[Symbol.iterator] === 'function' &&
+    // unless it is a store whose custom factories may not create RDF/JS quads,
+    // either for its quads or, through its entity index, for their terms
+    other._factory === _N3DataFactory.default && other._entityIndex._factory === _N3DataFactory.default) {
+      const store = new N3Store({
+        entityIndex: this._entityIndex
+      });
+      for (const quad of other) if (this.has(quad)) store.add(quad);
+      return store;
+    }
     return this.filter(quad => other.has(quad));
   }
 
@@ -1220,7 +1251,7 @@ class N3Store {
       entityIndex: this._entityIndex
     });
     store._graphs = merge(Object.create(null), this._graphs);
-    store._size = this._size;
+    store._size = this.size;
     store.addAll(quads);
     return store;
   }

package/package.json

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

package/src/N3Lexer.js

@@ -2,7 +2,35 @@
 import namespaces from './IRIs';
 
 const { xsd } = namespaces;
-const SPACE = 0x20, TAB = 0x09, LF = 0x0A, CR = 0x0D, HASH = 0x23;
+const SPACE = 0x20, TAB = 0x09, LF = 0x0A, CR = 0x0D, HASH = 0x23,
+    DOT = 0x2E, COLON = 0x3A, ZERO = 0x30, NINE = 0x39,
+    PERCENT = 0x25, BACKSLASH = 0x5C;
+
+// Whitespace as matched by `\s`
+function isWhitespace(charCode) {
+  return charCode === SPACE || charCode >= TAB && charCode <= CR ||
+    charCode >= 0xA0 && (charCode === 0xA0 || charCode === 0x1680 ||
+      charCode >= 0x2000 && charCode <= 0x200A || charCode === 0x2028 || charCode === 0x2029 ||
+      charCode === 0x202F || charCode === 0x205F || charCode === 0x3000 || charCode === 0xFEFF);
+}
+// Characters that can directly follow a name: whitespace and punctuation
+// (the lookahead `[,;!\^\s#()\[\]\{\}"'<>]` of the former regular expressions)
+const asciiDelimiters = new Uint8Array(0x80);
+for (const char of ',;!^#()[]{}"\'<> \t\n\v\f\r')
+  asciiDelimiters[char.charCodeAt(0)] = 1;
+function isDelimiter(charCode) {
+  return charCode < 0x80 ? asciiDelimiters[charCode] === 1 : isWhitespace(charCode);
+}
+// Whether a name can end before the given position: it must be followed by
+// a delimiter, optionally after a dot. At the end of finished input, it can always end.
+function canEndName(input, pos, inputFinished) {
+  let charCode = input.charCodeAt(pos);
+  if (charCode === DOT)
+    charCode = input.charCodeAt(++pos);
+  if (pos >= input.length)
+    return inputFinished;
+  return isDelimiter(charCode);
+}
 
 // Fixed escape sequences allowed in string literals (ECHAR)
 const stringEscapeReplacements = {
@@ -16,9 +44,105 @@ const localNameEscapeReplacements = {
   '=': '=', '/': '/', '?': '?', '#': '#', '@': '@', '%': '%',
 };
 const illegalIriChars = /[\x00-\x20<>\\"\{\}\|\^\`]/;
-// Characters that cannot occur in a prefixed name, not even escaped
-// (global, so that testAt searches the rest of the input from a position)
-const nonPrefixedNameChar = /[\s<>"{}|^`]/g;
+
+// Character classes of names, as bit flags for ASCII characters
+const PREFIX_START = 1, // PN_CHARS_BASE
+    LOCAL_START = 2,      // PN_CHARS_U, digits, and colon
+    NAME_CHAR = 4,        // PN_CHARS
+    LOCAL_CHAR = 8,       // PN_CHARS and colon
+    LOCAL_ESCAPE = 16;    // characters that can be escaped in local names (PN_LOCAL_ESC)
+const asciiNameClasses = new Uint8Array(0x80);
+for (let charCode = 0; charCode < 0x80; charCode++) {
+  const char = String.fromCharCode(charCode);
+  const letter = char >= 'A' && char <= 'Z' || char >= 'a' && char <= 'z';
+  const nameChar = letter || char === '_' || char === '-' || char >= '0' && char <= '9';
+  asciiNameClasses[charCode] =
+    (letter ? PREFIX_START : 0) |
+    (nameChar && char !== '-' || char === ':' ? LOCAL_START : 0) |
+    (nameChar ? NAME_CHAR : 0) |
+    (nameChar || char === ':' ? LOCAL_CHAR : 0) |
+    (char in localNameEscapeReplacements ? LOCAL_ESCAPE : 0);
+}
+// Returns the length (0, 1, or 2 code units) of the character at the given position
+// if it is in the given name character class
+function nameCharLength(input, pos, charClass) {
+  const charCode = input.charCodeAt(pos);
+  if (charCode < 0x80)
+    return (asciiNameClasses[charCode] & charClass) !== 0 ? 1 : 0;
+  // Characters from U+10000 to U+EFFFF consist of a surrogate pair
+  if (charCode >= 0xD800 && charCode <= 0xDB7F) {
+    const low = input.charCodeAt(pos + 1);
+    return low >= 0xDC00 && low <= 0xDFFF ? 2 : 0;
+  }
+  // PN_CHARS has some characters that PN_CHARS_BASE does not
+  if (charClass >= NAME_CHAR && (charCode === 0xB7 || charCode >= 0x300 && charCode <= 0x36F ||
+                                 charCode === 0x203F || charCode === 0x2040))
+    return 1;
+  // PN_CHARS_BASE
+  return charCode >= 0xC0 && charCode <= 0x1FFF && charCode !== 0xD7 && charCode !== 0xF7 &&
+           (charCode < 0x300 || charCode >= 0x370 && charCode !== 0x37E) ||
+         charCode >= 0x200C && charCode <= 0x200D || charCode >= 0x2070 && charCode <= 0x218F ||
+         charCode >= 0x2C00 && charCode <= 0x2FEF || charCode >= 0x3001 && charCode <= 0xD7FF ||
+         charCode >= 0xF900 && charCode <= 0xFDCF || charCode >= 0xFDF0 && charCode <= 0xFFFD ? 1 : 0;
+}
+function isLocalEscape(charCode) {
+  return charCode < 0x80 && (asciiNameClasses[charCode] & LOCAL_ESCAPE) !== 0;
+}
+function isHexDigit(charCode) {
+  return charCode >= ZERO && charCode <= NINE ||
+    charCode >= 0x41 && charCode <= 0x46 || charCode >= 0x61 && charCode <= 0x66;
+}
+// Returns the end of the prefix (PN_PREFIX) at the given position,
+// which can contain single dots, but not start or end with one
+function skipPrefix(input, pos) {
+  let length = nameCharLength(input, pos, PREFIX_START);
+  while (length !== 0) {
+    pos += length;
+    const next = input.charCodeAt(pos) === DOT ? pos + 1 : pos;
+    // Most names are ASCII, so look those up without a call
+    const charCode = input.charCodeAt(next);
+    length = charCode < 0x80 ? (asciiNameClasses[charCode] & NAME_CHAR) !== 0 ? 1 : 0 :
+      nameCharLength(input, next, NAME_CHAR);
+    if (length !== 0)
+      pos = next;
+  }
+  return pos;
+}
+// Returns the end of the local name (PN_LOCAL) at the given position,
+// which can contain dots, but not start or end with one
+function skipLocalName(input, pos) {
+  let end = pos, charClass = LOCAL_START;
+  while (true) {
+    // Most names are ASCII, so look those up without a call
+    const charCode = input.charCodeAt(pos);
+    let length = charCode < 0x80 ? (asciiNameClasses[charCode] & charClass) !== 0 ? 1 : 0 :
+      nameCharLength(input, pos, charClass);
+    // Percent-encoded character (PERCENT)
+    if (length === 0 && charCode === PERCENT &&
+        isHexDigit(input.charCodeAt(pos + 1)) && isHexDigit(input.charCodeAt(pos + 2)))
+      length = 3;
+    // Escaped character (PN_LOCAL_ESC)
+    else if (length === 0 && charCode === BACKSLASH && isLocalEscape(input.charCodeAt(pos + 1)))
+      length = 2;
+    if (length !== 0) {
+      end = pos += length;
+      charClass = LOCAL_CHAR;
+    }
+    // Dots are allowed after the first character, but not at the end
+    else if (charCode === DOT && charClass === LOCAL_CHAR)
+      pos++;
+    else
+      return end;
+  }
+}
+// Returns the end of the prefixed name at the given position, or -1 if there is none
+function skipPrefixedName(input, pos, inputFinished) {
+  const colon = skipPrefix(input, pos);
+  if (input.charCodeAt(colon) !== COLON)
+    return -1;
+  const end = skipLocalName(input, colon + 1);
+  return canEndName(input, end, inputFinished) ? end : -1;
+}
 
 // A valid code point is a Unicode scalar value: at most U+10FFFF and not a surrogate
 function isValidCodePoint(charCode) {
@@ -75,8 +199,6 @@ export default class N3Lexer {
     this._simpleQuotedString = /"([^"\\\r\n]*)"(?=[^"])/y; // string without escape sequences
     this._simpleApostropheString = /'([^'\\\r\n]*)'(?=[^'])/y;
     this._langcode = /@([a-z]+(?:-[a-z0-9]+)*)(?=[^a-z0-9])/iy;
-    this._prefix = /((?:[A-Za-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])*)?:(?=[#\s<])/y;
-    this._prefixed = /((?:[A-Za-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])*)?:((?:(?:[0-9:A-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-fA-F]{2}|\\[!#-\/;=?\-@_~])(?:(?:[\.\-0-9:A-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]|%[0-9a-fA-F]{2}|\\[!#-\/;=?\-@_~])*(?:[\-0-9:A-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]|%[0-9a-fA-F]{2}|\\[!#-\/;=?\-@_~]))?)?)(?:[ \t]+|(?=\.?[,;!\^\s#()\[\]\{\}"'<>]))/y;
     this._variable = /\?(?:(?:[A-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-9:A-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])*)(?=[.,;!\^\s#()\[\]\{\}"'<>])/y;
     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;
@@ -501,9 +623,14 @@ export default class N3Lexer {
       // Some first characters do not allow an immediate decision, so inspect more
       if (inconclusive) {
         // Try to find a prefix
+        let end;
         if ((this._previousMarker === '@prefix' || this._previousMarker === 'PREFIX') &&
-            (match = execAt(this._prefix, input, pos)))
-          type = 'prefix', value = match[1] || '';
+            input.charCodeAt(end = skipPrefix(input, pos)) === COLON &&
+            end + 1 < input.length && (input[end + 1] === '#' || input[end + 1] === '<' ||
+                                       isWhitespace(input.charCodeAt(end + 1)))) {
+          type = 'prefix', value = input.slice(pos, end);
+          matchLength = end + 1 - pos;
+        }
         // 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) &&
@@ -512,13 +639,13 @@ export default class N3Lexer {
                  (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.
-        else if ((match = execAt(this._prefixed, input, pos)) ||
-                 inputFinished && (match = execAtEnd(this._prefixed, input, pos))) {
-          type = 'prefixed', prefix = match[1] || '';
-          value = this._unescape(match[2], localNameEscapeReplacements);
-          lexicalLength = prefix.length + match[2].length + 1;
+        // we always need a non-dot character before deciding it is a prefixed name,
+        // except at the end of the input.
+        else if (!this._lineMode && (end = skipPrefixedName(input, pos, inputFinished)) >= 0) {
+          const colon = input.indexOf(':', pos);
+          type = 'prefixed', prefix = input.slice(pos, colon);
+          value = this._unescape(input.slice(colon + 1, end), localNameEscapeReplacements);
+          matchLength = end - pos;
         }
       }
 
@@ -605,30 +732,21 @@ export default class N3Lexer {
       return null;
 
     // Most verb boundaries cannot be part of a prefix, so keep the common path fast.
+    // U+1680 and U+FEFF are whitespace to the regular expression but name characters.
     const next = input[pos + verb[0].length];
-    if (next !== '-' && next !== '_' && (next < '0' || next > '9'))
+    if (next !== '-' && next !== '_' && (next < '0' || next > '9') &&
+        next !== '\u1680' && next !== '\ufeff')
       return verb;
 
     // A prefix can start with a verb and continue with characters that are also
     // valid verb boundaries. Prefer the longer prefixed name when it is complete.
-    if (execAt(this._prefixed, input, pos))
-      return null;
-    // Appending to the input only matters when a prefixed name could run up to
-    // its end, which a character that cannot occur in prefixed names rules out.
-    // This avoids copying the rest of the document for every such verb.
-    if (testAt(nonPrefixedNameChar, input, pos))
-      return verb;
-    if (execAtEnd(this._prefixed, input, pos))
+    if (skipPrefixedName(input, pos, true) >= 0)
       return null;
 
-    // If a stream chunk ends partway through such a prefix, wait for the colon
-    // instead of prematurely emitting the verb. Appending ": " lets the prefix
-    // grammar determine whether all input seen so far can be a complete prefix.
-    if (!inputFinished) {
-      const prefix = execAt(this._prefix, `${input.slice(pos)}: `, 0);
-      if (prefix)
-        return null;
-    }
+    // If a stream chunk ends partway through such a prefix,
+    // wait for the colon instead of prematurely emitting the verb.
+    if (!inputFinished && skipPrefix(input, pos) === input.length)
+      return null;
     return verb;
   }