n3 2.8.0 → 2.9.1

package/lib/N3Lexer.js

@@ -18,8 +18,6 @@ const SPACE = 0x20,
   CR = 0x0D,
   HASH = 0x23;
 
-// Regular expression and replacement strings to unescape N3 strings
-const escapeSequence = /\\u([a-fA-F0-9]{4})|\\U([a-fA-F0-9]{8})|\\([^])/g;
 // Fixed escape sequences allowed in string literals (ECHAR)
 const stringEscapeReplacements = {
   '\\': '\\',
@@ -549,34 +547,42 @@ class N3Lexer {
   // ### `_unescape` replaces N3 escape codes by their corresponding characters,
   // allowing only the fixed escape sequences from the given replacement table
   _unescape(item, replacements) {
-    if (item.indexOf('\\') < 0) return item;
-    let invalid = false;
-    const replaced = item.replace(escapeSequence, (sequence, unicode4, unicode8, escapedChar) => {
-      // 4-digit unicode character
-      if (typeof unicode4 === 'string') {
-        const charCode = Number.parseInt(unicode4, 16);
-        if (!isValidCodePoint(charCode)) {
-          invalid = true;
-          return '';
+    let backslash = item.indexOf('\\');
+    if (backslash < 0) return item;
+    let result = '',
+      start = 0;
+    // A trailing lone backslash is not an escape sequence.
+    while (backslash >= 0 && backslash + 1 < item.length) {
+      const escapedChar = item[backslash + 1];
+      let end = backslash + 2,
+        replacement;
+      if (escapedChar === 'u' || escapedChar === 'U') {
+        end += escapedChar === 'u' ? 4 : 8;
+        if (end > item.length) return null;
+        let charCode = 0;
+        for (let i = backslash + 2; i < end; i++) {
+          let digit = item.charCodeAt(i);
+          if (digit >= 0x30 && digit <= 0x39)
+            // 0–9
+            digit -= 0x30;else if (digit >= 0x41 && digit <= 0x46)
+            // A–F
+            digit -= 0x41 - 10;else if (digit >= 0x61 && digit <= 0x66)
+            // a–f
+            digit -= 0x61 - 10;else return null;
+          // Eight digits can exceed a signed 32-bit integer; avoid bitwise shifts.
+          charCode = charCode * 16 + digit;
         }
-        return String.fromCharCode(charCode);
+        if (!isValidCodePoint(charCode)) return null;
+        replacement = String.fromCodePoint(charCode);
+      } else {
+        if (!(escapedChar in replacements)) return null;
+        replacement = replacements[escapedChar];
       }
-      // 8-digit unicode character
-      if (typeof unicode8 === 'string') {
-        let charCode = Number.parseInt(unicode8, 16);
-        if (!isValidCodePoint(charCode)) {
-          invalid = true;
-          return '';
-        }
-        return charCode <= 0xFFFF ? String.fromCharCode(Number.parseInt(unicode8, 16)) : String.fromCharCode(0xD800 + ((charCode -= 0x10000) >> 10), 0xDC00 + (charCode & 0x3FF));
-      }
-      // fixed escape sequence
-      if (escapedChar in replacements) return replacements[escapedChar];
-      // invalid escape sequence
-      invalid = true;
-      return '';
-    });
-    return invalid ? null : replaced;
+      result += item.slice(start, backslash) + replacement;
+      start = end;
+      backslash = item.indexOf('\\', start);
+    }
+    return result + item.slice(start);
   }
 
   // ### `_parseLiteral` parses a literal into an unescaped value

package/lib/N3Parser.js

@@ -1446,14 +1446,16 @@ class N3Parser {
 
   // ### `parse` parses the N3 input and emits each parsed quad through the onQuad callback.
   parse(input, quadCallback, prefixCallback, versionCallback) {
-    // The second parameter accepts an object { onQuad: ..., onPrefix: ..., onComment: ...}
+    // 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;
-    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion)) {
+    let onQuad, onPrefix, onComment, onVersion, onToken, onTokenEnd;
+    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion || quadCallback.onToken || quadCallback.onTokenEnd)) {
       onQuad = quadCallback.onQuad;
       onPrefix = quadCallback.onPrefix;
       onComment = quadCallback.onComment;
       onVersion = quadCallback.onVersion;
+      onToken = quadCallback.onToken;
+      onTokenEnd = quadCallback.onTokenEnd;
     } else {
       onQuad = quadCallback;
       onPrefix = prefixCallback;
@@ -1473,36 +1475,55 @@ class N3Parser {
     this._expectOf = false;
     this._quantified = Object.create(null);
     this._emptyFormula = false;
+    let readToken = token => {
+      return this._readCallback = this._readCallback(token);
+    };
+
+    // Comments bypass the grammar, but participate in the token lifecycle.
+    if (onComment || this._lexer.comments) {
+      this._lexer.comments = true;
+      const readGrammarToken = readToken;
+      readToken = token => {
+        if (token.type !== 'comment') return readGrammarToken(token);
+        if (onComment) onComment(token.value);
+        return this._readCallback;
+      };
+    }
+
+    // Install observers once per parse, leaving the ordinary token path intact.
+    if (onToken || onTokenEnd) {
+      const consumeToken = readToken;
+      readToken = token => {
+        try {
+          try {
+            if (onToken) onToken(token);
+            return consumeToken(token);
+          } finally {
+            if (onTokenEnd) onTokenEnd(token);
+          }
+        } catch (error) {
+          // A consumer exception aborts this parse, including later chunks.
+          this._readCallback = null;
+          throw error;
+        }
+      };
+    }
 
-    // Parse synchronously if no quad callback is given
+    // Parse synchronously if no quad callback is given.
     if (!onQuad) {
       const quads = [];
       let error;
       this._callback = (e, t) => {
         e ? error = e : t && quads.push(t);
       };
-      this._lexer.tokenize(input).every(token => {
-        return this._readCallback = this._readCallback(token);
-      });
+      this._lexer.tokenize(input).every(readToken);
       if (error) throw error;
       return quads;
     }
-    let processNextToken = (error, token) => {
-      if (error !== null) this._callback(error), this._callback = noop;else if (this._readCallback) this._readCallback = this._readCallback(token);
+    const processNextToken = (error, token) => {
+      if (error !== null) this._callback(error), this._callback = noop;else if (this._readCallback) readToken(token);
     };
 
-    // Enable checking for comments on every token when a commentCallback has been set
-    if (onComment) {
-      // Enable the lexer to return comments as tokens first (disabled by default)
-      this._lexer.comments = true;
-      // Patch the processNextToken function
-      processNextToken = (error, token) => {
-        if (error !== null) this._callback(error), this._callback = noop;else if (this._readCallback) {
-          if (token.type === 'comment') onComment(token.value);else this._readCallback = this._readCallback(token);
-        }
-      };
-    }
-
     // Parse asynchronously otherwise, executing the read callback when a token arrives
     this._callback = onQuad;
     this._lexer.tokenize(input, processNextToken);

package/package.json

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

package/src/N3Lexer.js

@@ -5,8 +5,6 @@ import namespaces from './IRIs';
 const { xsd } = namespaces;
 const SPACE = 0x20, TAB = 0x09, LF = 0x0A, CR = 0x0D, HASH = 0x23;
 
-// Regular expression and replacement strings to unescape N3 strings
-const escapeSequence = /\\u([a-fA-F0-9]{4})|\\U([a-fA-F0-9]{8})|\\([^])/g;
 // Fixed escape sequences allowed in string literals (ECHAR)
 const stringEscapeReplacements = {
   '\\': '\\', "'": "'", '"': '"',
@@ -561,37 +559,48 @@ export default class N3Lexer {
   // ### `_unescape` replaces N3 escape codes by their corresponding characters,
   // allowing only the fixed escape sequences from the given replacement table
   _unescape(item, replacements) {
-    if (item.indexOf('\\') < 0)
+    let backslash = item.indexOf('\\');
+    if (backslash < 0)
       return item;
-    let invalid = false;
-    const replaced = item.replace(escapeSequence, (sequence, unicode4, unicode8, escapedChar) => {
-      // 4-digit unicode character
-      if (typeof unicode4 === 'string') {
-        const charCode = Number.parseInt(unicode4, 16);
-        if (!isValidCodePoint(charCode)) {
-          invalid = true;
-          return '';
+
+    let result = '', start = 0;
+    // A trailing lone backslash is not an escape sequence.
+    while (backslash >= 0 && backslash + 1 < item.length) {
+      const escapedChar = item[backslash + 1];
+      let end = backslash + 2, replacement;
+      if (escapedChar === 'u' || escapedChar === 'U') {
+        end += escapedChar === 'u' ? 4 : 8;
+        if (end > item.length)
+          return null;
+
+        let charCode = 0;
+        for (let i = backslash + 2; i < end; i++) {
+          let digit = item.charCodeAt(i);
+          if (digit >= 0x30 && digit <= 0x39) // 0–9
+            digit -= 0x30;
+          else if (digit >= 0x41 && digit <= 0x46) // A–F
+            digit -= 0x41 - 10;
+          else if (digit >= 0x61 && digit <= 0x66) // a–f
+            digit -= 0x61 - 10;
+          else
+            return null;
+          // Eight digits can exceed a signed 32-bit integer; avoid bitwise shifts.
+          charCode = charCode * 16 + digit;
         }
-        return String.fromCharCode(charCode);
+        if (!isValidCodePoint(charCode))
+          return null;
+        replacement = String.fromCodePoint(charCode);
       }
-      // 8-digit unicode character
-      if (typeof unicode8 === 'string') {
-        let charCode = Number.parseInt(unicode8, 16);
-        if (!isValidCodePoint(charCode)) {
-          invalid = true;
-          return '';
-        }
-        return charCode <= 0xFFFF ? String.fromCharCode(Number.parseInt(unicode8, 16)) :
-          String.fromCharCode(0xD800 + ((charCode -= 0x10000) >> 10), 0xDC00 + (charCode & 0x3FF));
+      else {
+        if (!(escapedChar in replacements))
+          return null;
+        replacement = replacements[escapedChar];
       }
-      // fixed escape sequence
-      if (escapedChar in replacements)
-        return replacements[escapedChar];
-      // invalid escape sequence
-      invalid = true;
-      return '';
-    });
-    return invalid ? null : replaced;
+      result += item.slice(start, backslash) + replacement;
+      start = end;
+      backslash = item.indexOf('\\', start);
+    }
+    return result + item.slice(start);
   }
 
   // ### `_parseLiteral` parses a literal into an unescaped value

package/src/N3Parser.js

@@ -1564,14 +1564,17 @@ export default class N3Parser {
 
   // ### `parse` parses the N3 input and emits each parsed quad through the onQuad callback.
   parse(input, quadCallback, prefixCallback, versionCallback) {
-    // The second parameter accepts an object { onQuad: ..., onPrefix: ..., onComment: ...}
+    // 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;
-    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion)) {
+    let onQuad, onPrefix, onComment, onVersion, onToken, onTokenEnd;
+    if (quadCallback && (quadCallback.onQuad || quadCallback.onPrefix || quadCallback.onComment || quadCallback.onVersion ||
+                         quadCallback.onToken || quadCallback.onTokenEnd)) {
       onQuad = quadCallback.onQuad;
       onPrefix = quadCallback.onPrefix;
       onComment = quadCallback.onComment;
       onVersion = quadCallback.onVersion;
+      onToken = quadCallback.onToken;
+      onTokenEnd = quadCallback.onTokenEnd;
     }
     else {
       onQuad = quadCallback;
@@ -1595,42 +1598,60 @@ export default class N3Parser {
     this._quantified = Object.create(null);
     this._emptyFormula = false;
 
-    // Parse synchronously if no quad callback is given
+    let readToken = token => {
+      return this._readCallback = this._readCallback(token);
+    };
+
+    // Comments bypass the grammar, but participate in the token lifecycle.
+    if (onComment || this._lexer.comments) {
+      this._lexer.comments = true;
+      const readGrammarToken = readToken;
+      readToken = token => {
+        if (token.type !== 'comment')
+          return readGrammarToken(token);
+        if (onComment) onComment(token.value);
+        return this._readCallback;
+      };
+    }
+
+    // Install observers once per parse, leaving the ordinary token path intact.
+    if (onToken || onTokenEnd) {
+      const consumeToken = readToken;
+      readToken = token => {
+        try {
+          try {
+            if (onToken) onToken(token);
+            return consumeToken(token);
+          }
+          finally {
+            if (onTokenEnd) onTokenEnd(token);
+          }
+        }
+        catch (error) {
+          // A consumer exception aborts this parse, including later chunks.
+          this._readCallback = null;
+          throw error;
+        }
+      };
+    }
+
+    // Parse synchronously if no quad callback is given.
     if (!onQuad) {
       const quads = [];
       let error;
       this._callback = (e, t) => { e ? (error = e) : t && quads.push(t); };
-      this._lexer.tokenize(input).every(token => {
-        return this._readCallback = this._readCallback(token);
-      });
+      this._lexer.tokenize(input).every(readToken);
       if (error) throw error;
       return quads;
     }
 
-    let processNextToken = (error, token) => {
+    const processNextToken = (error, token) => {
       if (error !== null)
         this._callback(error), this._callback = noop;
       else if (this._readCallback)
-        this._readCallback = this._readCallback(token);
+        readToken(token);
     };
 
-    // Enable checking for comments on every token when a commentCallback has been set
-    if (onComment) {
-      // Enable the lexer to return comments as tokens first (disabled by default)
-      this._lexer.comments = true;
-      // Patch the processNextToken function
-      processNextToken = (error, token) => {
-        if (error !== null)
-          this._callback(error), this._callback = noop;
-        else if (this._readCallback) {
-          if (token.type === 'comment')
-            onComment(token.value);
-          else
-            this._readCallback = this._readCallback(token);
-        }
-      };
-    }
-
     // Parse asynchronously otherwise, executing the read callback when a token arrives
     this._callback = onQuad;
     this._lexer.tokenize(input, processNextToken);