From 2087736649512571d09efe47c52fcbe9cb2fc1fe Mon Sep 17 00:00:00 2001
From: John-David Dalton <john.david.dalton@gmail.com>
Date: Fri, 25 Sep 2015 01:26:15 -0700
Subject: [PATCH] Add support for unicode modifiers.

---
 lodash.js    | 11 +++++++----
 test/test.js | 52 ++++++++++++++++++++++++++++++++++++++++++++++------
 2 files changed, 53 insertions(+), 10 deletions(-)

diff --git a/lodash.js b/lodash.js
index 0cfc0f435..88bbb681a 100644
--- a/lodash.js
+++ b/lodash.js
@@ -148,28 +148,31 @@
       rsDigits = '\\d+',
       rsDingbat = '[\\u2700-\\u27bf]',
       rsLowers = '[a-z\\xdf-\\xf6\\xf8-\\xff]+',
+      rsModifier = '(?:\\ud83c[\\udffb-\\udfff])',
       rsNonAstral = '[^' + rsAstralRange + ']',
       rsRegional = '(?:\\ud83c[\\udde6-\\uddff]){2}',
       rsSurrPair = '[\\ud800-\\udbff][\\udc00-\\udfff]',
+      rsSymbol = '(?:' + [rsNonAstral, rsRegional, rsSurrPair, rsAstral].join('|') + ')',
       rsUpper = '[A-Z\\xc0-\\xd6\\xd8-\\xde]',
       rsVS = '\\ufe0e\\ufe0f',
       rsZWJ = '\\u200d',
+      reOptMod = rsModifier + '?',
       rsOptVS = '[' + rsVS + ']?',
-      rsJoiner = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVS + ')*',
-      rsSymbol = '(?:' + [rsNonAstral, rsRegional, rsSurrPair, rsAstral].join('|') + ')';
+      rsJoiner = '(?:' + rsZWJ + '(?:' + [rsNonAstral, rsRegional, rsSurrPair].join('|') + ')' + rsOptVS + reOptMod + ')*',
+      rsSeq = rsOptVS + reOptMod + rsJoiner;
 
   /** Used to match [zero-width joiners and code points from the astral planes](http://eev.ee/blog/2015/09/12/dark-corners-of-unicode/). */
   var reAdvSymbol = RegExp('[' + rsZWJ + rsVS + rsAstralRange + ']');
 
   /** Used to match [string symbols](https://mathiasbynens.be/notes/javascript-unicode). */
-  var reStrSymbol = RegExp(rsSymbol + rsOptVS + rsJoiner, 'g');
+  var reStrSymbol = RegExp(rsSymbol + rsSeq, 'g');
 
   /** Used to match words to create compound words. */
   var reWord = RegExp([
     rsUpper + '+(?=' + rsUpper + rsLowers + ')',
     rsUpper + '?' + rsLowers,
     rsUpper + '+',
-    '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsOptVS + rsJoiner,
+    '(?:' + [rsDingbat, rsRegional, rsSurrPair].join('|') + ')' + rsSeq,
     rsDigits
   ].join('|'), 'g');
 
diff --git a/test/test.js b/test/test.js
index 7e581ac13..c2cc1f34b 100644
--- a/test/test.js
+++ b/test/test.js
@@ -18888,12 +18888,16 @@
   QUnit.module('astral symbols');
 
   (function() {
-    var flag = '\ud83c\uddfa\ud83c\uddf8',
+    var emojiVar = '\ufe0f',
+        flag = '\ud83c\uddfa\ud83c\uddf8',
+        heart = '\u2764' + emojiVar,
         hearts = '\ud83d\udc95',
         leafs = '\ud83c\udf42',
+        raisedHand = '\u270B' + emojiVar,
         rocket = '\ud83d\ude80',
-        varHeart = '\u2764\ufe0f',
-        comboGlyph = '\ud83d\udc68\u200d' + varHeart + '\u200d\ud83d\udc8B\u200d\ud83d\udc68';
+        thumbsUp = '\ud83d\udc4d',
+        comboGlyph = '\ud83d\udc68\u200d' + heart + '\u200d\ud83d\udc8B\u200d\ud83d\udc68',
+        modifiers = ['\ud83c\udffb', '\ud83c\udffc', '\ud83c\udffd', '\ud83c\udffe', '\ud83c\udfff'];
 
     QUnit.test('should account for astral symbols', function(assert) {
       assert.expect(25);
@@ -18972,9 +18976,45 @@
     QUnit.test('should account for variation selectors', function(assert) {
       assert.expect(3);
 
-      assert.strictEqual(_.size(varHeart), 1);
-      assert.deepEqual(_.toArray(varHeart), [varHeart]);
-      assert.deepEqual(_.words(varHeart), [varHeart]);
+      assert.strictEqual(_.size(heart), 1);
+      assert.deepEqual(_.toArray(heart), [heart]);
+      assert.deepEqual(_.words(heart), [heart]);
+    });
+
+    QUnit.test('should account for modifiers', function(assert) {
+      assert.expect(1);
+
+      var values = _.map(modifiers, function(modifier) {
+        return thumbsUp + modifier;
+      });
+
+      var expected = _.map(values, function(value) {
+        return [1, [value], [value]];
+      });
+
+      var actual = _.map(values, function(value) {
+        return [_.size(value), _.toArray(value), _.words(value)];
+      });
+
+      assert.deepEqual(actual, expected);
+    });
+
+    QUnit.test('should account for variation selectors with modifiers', function(assert) {
+      assert.expect(1);
+
+      var values = _.map(modifiers, function(modifier) {
+        return raisedHand + modifier;
+      });
+
+      var expected = _.map(values, function(value) {
+        return [1, [value], [value]];
+      });
+
+      var actual = _.map(values, function(value) {
+        return [_.size(value), _.toArray(value), _.words(value)];
+      });
+
+      assert.deepEqual(actual, expected);
     });
   }());