tsc-ts 0.0.10 → 0.1.1

package/dist/api/compiler/scanner.js

@@ -1,4 +1,5 @@
 import { charSize, codePointAt, isASCIILetter, isDigit, isHexDigit, isIdentifierPart, isIdentifierStart, isLineBreak, isOctalDigit, isWhiteSpaceLike, isWhiteSpaceSingleLine, } from './character-codes.js';
+import { IdentifierName } from './identifier-name.js';
 import { parsePseudoBigInt } from './pseudo-bigint.js';
 import { checkRegularExpression, regularExpressionFlag, } from './regexp-checker.js';
 import { CommentDirective, CommentRange, } from './types.js';
@@ -66,6 +67,7 @@ const textToKeyword = new Map([
     ['return', 106 /* SyntaxKind.ReturnKeyword */],
     ['satisfies', 152 /* SyntaxKind.SatisfiesKeyword */],
     ['set', 153 /* SyntaxKind.SetKeyword */],
+    ['source', 167 /* SyntaxKind.SourceKeyword */],
     ['static', 125 /* SyntaxKind.StaticKeyword */],
     ['string', 154 /* SyntaxKind.StringKeyword */],
     ['super', 107 /* SyntaxKind.SuperKeyword */],
@@ -154,7 +156,7 @@ const textToToken = new Map([
     ['`', 61 /* SyntaxKind.BacktickToken */],
 ]);
 const tokenToText = [];
-for (let kind = 0; kind <= 166 /* SyntaxKind.LastToken */; kind++)
+for (let kind = 0; kind <= 167 /* SyntaxKind.LastToken */; kind++)
     tokenToText.push('');
 for (const [text, kind] of textToToken)
     tokenToText[kind] = text;
@@ -307,58 +309,58 @@ function rangeHash(chars, start, end) {
 function finishHash(hash) {
     return hash ^ (hash >>> 15);
 }
-/** Strings for ranges of one text, keyed by their code units: equal identifiers share one string. */
+/**
+ * Names for ranges of one text, keyed by their code units: equal identifiers share one
+ * `IdentifierName`.
+ */
 class IdentifierTable {
-    text;
     // Pairs of (entry index + 1, hash) per slot, (0, 0) when empty; linear probing.
     slots;
     // Each entry's length in code units.
     lengths;
-    texts;
+    names;
     count;
-    // Per entry: 1 once its text was recorded among the file's identifier texts (`markRecorded`).
+    // Per entry: 1 once its name was recorded among the file's identifier texts (`markRecorded`).
     recorded;
-    // The entry the last `intern` returned.
-    lastEntry;
-    constructor(text) {
-        this.text = text;
+    constructor() {
         this.slots = new Int32Array(512);
         this.lengths = new Int32Array(128);
-        this.texts = [];
+        this.names = [];
         this.count = 0;
         this.recorded = new Uint8Array(128);
-        this.lastEntry = -1;
+    }
+    /** Empties the table for a new text. */
+    clear() {
+        if (this.count === 0)
+            return;
+        this.slots.fill(0);
+        this.names.length = 0;
+        this.recorded.fill(0, 0, this.count);
+        this.count = 0;
     }
     /**
-     * Whether `text`, just returned by `intern`, still needs recording among the file's identifier
-     * texts; marks it recorded. Texts the table doesn't know are always recorded.
+     * Whether `text`, the text of the entry `entry` that `intern` returned (-1 for none), still needs
+     * recording among the file's identifier texts; marks it recorded. Texts the table doesn't know are
+     * always recorded.
      */
-    markRecorded(text) {
-        const entry = this.lastEntry;
-        if (entry < 0 || this.texts[entry] !== text)
+    markRecorded(entry, text) {
+        if (entry < 0 || this.names[entry].text !== text)
             return true;
         if (this.recorded[entry] !== 0)
             return false;
         this.recorded[entry] = 1;
         return true;
     }
-    /** Empties the table for a new text. */
-    setText(text) {
-        this.text = text;
-        if (this.count === 0)
-            return;
-        this.slots.fill(0);
-        this.recorded.fill(0, 0, this.count);
-        this.texts.length = 0;
-        this.count = 0;
-        this.lastEntry = -1;
+    /** The name of the entry `intern` returned. */
+    name(entry) {
+        return this.names[entry];
     }
     /**
-     * `text.substring(start, end)`, or the string interned for an equal range; `hash` is its `rangeHash`.
-     * A candidate of the same hash and length is compared with `startsWith`, which natively compares
-     * the bytes of both strings at once.
+     * The entry of `text.substring(start, end)`, added when the table has no equal range; `hash` is its
+     * `rangeHash`. A candidate of the same hash and length is compared with `startsWith`, which natively
+     * compares the bytes of both strings at once.
      */
-    intern(start, end, hash) {
+    intern(text, start, end, hash) {
         start = start | 0;
         end = end | 0;
         hash = hash | 0;
@@ -371,15 +373,11 @@ class IdentifierTable {
             if (entry === 0)
                 break;
             if ((slots[(slot * 2 + 1) | 0] | 0) === hash && (this.lengths[(entry - 1) | 0] | 0) === length) {
-                const candidate = this.texts[(entry - 1) | 0];
-                if (this.text.startsWith(candidate, start)) {
-                    this.lastEntry = (entry - 1) | 0;
-                    return candidate;
-                }
+                if (text.startsWith(this.names[(entry - 1) | 0].text, start))
+                    return (entry - 1) | 0;
             }
             slot = (slot + 1) & mask;
         }
-        const value = this.text.substring(start, end);
         const index = this.count | 0;
         if (index === this.lengths.length) {
             const lengths = new Int32Array(index * 2);
@@ -390,14 +388,13 @@ class IdentifierTable {
             this.recorded = recorded;
         }
         this.lengths[index] = length;
-        this.texts.push(value);
+        this.names.push(new IdentifierName(text.substring(start, end)));
         this.count = (index + 1) | 0;
-        this.lastEntry = index;
         slots[(slot * 2) | 0] = (index + 1) | 0;
         slots[(slot * 2 + 1) | 0] = hash;
         if (this.count * 2 > mask + 1)
             this.slots = rehash(slots);
-        return value;
+        return index;
     }
 }
 /** `IdentifierTable` slots in a table twice the size. */
@@ -545,6 +542,8 @@ export class Scanner {
     // so identifiers and keywords don't allocate until their value is read.
     /** @internal */ tokenValue;
     /** @internal */ valueStart;
+    // The name `getIdentifierValue` last interned, whose text `tokenValue` then holds.
+    tokenName;
     /** @internal */ valueEnd;
     // `rangeHash` of `chars[hashStart, hashEnd)`, which the ASCII identifier scan computes as it goes.
     valueHash;
@@ -555,6 +554,8 @@ export class Scanner {
     // The code units zeroed by `setTextEnd`.
     cutUnits;
     identifiers;
+    // The entry `getIdentifierValue` last interned, -1 for none.
+    lastEntry;
     // With code units on demand: per block of `unitBlockSize` code units, 1 once `chars` holds them
     // (`loadUnits`); `chars` is zero elsewhere.
     loadedBlocks;
@@ -593,6 +594,7 @@ export class Scanner {
         this.tokenFlags = 0 /* TokenFlags.None */;
         this.tokenValue = '';
         this.valueStart = -1;
+        this.tokenName = undefined;
         this.valueEnd = -1;
         this.valueHash = 0;
         this.hashStart = -1;
@@ -600,7 +602,8 @@ export class Scanner {
         this.commentDirectives = [];
         this.skipJSDocLeadingAsterisks = 0;
         this.cutUnits = new Uint16Array(4);
-        this.identifiers = new IdentifierTable(text);
+        this.identifiers = new IdentifierTable();
+        this.lastEntry = -1;
         this.textKind = 0 /* TextKind.Unknown */;
         this.lineFeedFrom = -1;
         this.lineFeedAt = -1;
@@ -612,7 +615,8 @@ export class Scanner {
         this.text = text;
         this.chars = toCodeUnits(text);
         this.loadedBlocks = undefined;
-        this.identifiers.setText(text);
+        this.identifiers.clear();
+        this.lastEntry = -1;
         this.textKind = 0 /* TextKind.Unknown */;
         this.lineFeedFrom = -1;
         this.lineFeedAt = -1;
@@ -736,7 +740,7 @@ export class Scanner {
      * file to be recorded; files record each identifier text once.
      */
     recordIdentifierValue(text) {
-        return this.identifiers.markRecorded(text);
+        return this.identifiers.markRecorded(this.lastEntry, text);
     }
     /** @internal Like `getTokenValue`, but identifiers with the same text share one string. */
     getIdentifierValue() {
@@ -744,11 +748,24 @@ export class Scanner {
         if (start >= 0) {
             const end = this.valueEnd;
             const hash = start === this.hashStart && end === this.hashEnd ? this.valueHash : rangeHash(this.chars, start, end);
-            this.tokenValue = this.identifiers.intern(start, end, hash);
+            const entry = this.identifiers.intern(this.text, start, end, hash);
+            this.lastEntry = entry;
+            this.tokenName = this.identifiers.name(entry);
+            this.tokenValue = this.tokenName.text;
             this.valueStart = -1;
         }
         return this.tokenValue;
     }
+    /**
+     * The identifier value as a name that identifiers with the same text share, after
+     * `getIdentifierValue`; a cooked value (with escapes) gets a name of its own.
+     */
+    getIdentifierName() {
+        const name = this.tokenName;
+        if (name !== undefined && name.text === this.tokenValue)
+            return name;
+        return new IdentifierName(this.tokenValue);
+    }
     getCommentDirectives() {
         return this.commentDirectives;
     }
@@ -1209,36 +1226,21 @@ export class Scanner {
                 case 64 /* CharacterCodes.at */:
                     this.pos = (this.pos + 1) | 0;
                     return (this.token = 59 /* SyntaxKind.AtToken */);
-                case 92 /* CharacterCodes.backslash */: {
-                    const codePoint = this.peekUnicodeEscape();
-                    if (codePoint >= 0 && isIdentifierStart(codePoint)) {
-                        const head = String.fromCodePoint(this.scanUnicodeEscape(true));
-                        this.setValue(head + this.scanIdentifierParts());
+                case 92 /* CharacterCodes.backslash */:
+                    if (this.scanIdentifier(0, 0 /* IdentifierVariant.Standard */))
                         return (this.token = getIdentifierToken(this.tokenValue));
-                    }
                     return this.scanInvalidCharacter();
-                }
                 case 35 /* CharacterCodes.hash */:
                     if ((chars[this.pos + 1] | 0) === 33 /* CharacterCodes.exclamation */) {
                         if (this.pos === 0) {
                             this.pos = scanShebangTrivia(this.text, 0) | 0;
                             continue;
                         }
-                        this.errorAt(1843 /* Diagnostics.X_can_only_be_used_at_the_start_of_a_file */, this.pos, 2, noArgs);
-                        this.pos = (this.pos + 1) | 0;
+                        this.errorAt(1863 /* Diagnostics.X_can_only_be_used_at_the_start_of_a_file */, this.pos, 2, noArgs);
+                        this.pos = (this.pos + 2) | 0;
                         return (this.token = 0 /* SyntaxKind.Unknown */);
                     }
-                    if ((chars[this.pos + 1] | 0) === 92 /* CharacterCodes.backslash */) {
-                        this.pos = (this.pos + 1) | 0;
-                        const codePoint = this.peekUnicodeEscape();
-                        if (codePoint >= 0 && isIdentifierStart(codePoint)) {
-                            const head = '#' + String.fromCodePoint(this.scanUnicodeEscape(true));
-                            this.setValue(head + this.scanIdentifierParts());
-                            return (this.token = 80 /* SyntaxKind.PrivateIdentifier */);
-                        }
-                        this.pos = (this.pos - 1) | 0;
-                    }
-                    if (!this.scanIdentifier(1)) {
+                    if (!this.scanIdentifier(1, 0 /* IdentifierVariant.Standard */)) {
                         this.errorAt(94 /* Diagnostics.Invalid_character */, this.pos - 1, 1, noArgs);
                         this.setValue('#');
                     }
@@ -1246,11 +1248,11 @@ export class Scanner {
                 default: {
                     if (ch < 0)
                         return (this.token = 1 /* SyntaxKind.EndOfFile */);
-                    if (this.scanIdentifier(0))
+                    if (this.scanIdentifier(0, 0 /* IdentifierVariant.Standard */))
                         return (this.token = this.identifierKind());
                     const codePoint = this.codePoint();
                     if (codePoint === 65533 /* CharacterCodes.replacementCharacter */) {
-                        this.errorAt(405 /* Diagnostics.File_appears_to_be_binary */, 0, 0, noArgs);
+                        this.errorAt(403 /* Diagnostics.File_appears_to_be_binary */, 0, 0, noArgs);
                         this.pos = this.end;
                         return (this.token = 7 /* SyntaxKind.NonTextFileMarkerTrivia */);
                     }
@@ -1441,14 +1443,38 @@ export class Scanner {
             return;
         this.commentDirectives.push(new CommentDirective(start, end, kind));
     }
-    /** @internal Scans an identifier after `prefixLength` units; sets the token value. */
-    scanIdentifier(prefixLength) {
+    /**
+     * @internal Scans an identifier after `prefixLength` units; sets the token value. `variant`
+     * decides the identifier parts: JSX and JSDoc names also take `-`, and regular expression group
+     * names take a surrogate pair written as two `\u` escapes.
+     */
+    scanIdentifier(prefixLength, variant) {
         const text = this.text;
         const chars = this.chars;
         const start = this.pos;
         this.pos = (this.pos + prefixLength) | 0;
+        const identifierStart = this.pos;
         let ch = this.char();
-        if (isASCIILetter(ch) || ch === 95 /* CharacterCodes._ */ || ch === 36 /* CharacterCodes.$ */) {
+        if (variant === 1 /* IdentifierVariant.JSX */) {
+            if (isASCIILetter(ch) || ch === 95 /* CharacterCodes._ */ || ch === 36 /* CharacterCodes.$ */) {
+                // ASCII names, as the general loop below scans them.
+                let pos = (this.pos + 1) | 0;
+                const end = this.end;
+                while (pos < end) {
+                    const c = chars[pos] | 0;
+                    if (!isASCIIIdentifierPart(c) && c !== 45 /* CharacterCodes.minus */)
+                        break;
+                    pos = (pos + 1) | 0;
+                }
+                const next = pos < end ? chars[pos] | 0 : -1 /* CharacterCodes.EOF */;
+                if (next <= 127 /* CharacterCodes.maxAsciiCharacter */ && next !== 92 /* CharacterCodes.backslash */) {
+                    this.pos = pos;
+                    this.setValueSlice(start, pos);
+                    return true;
+                }
+            }
+        }
+        else if (isASCIILetter(ch) || ch === 95 /* CharacterCodes._ */ || ch === 36 /* CharacterCodes.$ */) {
             // Fast path for ASCII identifiers, which also hashes the units for interning.
             let pos = (this.pos + 1) | 0;
             const end = this.end;
@@ -1472,35 +1498,47 @@ export class Scanner {
                 this.hashEnd = pos;
                 return true;
             }
-            this.pos = (start + prefixLength) | 0;
         }
+        this.pos = identifierStart;
+        const languageVariant = variant === 1 /* IdentifierVariant.JSX */ ? 1 /* LanguageVariant.JSX */ : 0 /* LanguageVariant.Standard */;
         ch = this.codePoint();
-        if (!isIdentifierStart(ch))
-            return false;
-        do {
-            this.pos = (this.pos + charSize(ch)) | 0;
-            ch = this.codePoint();
-        } while (isIdentifierPart(ch));
-        if (ch === 92 /* CharacterCodes.backslash */)
-            this.setValue(text.substring(start, this.pos) + this.scanIdentifierParts());
-        else
-            this.setValueSlice(start, this.pos);
-        return true;
+        if (isIdentifierStart(ch)) {
+            do {
+                this.pos = (this.pos + charSize(ch)) | 0;
+                ch = this.codePoint();
+            } while (isIdentifierPart(ch, languageVariant));
+            if (ch === 92 /* CharacterCodes.backslash */)
+                this.setValue(text.substring(start, this.pos) + this.scanIdentifierParts(variant));
+            else
+                this.setValueSlice(start, this.pos);
+            return true;
+        }
+        if (ch === 92 /* CharacterCodes.backslash */) {
+            const escaped = this.scanIdentifierEscape(true, variant);
+            if (escaped >= 0) {
+                const head = text.substring(start, identifierStart) + String.fromCodePoint(escaped);
+                this.setValue(head + this.scanIdentifierParts(variant));
+                return true;
+            }
+        }
+        return false;
     }
     /** Scans identifier parts including `\u` escapes and returns their cooked text. */
-    scanIdentifierParts() {
+    scanIdentifierParts(variant) {
+        const languageVariant = variant === 1 /* IdentifierVariant.JSX */ ? 1 /* LanguageVariant.JSX */ : 0 /* LanguageVariant.Standard */;
         let result = '';
         let start = this.pos;
         for (;;) {
             const ch = this.codePoint();
-            if (isIdentifierPart(ch)) {
+            if (isIdentifierPart(ch, languageVariant)) {
                 this.pos = (this.pos + charSize(ch)) | 0;
                 continue;
             }
             if (ch === 92 /* CharacterCodes.backslash */) {
-                const escaped = this.peekUnicodeEscape();
-                if (escaped >= 0 && isIdentifierPart(escaped)) {
-                    result += this.text.substring(start, this.pos) + String.fromCodePoint(this.scanUnicodeEscape(true));
+                const escapeStart = this.pos;
+                const escaped = this.scanIdentifierEscape(false, variant);
+                if (escaped >= 0) {
+                    result += this.text.substring(start, escapeStart) + String.fromCodePoint(escaped);
                     start = this.pos;
                     continue;
                 }
@@ -1509,6 +1547,37 @@ export class Scanner {
         }
         return start === this.pos ? result : result + this.text.substring(start, this.pos);
     }
+    /**
+     * At `\`: scans a `\u` escape of an identifier start (`isStart`) or part and returns its code point,
+     * or returns -1 and leaves the scanner unchanged.
+     */
+    scanIdentifierEscape(isStart, variant) {
+        const languageVariant = variant === 1 /* IdentifierVariant.JSX */ ? 1 /* LanguageVariant.JSX */ : 0 /* LanguageVariant.Standard */;
+        const escaped = this.peekUnicodeEscape();
+        if (escaped >= 0 && (isStart ? isIdentifierStart(escaped) : isIdentifierPart(escaped, languageVariant)))
+            return this.scanUnicodeEscape(true);
+        // Group names in regular expressions, in Unicode mode or not, take `\u` HexLeadSurrogate `\u`
+        // HexTrailSurrogate as part of RegExpIdentifierName (tc39/ecma262#1869), but not the braced form.
+        if (variant === 2 /* IdentifierVariant.RegExpGroupName */ &&
+            this.peek(2) !== 123 /* CharacterCodes.openBrace */ &&
+            escaped >= 0xd800 &&
+            escaped <= 0xdbff) {
+            const pos = this.pos;
+            const flags = this.tokenFlags;
+            this.scanUnicodeEscape(false);
+            if (this.peek(2) !== 123 /* CharacterCodes.openBrace */) {
+                const low = this.scanLowSurrogateEscape();
+                if (low >= 0) {
+                    const codePoint = (escaped - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+                    if (isStart ? isIdentifierStart(codePoint) : isIdentifierPart(codePoint, languageVariant))
+                        return codePoint;
+                }
+            }
+            this.pos = pos | 0;
+            this.tokenFlags = flags;
+        }
+        return -1;
+    }
     scanInvalidCharacter() {
         const size = charSize(this.codePoint());
         this.errorAt(94 /* Diagnostics.Invalid_character */, this.pos, size, noArgs);
@@ -1674,9 +1743,9 @@ export class Scanner {
                     if ((flags & 4 /* EscapeSequenceScanningFlags.RegularExpression */) !== 0 &&
                         (flags & 32 /* EscapeSequenceScanningFlags.AtomEscape */) === 0 &&
                         ch !== 48 /* CharacterCodes._0 */)
-                        this.errorAt(451 /* Diagnostics.Octal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_If_this_was_intended_as_an_escape_sequence_use_the_syntax_0_instead */, start, this.pos - start, args);
+                        this.errorAt(449 /* Diagnostics.Octal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class_If_this_was_intended_as_an_escape_sequence_use_the_syntax_0_instead */, start, this.pos - start, args);
                     else
-                        this.errorAt(402 /* Diagnostics.Octal_escape_sequences_are_not_allowed_Use_the_syntax_0 */, start, this.pos - start, args);
+                        this.errorAt(400 /* Diagnostics.Octal_escape_sequences_are_not_allowed_Use_the_syntax_0 */, start, this.pos - start, args);
                     return code;
                 }
                 return -2 /* EscapeValue.Raw */;
@@ -1687,9 +1756,9 @@ export class Scanner {
                 if ((flags & 6 /* EscapeSequenceScanningFlags.ReportInvalidEscapeErrors */) !== 0) {
                     if ((flags & 4 /* EscapeSequenceScanningFlags.RegularExpression */) !== 0 &&
                         (flags & 32 /* EscapeSequenceScanningFlags.AtomEscape */) === 0)
-                        this.errorAt(452 /* Diagnostics.Decimal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class */, start, this.pos - start, noArgs);
+                        this.errorAt(450 /* Diagnostics.Decimal_escape_sequences_and_backreferences_are_not_allowed_in_a_character_class */, start, this.pos - start, noArgs);
                     else
-                        this.errorAt(403 /* Diagnostics.Escape_sequence_0_is_not_allowed */, start, this.pos - start, [
+                        this.errorAt(401 /* Diagnostics.Escape_sequence_0_is_not_allowed */, start, this.pos - start, [
                             this.text.substring(start, this.pos),
                         ]);
                     return ch;
@@ -1720,7 +1789,7 @@ export class Scanner {
                 if (extended && (flags & 17 /* EscapeSequenceScanningFlags.AllowExtendedUnicodeEscape */) === 0) {
                     this.tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */;
                     if (reportErrors)
-                        this.errorAt(453 /* Diagnostics.Unicode_escape_sequences_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set */, start, this.pos - start, noArgs);
+                        this.errorAt(451 /* Diagnostics.Unicode_escape_sequences_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set */, start, this.pos - start, noArgs);
                 }
                 if (codePoint < 0)
                     return -2 /* EscapeValue.Raw */;
@@ -1780,7 +1849,7 @@ export class Scanner {
                     ((flags & 4 /* EscapeSequenceScanningFlags.RegularExpression */) !== 0 &&
                         (flags & 8 /* EscapeSequenceScanningFlags.AnnexB */) === 0 &&
                         isIdentifierPart(ch)))
-                    this.errorAt(450 /* Diagnostics.This_character_cannot_be_escaped_in_a_regular_expression */, start, this.pos - start, noArgs);
+                    this.errorAt(448 /* Diagnostics.This_character_cannot_be_escaped_in_a_regular_expression */, start, this.pos - start, noArgs);
                 return ch;
         }
     }
@@ -1898,7 +1967,7 @@ export class Scanner {
             this.pos = (this.pos + 1) | 0;
             if (this.char() === 95 /* CharacterCodes._ */) {
                 this.tokenFlags |= 512 /* TokenFlags.ContainsSeparator */ | 16384 /* TokenFlags.ContainsInvalidSeparator */;
-                this.errorAt(1342 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos, 1, noArgs);
+                this.errorAt(1353 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos, 1, noArgs);
                 this.pos = start | 0;
                 this.scanNumberFragment();
             }
@@ -1956,7 +2025,7 @@ export class Scanner {
         }
         const raw = this.withoutSeparators(start, end);
         if ((this.tokenFlags & 8192 /* TokenFlags.ContainsLeadingZero */) !== 0) {
-            this.errorAt(404 /* Diagnostics.Decimals_with_leading_zeros_are_not_allowed */, start, this.pos - start, noArgs);
+            this.errorAt(402 /* Diagnostics.Decimals_with_leading_zeros_are_not_allowed */, start, this.pos - start, noArgs);
             this.setValue(String(Number(raw)));
             return 8 /* SyntaxKind.NumericLiteral */;
         }
@@ -1971,7 +2040,7 @@ export class Scanner {
         }
         if (isIdentifierStart(this.codePoint())) {
             const idStart = this.pos;
-            const id = this.scanIdentifierParts();
+            const id = this.scanIdentifierParts(0 /* IdentifierVariant.Standard */);
             if (result !== 9 /* SyntaxKind.BigIntLiteral */ && id.length === 1 && this.chars[idStart] === 110 /* CharacterCodes.n */) {
                 if ((this.tokenFlags & 16 /* TokenFlags.Scientific */) !== 0) {
                     this.errorAt(286 /* Diagnostics.A_bigint_literal_cannot_use_exponential_notation */, start, this.pos - start, noArgs);
@@ -2008,9 +2077,9 @@ export class Scanner {
                 else {
                     this.tokenFlags |= 16384 /* TokenFlags.ContainsInvalidSeparator */;
                     if (isPreviousTokenSeparator)
-                        this.errorAt(1343 /* Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted */, this.pos, 1, noArgs);
+                        this.errorAt(1354 /* Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted */, this.pos, 1, noArgs);
                     else
-                        this.errorAt(1342 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos, 1, noArgs);
+                        this.errorAt(1353 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos, 1, noArgs);
                 }
             }
             else {
@@ -2020,7 +2089,7 @@ export class Scanner {
         }
         if (isPreviousTokenSeparator) {
             this.tokenFlags |= 16384 /* TokenFlags.ContainsInvalidSeparator */;
-            this.errorAt(1342 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos - 1, 1, noArgs);
+            this.errorAt(1353 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos - 1, 1, noArgs);
         }
         return count;
     }
@@ -2043,10 +2112,10 @@ export class Scanner {
                     isPreviousTokenSeparator = true;
                 }
                 else if (isPreviousTokenSeparator) {
-                    this.errorAt(1343 /* Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted */, this.pos, 1, noArgs);
+                    this.errorAt(1354 /* Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted */, this.pos, 1, noArgs);
                 }
                 else {
-                    this.errorAt(1342 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos, 1, noArgs);
+                    this.errorAt(1353 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos, 1, noArgs);
                 }
             }
             else {
@@ -2055,7 +2124,7 @@ export class Scanner {
             this.pos = (this.pos + 1) | 0;
         }
         if (isPreviousTokenSeparator)
-            this.errorAt(1342 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos - 1, 1, noArgs);
+            this.errorAt(1353 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos - 1, 1, noArgs);
         return count;
     }
     scanHexNumber() {
@@ -2257,11 +2326,11 @@ export class Scanner {
                 if (reportErrors) {
                     const flag = regularExpressionFlag(ch);
                     if (flag === 0 /* RegularExpressionFlags.None */)
-                        this.errorAt(414 /* Diagnostics.Unknown_regular_expression_flag */, p, size, noArgs);
+                        this.errorAt(412 /* Diagnostics.Unknown_regular_expression_flag */, p, size, noArgs);
                     else if ((flags & flag) !== 0)
-                        this.errorAt(415 /* Diagnostics.Duplicate_regular_expression_flag */, p, size, noArgs);
+                        this.errorAt(413 /* Diagnostics.Duplicate_regular_expression_flag */, p, size, noArgs);
                     else if (((flags | flag) & 96 /* RegularExpressionFlags.AnyUnicodeMode */) === 96 /* RegularExpressionFlags.AnyUnicodeMode */)
-                        this.errorAt(417 /* Diagnostics.The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously */, p, size, noArgs);
+                        this.errorAt(415 /* Diagnostics.The_Unicode_u_flag_and_the_Unicode_Sets_v_flag_cannot_be_set_simultaneously */, p, size, noArgs);
                     else {
                         flags |= flag;
                         this.checkRegularExpressionFlagAvailability(flag, p, size);
@@ -2297,7 +2366,7 @@ export class Scanner {
         else
             return;
         if (this.languageVersion() < availableFrom)
-            this.errorAt(416 /* Diagnostics.This_regular_expression_flag_is_only_available_when_targeting_0_or_later */, pos, size, [
+            this.errorAt(414 /* Diagnostics.This_regular_expression_flag_is_only_available_when_targeting_0_or_later */, pos, size, [
                 regularExpressionFlagName(availableFrom),
             ]);
     }
@@ -2373,18 +2442,8 @@ export class Scanner {
     scanJsxIdentifier() {
         if (!tokenIsIdentifierOrKeyword(this.token))
             return this.token;
-        let value = this.getTokenValue();
-        while (this.pos < this.end) {
-            if (this.char() === 45 /* CharacterCodes.minus */) {
-                value += '-';
-                this.pos = (this.pos + 1) | 0;
-                continue;
-            }
-            const pos = this.pos;
-            value += this.scanIdentifierParts();
-            if (this.pos === pos)
-                break;
-        }
+        // An identifier or keyword is scanned: append a following `-` and the rest of the name.
+        const value = this.getTokenValue() + this.scanIdentifierParts(1 /* IdentifierVariant.JSX */);
         this.setValue(value);
         return (this.token = getIdentifierToken(value));
     }
@@ -2455,7 +2514,6 @@ export class Scanner {
     scanJSDocToken() {
         this.fullStartPos = this.pos | 0;
         this.tokenFlags = 0 /* TokenFlags.None */;
-        const text = this.text;
         const chars = this.chars;
         if (this.pos >= this.end)
             return (this.token = 1 /* SyntaxKind.EndOfFile */);
@@ -2506,40 +2564,13 @@ export class Scanner {
                 return (this.token = 61 /* SyntaxKind.BacktickToken */);
             case 35 /* CharacterCodes.hash */:
                 return (this.token = 62 /* SyntaxKind.HashToken */);
-            case 92 /* CharacterCodes.backslash */: {
-                this.pos = (this.pos - 1) | 0;
-                const codePoint = this.peekUnicodeEscape();
-                if (codePoint >= 0 && isIdentifierStart(codePoint)) {
-                    const head = String.fromCodePoint(this.scanUnicodeEscape(true));
-                    this.setValue(head + this.scanIdentifierParts());
-                    return (this.token = getIdentifierToken(this.tokenValue));
-                }
-                this.pos = (this.pos + 1) | 0;
-                return (this.token = 0 /* SyntaxKind.Unknown */);
-            }
         }
-        if (!isIdentifierStart(ch))
-            return (this.token = 0 /* SyntaxKind.Unknown */);
-        let last = ch;
-        while (this.pos < this.end) {
-            const unit = this.chars[this.pos] | 0;
-            if (unit < 0x80) {
-                last = unit;
-                if (!isASCIIIdentifierPart(unit) && unit !== 45 /* CharacterCodes.minus */)
-                    break;
-                this.pos = (this.pos + 1) | 0;
-                continue;
-            }
-            last = this.codePointAt(this.pos, this.end);
-            if (!isIdentifierPart(last) && last !== 45 /* CharacterCodes.minus */)
-                break;
-            this.pos = (this.pos + charSize(last)) | 0;
-        }
-        if (last === 92 /* CharacterCodes.backslash */)
-            this.setValue(text.substring(this.tokenStart, this.pos) + this.scanIdentifierParts());
-        else
-            this.setValueSlice(this.tokenStart, this.pos);
-        return (this.token = this.identifierKind());
+        // JSDoc names take `-`, as JSX names do.
+        this.pos = this.tokenStart;
+        if (this.scanIdentifier(0, 1 /* IdentifierVariant.JSX */))
+            return (this.token = this.identifierKind());
+        this.pos = (this.tokenStart + charSize(ch)) | 0;
+        return (this.token = 0 /* SyntaxKind.Unknown */);
     }
 }
 const mergeConflictMarkerLength = 7;