Update TypeScript Scanner code to TypeScript current main (microsoft/…

…TypeScript@9757109)

src/Serenity.TypeScript/Parser/Parser.cs

@@ -529,7 +529,7 @@ SyntaxKind ReScanGreaterToken()
 
     SyntaxKind ReScanSlashToken()
     {
-        return currentToken = scanner.ReScanSlashToken();
+        return currentToken = scanner.ReScanSlashToken(reportErrors: false);
     }
 
     SyntaxKind ReScanTemplateToken(bool isTaggedTemplate)
@@ -2231,7 +2231,7 @@ ParameterDeclaration ParseJSDocParameter()
 
     ITypeNode ParseJSDocType()
     {
-        scanner.SetInJSDocType(true);
+        scanner.SetSkipJsDocLeadingAsterisks(true);
         var pos = GetNodePos();
         if (ParseOptional(SyntaxKind.ModuleKeyword))
         {
@@ -2254,13 +2254,13 @@ ITypeNode ParseJSDocType()
 
         terminateLabel:
 
-            scanner.SetInJSDocType(false);
+            scanner.SetSkipJsDocLeadingAsterisks(false);
             return FinishNode(moduleTag, pos);
         }
 
         var hasDotDotDot = ParseOptional(SyntaxKind.DotDotDotToken);
         var type = ParseTypeOrTypePredicate();
-        scanner.SetInJSDocType(false);
+        scanner.SetSkipJsDocLeadingAsterisks(false);
         if (hasDotDotDot)
         {
             type = FinishNode(new JSDocVariadicType(type), pos);

src/Serenity.TypeScript/Scanner/Scanner.CharacterCodes.cs

@@ -4,6 +4,7 @@ partial class Scanner
 {
     internal static class CharacterCodes
     {
+        internal const int EOF = -1;
         internal const int NullCharacter = 0;
         internal const int MaxAsciiCharacter = 0x7F;
 
@@ -146,6 +147,11 @@ private static bool IsCodePoint(int code)
         return code <= 0x10FFFF;
     }
 
+    private static bool IsASCIILetter(int ch)
+    {
+        return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+    }
+
     private static bool IsDigit(int ch)
     {
         return ch >= '0' && ch <= '9';
@@ -180,6 +186,11 @@ private static bool IsLineBreak(int ch)
             ch == CharacterCodes.ParagraphSeparator;
     }
 
+    private static bool IsWordCharacter(int ch)
+    {
+        return IsASCIILetter(ch) || IsDigit(ch) || ch == CharacterCodes._;
+    }
+
     public static bool IsWhiteSpaceLike(int ch)
     {
         return IsWhiteSpaceSingleLine(ch) || IsLineBreak(ch);

src/Serenity.TypeScript/Scanner/Scanner.IdentifierUtils.cs

@@ -4,14 +4,13 @@ partial class Scanner
 {
     private static bool IsIdentifierStart(int ch, ScriptTarget _)
     {
-        return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') || ch == '$' || ch == '_' ||
+        return IsASCIILetter(ch) || ch == '$' || ch == '_' ||
             (ch > CharacterCodes.MaxAsciiCharacter && IsUnicodeIdentifierStart(ch));
     }
 
     private static bool IsIdentifierPart(int ch, ScriptTarget _, LanguageVariant identifierVariant = LanguageVariant.Standard)
     {
-        return (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z') ||
-            (ch >= '0' && ch <= '9') || ch == '$' || ch == '_' ||
+        return IsWordCharacter(ch) || ch == '$' ||
             // "-" and ":" are valid in JSX Identifiers
             (identifierVariant == LanguageVariant.JSX && (ch == CharacterCodes.Minus || ch == CharacterCodes.Colon)) ||
             (ch > CharacterCodes.MaxAsciiCharacter && IsUnicodeIdentifierPart(ch));
@@ -23,22 +22,38 @@ private static int CharSize(int ch)
         {
             return 2;
         }
+        if (ch == CharacterCodes.EOF)
+        {
+            return 0;
+        }
         return 1;
     }
 
+    internal static int CodePointAt(string s, int pos)
+    {
+        if (pos < 0 || pos >= s.Length)
+            return CharacterCodes.EOF;
+
+        if (pos < s.Length - 1 &&
+            char.IsSurrogatePair(s, pos))
+            return char.ConvertToUtf32(s, pos);
+
+        return s[pos];
+    }
+
     internal static bool IsIdentifierText(string name, ScriptTarget languageVersion, LanguageVariant identifierVariant = LanguageVariant.Standard)
     {
         if (string.IsNullOrEmpty(name)) 
             return false;
-        var ch = (int)name[0];
+        var ch = CodePointAt(name, 0);
         if (!IsIdentifierStart(ch, languageVersion))
         {
             return false;
         }
 
         for (var i = CharSize(ch); i < name.Length; i += CharSize(ch))
         {
-            if (!IsIdentifierPart(name[i], languageVersion, identifierVariant))
+            if (!IsIdentifierPart(CodePointAt(name, i), languageVersion, identifierVariant))
             {
                 return false;
             }

src/Serenity.TypeScript/Scanner/Scanner.RegexUtils.cs

@@ -0,0 +1,40 @@
+namespace Serenity.TypeScript;
+
+partial class Scanner
+{
+    private static readonly Dictionary<int, RegularExpressionFlags> CharCodeToRegExpFlag = new()
+    {
+        [CharacterCodes.d] = RegularExpressionFlags.HasIndices,
+        [CharacterCodes.g] = RegularExpressionFlags.Global,
+        [CharacterCodes.i] = RegularExpressionFlags.IgnoreCase,
+        [CharacterCodes.m] = RegularExpressionFlags.Multiline,
+        [CharacterCodes.s] = RegularExpressionFlags.DotAll,
+        [CharacterCodes.u] = RegularExpressionFlags.Unicode,
+        [CharacterCodes.v] = RegularExpressionFlags.UnicodeSets,
+        [CharacterCodes.y] = RegularExpressionFlags.Sticky,
+    };
+
+    RegularExpressionFlags? CharacterCodeToRegularExpressionFlag(int ch)
+    {
+        return CharCodeToRegExpFlag.TryGetValue(ch, out RegularExpressionFlags value) ? value : null;
+    }
+
+    private static readonly Dictionary<RegularExpressionFlags, LanguageFeatureMinimumTarget> RegExpFlagToFirstAvailableLanguageVersion = new()
+    {
+        [RegularExpressionFlags.HasIndices] = LanguageFeatureMinimumTarget.RegularExpressionFlagsHasIndices,
+        [RegularExpressionFlags.DotAll] = LanguageFeatureMinimumTarget.RegularExpressionFlagsDotAll,
+        [RegularExpressionFlags.Unicode] = LanguageFeatureMinimumTarget.RegularExpressionFlagsUnicode,
+        [RegularExpressionFlags.UnicodeSets] = LanguageFeatureMinimumTarget.RegularExpressionFlagsUnicodeSets,
+        [RegularExpressionFlags.Sticky] = LanguageFeatureMinimumTarget.RegularExpressionFlagsSticky
+    };
+
+    public class RegexGroupNameRef : TextRange
+    {
+        public string Name { get; set; }
+    }
+
+    public class RegexDecimalEscape : TextRange
+    {
+        public decimal Value { get; set; }
+    }
+}