Add resources.

src/Workspaces/Core/Portable/EmbeddedLanguages/RegularExpressions/LanguageServices/RegexEmbeddedCompletionProvider.cs

@@ -121,6 +121,7 @@ public async Task ProvideCompletionsAsync(EmbeddedCompletionContext context)
             }
 
             ProvideAnchorCompletions(context, stringToken, inCharacterClass);
+            ProvideCharacterClassCompletions(context, stringToken, parentOpt: null);
             ProvideEscapeCompletions(context, stringToken, inCharacterClass, parentOpt: null);
         }
 
@@ -164,7 +165,7 @@ public async Task ProvideCompletionsAsync(EmbeddedCompletionContext context)
 
             if (token.Kind == RegexKind.OpenBracketToken)
             {
-                // ProvideCharacterClassCompletions(context);
+                ProvideCharacterClassCompletions(context, stringToken, parent);
                 return;
             }
 
@@ -216,6 +217,13 @@ public async Task ProvideCompletionsAsync(EmbeddedCompletionContext context)
             }
         }
 
+        private void ProvideCharacterClassCompletions(
+            EmbeddedCompletionContext context, SyntaxToken stringToken, RegexNode parentOpt)
+        {
+            AddIfMissing(context, CreateItem(stringToken, "[]", regex_positive_character_group_short, regex_positive_character_group_long, context, parentOpt, positionOffset: "[".Length));
+            AddIfMissing(context, CreateItem(stringToken, "[^]", regex_negative_character_group_short, regex_negative_character_group_long, context, parentOpt, positionOffset: "[^".Length));
+        }
+
         private void ProvideEscapeCategoryCompletions(EmbeddedCompletionContext context)
         {
             foreach (var (name, (shortDesc, longDesc)) in RegexCharClass.EscapeCategories)

src/Workspaces/Core/Portable/WorkspacesResources.Designer.cs

@@ -1452,6 +1452,30 @@ internal class WorkspacesResources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+        ///
+        ///The syntax for specifying a list of individual characters is as follows:
+        ///
+        ///[^character_group]
+        ///
+        ///where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape cha [rest of string was truncated]&quot;;.
+        /// </summary>
+        internal static string regex_negative_character_group_long {
+            get {
+                return ResourceManager.GetString("regex_negative_character_group_long", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to negative character group.
+        /// </summary>
+        internal static string regex_negative_character_group_short {
+            get {
+                return ResourceManager.GetString("regex_negative_character_group_short", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Matches a new-line character, \u000A.
         /// </summary>
@@ -1488,6 +1512,30 @@ internal class WorkspacesResources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+        ///
+        ///The syntax for specifying a list of individual characters is as follows:
+        ///
+        ///[character_group]
+        ///
+        ///where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escap [rest of string was truncated]&quot;;.
+        /// </summary>
+        internal static string regex_positive_character_group_long {
+            get {
+                return ResourceManager.GetString("regex_positive_character_group_long", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to positive character group.
+        /// </summary>
+        internal static string regex_positive_character_group_short {
+            get {
+                return ResourceManager.GetString("regex_positive_character_group_short", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string..
         /// </summary>

src/Workspaces/Core/Portable/WorkspacesResources.resx

@@ -808,12 +808,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
   <data name="regex_hexadecimal_escape_short" xml:space="preserve">
     <value>hexidecimal escape</value>
   </data>
+  <data name="regex_negative_character_group_long" xml:space="preserve">
+    <value>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</value>
+  </data>
+  <data name="regex_negative_character_group_short" xml:space="preserve">
+    <value>negative character group</value>
+  </data>
   <data name="regex_new_line_character_long" xml:space="preserve">
     <value>Matches a new-line character, \u000A</value>
   </data>
   <data name="regex_new_line_character_short" xml:space="preserve">
     <value>new-line character</value>
   </data>
+  <data name="regex_positive_character_group_long" xml:space="preserve">
+    <value>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</value>
+  </data>
+  <data name="regex_positive_character_group_short" xml:space="preserve">
+    <value>positive character group</value>
+  </data>
   <data name="regex_tab_character_long" xml:space="preserve">
     <value>Matches a tab character, \u0009</value>
   </data>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.cs.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.de.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.es.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.fr.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.it.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.ja.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.ko.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.pl.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.pt-BR.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.ru.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.tr.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.zh-Hans.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>

src/Workspaces/Core/Portable/xlf/WorkspacesResources.zh-Hant.xlf

@@ -1065,6 +1065,56 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">hexidecimal escape</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_negative_character_group_long">
+        <source>A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</source>
+        <target state="new">A negative character group specifies a list of characters that must not appear in an input string for a match to occur. The list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[^character_group]
+
+where character_group is a list of the individual characters that cannot appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[^firstCharacter-lastCharacter]
+
+where firstCharacter is the character that begins the range, and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.
+
+Two or more character ranges can be concatenated. For example, to specify the range of decimal digits from "0" through "9", the range of lowercase letters from "a" through "f", and the range of uppercase letters from "A" through "F", use [0-9a-fA-F].
+
+The leading carat character (^) in a negative character group is mandatory and indicates the character group is a negative character group instead of a positive character group.
+
+Important
+
+A negative character group in a larger regular expression pattern is not a zero-width assertion. That is, after evaluating the negative character group, the regular expression engine advances one character in the input string.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_negative_character_group_short">
+        <source>negative character group</source>
+        <target state="new">negative character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_new_line_character_long">
         <source>Matches a new-line character, \u000A</source>
         <target state="new">Matches a new-line character, \u000A</target>
@@ -1085,6 +1135,40 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">non-word boundary</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_positive_character_group_long">
+        <source>A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</source>
+        <target state="new">A positive character group specifies a list of characters, any one of which may appear in an input string for a match to occur. This list of characters may be specified individually, as a range, or both.
+
+The syntax for specifying a list of individual characters is as follows:
+
+[character_group]
+
+where character_group is a list of the individual characters that can appear in the input string for a match to succeed. character_group can consist of any combination of one or more literal characters, escape characters, or character classes.
+
+The syntax for specifying a range of characters is as follows:
+
+[firstCharacter-lastCharacter]  
+
+where firstCharacter is the character that begins the range and lastCharacter is the character that ends the range. A character range is a contiguous series of characters defined by specifying the first character in the series, a hyphen (-), and then the last character in the series. Two characters are contiguous if they have adjacent Unicode code points.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_positive_character_group_short">
+        <source>positive character group</source>
+        <target state="new">positive character group</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_start_of_string_only_long">
         <source>The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</source>
         <target state="new">The \A anchor specifies that a match must occur at the beginning of the input string. It is identical to the ^ anchor, except that \A ignores the RegexOptions.Multiline option. Therefore, it can only match the start of the first line in a multiline input string.</target>
@@ -1115,6 +1199,16 @@ If you use $ with the RegexOptions.Multiline option, the match can also occur at
         <target state="new">tab character</target>
         <note />
       </trans-unit>
+      <trans-unit id="regex_unicode_escape_long">
+        <source>Matches a UTF-16 code unit whose value is #### hexadecimal.</source>
+        <target state="new">Matches a UTF-16 code unit whose value is #### hexadecimal.</target>
+        <note />
+      </trans-unit>
+      <trans-unit id="regex_unicode_escape_short">
+        <source>unicode escape</source>
+        <target state="new">unicode escape</target>
+        <note />
+      </trans-unit>
       <trans-unit id="regex_vertical_tab_character_long">
         <source>Matches a vertical-tab character, \u000B</source>
         <target state="new">Matches a vertical-tab character, \u000B</target>