Parser: Parse surrogate pairs and es6 unicode code point escapes only when u flag is set

Author: Golmote

README.md

@@ -884,7 +884,6 @@ Unicode char started with `\u`, followed by a hex number:
 
 ```
 \u003B
-\u{003B}
 ```
 
 Node:
@@ -899,6 +898,43 @@ Node:
 }
 ```
 
+When using the `u` flag, unicode chars can also be represented using `\u` followed by a hex number between curly braces:
+
+```
+\u{1F680}
+```
+
+Node:
+
+```js
+{
+  type: 'Char',
+  value: '\\u{1F680}',
+  symbol: '🚀',
+  kind: 'unicode',
+  codePoint: 128640
+}
+```
+
+When using the `u` flag, unicode chars can also be represented using a surrogate pair:
+
+```
+\ud83d\ude80
+```
+
+Node:
+
+```js
+{
+  type: 'Char',
+  value: '\\ud83d\\ude80',
+  symbol: '🚀',
+  kind: 'unicode',
+  codePoint: 128640,
+  isSurrogatePair: true
+}
+```
+
 #### Character class
 
 Character classes define a _set_ of characters. A set may include as simple characters, as well as _character ranges_. A class can be _positive_ (any from the characters in the class match), or _negative_ (any _but_ the characters from the class match).

src/parser/__tests__/parser-basic-test.js

@@ -933,26 +933,67 @@ describe('basic', () => {
       codePoint: 0x000001d306
     });
 
-    // TODO: without `u` flag \u{1234} should be parsed NOT as
-    // a unicode code point, but as an (escaped) `u` character,
-    // repeated 1234 times.
+    // Not using `u` flag, not parsed as a unicode code point,
+    // but as an (escaped) `u` character repeated 1234 times.
+    expect(re(/\u{1234}/).body).toEqual({
+      type: 'Repetition',
+      expression: {
+        type: 'Char',
+        value: 'u',
+        symbol: 'u',
+        kind: 'simple',
+        escaped: true,
+        codePoint: 'u'.codePointAt(0)
+      },
+      quantifier: {
+        type: 'Quantifier',
+        kind: 'Range',
+        from: 1234,
+        to: 1234,
+        greedy: true
+      }
+    });
 
-    // expect(re(/\u{1234}/).body).toEqual({
-    //   type: 'Repetition',
-    //   expression: {
-    //     type: 'Char',
-    //     value: 'u',
-    //     kind: 'simple',
-    //     escaped: true
-    //   },
-    //   quantifier: {
-    //     type: 'Quantifier',
-    //     kind: 'Range',
-    //     from: 1234,
-    //     to: 1234,
-    //     greedy: true
-    //   }
-    // });
+    // Using `u` flag, surrogate pairs.
+    expect(re(/\ud83d\ude80/u).body).toEqual({
+      type: 'Char',
+      value: '\\ud83d\\ude80',
+      kind: 'unicode',
+      symbol: String.fromCodePoint(0x1F680),
+      codePoint: 0x1F680,
+      isSurrogatePair: true
+    });
+
+    // Using `u` flag, surrogate pairs in character class.
+    expect(re(/[\ud83d\ude80]/u).body).toEqual({
+      type: 'CharacterClass',
+      expressions: [{
+        type: 'Char',
+        value: '\\ud83d\\ude80',
+        kind: 'unicode',
+        symbol: String.fromCodePoint(0x1F680),
+        codePoint: 0x1F680,
+        isSurrogatePair: true
+      }]
+    });
+
+    // Not using `u` flag, surrogate pairs are treated as two characters
+    expect(re(/\ud83d\ude80/).body).toEqual({
+      type: 'Alternative',
+      expressions: [{
+        type: 'Char',
+        value: '\\ud83d',
+        kind: 'unicode',
+        symbol: String.fromCodePoint(0xd83d),
+        codePoint: 0xd83d
+      }, {
+        type: 'Char',
+        value: '\\ude80',
+        kind: 'unicode',
+        symbol: String.fromCodePoint(0xde80),
+        codePoint: 0xde80
+      }]
+    });
   });
 
   it('valid sorted flags', () => {