regjsgen.js in disco_app-0.18.1

- old
+ new

@@ -1,9 +1,9 @@
 /*!
- * regjsgen 0.5.1
- * Copyright 2014-2019 Benjamin Tan <https://bnjmnt4n.now.sh/>
- * Available under MIT license <https://github.com/bnjmnt4n/regjsgen/blob/master/LICENSE>
+ * regjsgen 0.5.2
+ * Copyright 2014-2020 Benjamin Tan <https://ofcr.se/>
+ * Available under the MIT license <https://github.com/bnjmnt4n/regjsgen/blob/master/LICENSE-MIT.txt>
  */
 ;(function() {
   'use strict';
 
   // Used to determine if values are of the language type `Object`.
@@ -94,27 +94,49 @@
     }
 
     throw Error('Invalid node type: ' + type);
   }
 
-  /*--------------------------------------------------------------------------*/
-
-  function generateAlternative(node) {
-    assertType(node.type, 'alternative');
-
-    var terms = node.body,
-        i = -1,
+  // Constructs a string by concatentating the output of each term.
+  function generateSequence(generator, terms) {
+    var i = -1,
         length = terms.length,
-        result = '';
+        result = '',
+        term;
 
     while (++i < length) {
-      result += generateTerm(terms[i]);
+      term = terms[i];
+
+      // Ensure that `\0` null escapes followed by number symbols are not
+      // treated as backreferences.
+      if (
+        i + 1 < length &&
+        terms[i].type == 'value' &&
+        terms[i].kind == 'null' &&
+        terms[i + 1].type == 'value' &&
+        terms[i + 1].kind == 'symbol' &&
+        terms[i + 1].codePoint >= 48 &&
+        terms[i + 1].codePoint <= 57
+      ) {
+        result += '\\000';
+        continue;
+      }
+
+      result += generator(term);
     }
 
     return result;
   }
 
+  /*--------------------------------------------------------------------------*/
+
+  function generateAlternative(node) {
+    assertType(node.type, 'alternative');
+
+    return generateSequence(generateTerm, node.body);
+  }
+
   function generateAnchor(node) {
     assertType(node.type, 'anchor');
 
     switch (node.kind) {
       case 'start':
@@ -137,38 +159,22 @@
   }
 
   function generateCharacterClass(node) {
     assertType(node.type, 'characterClass');
 
-    var classRanges = node.body,
-        i = -1,
-        length = classRanges.length,
-        result = '';
-
-    if (node.negative) {
-      result += '^';
-    }
-
-    while (++i < length) {
-      result += generateClassAtom(classRanges[i]);
-    }
-
-    return '[' + result + ']';
+    return '[' +
+      (node.negative ? '^' : '') +
+      generateSequence(generateClassAtom, node.body) +
+    ']';
   }
 
   function generateCharacterClassEscape(node) {
     assertType(node.type, 'characterClassEscape');
 
     return '\\' + node.value;
   }
 
-  function generateUnicodePropertyEscape(node) {
-    assertType(node.type, 'unicodePropertyEscape');
-
-    return '\\' + (node.negative ? 'P' : 'p') + '{' + node.value + '}';
-  }
-
   function generateCharacterClassRange(node) {
     assertType(node.type, 'characterClassRange');
 
     var min = node.min,
         max = node.max;
@@ -238,18 +244,12 @@
         break;
       default:
         throw Error('Invalid behaviour: ' + node.behaviour);
     }
 
-    var body = node.body,
-        i = -1,
-        length = body.length;
+    result += generateSequence(generate, node.body);
 
-    while (++i < length) {
-      result += generate(body[i]);
-    }
-
     return '(' + result + ')';
   }
 
   function generateIdentifier(node) {
     assertType(node.type, 'identifier');
@@ -304,10 +304,16 @@
     assertType(node.type, 'anchor|characterClass|characterClassEscape|empty|group|quantifier|reference|unicodePropertyEscape|value|dot');
 
     return generate(node);
   }
 
+  function generateUnicodePropertyEscape(node) {
+    assertType(node.type, 'unicodePropertyEscape');
+
+    return '\\' + (node.negative ? 'P' : 'p') + '{' + node.value + '}';
+  }
+
   function generateValue(node) {
     assertType(node.type, 'value');
 
     var kind = node.kind,
         codePoint = node.codePoint;
@@ -324,11 +330,11 @@
       case 'identifier':
         return '\\' + fromCodePoint(codePoint);
       case 'null':
         return '\\' + codePoint;
       case 'octal':
-        return '\\' + codePoint.toString(8);
+        return '\\' + ('000' + codePoint.toString(8)).slice(-3);
       case 'singleEscape':
         switch (codePoint) {
           case 0x0008:
             return '\\b';
           case 0x0009:
@@ -339,10 +345,12 @@
             return '\\v';
           case 0x000C:
             return '\\f';
           case 0x000D:
             return '\\r';
+          case 0x002D:
+            return '\\-';
           default:
             throw Error('Invalid code point: ' + codePoint);
         }
       case 'symbol':
         return fromCodePoint(codePoint);
@@ -362,15 +370,15 @@
     'alternative': generateAlternative,
     'anchor': generateAnchor,
     'characterClass': generateCharacterClass,
     'characterClassEscape': generateCharacterClassEscape,
     'characterClassRange': generateCharacterClassRange,
-    'unicodePropertyEscape': generateUnicodePropertyEscape,
     'disjunction': generateDisjunction,
     'dot': generateDot,
     'group': generateGroup,
     'quantifier': generateQuantifier,
     'reference': generateReference,
+    'unicodePropertyEscape': generateUnicodePropertyEscape,
     'value': generateValue
   };
 
   /*--------------------------------------------------------------------------*/
 