tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/scanner.js

@@ -0,0 +1,2853 @@
+import { charSize, codePointAt, isASCIILetter, isDigit, isHexDigit, isIdentifierPart, isIdentifierStart, isLineBreak, isOctalDigit, isWhiteSpaceLike, isWhiteSpaceSingleLine, } from './character-codes.js';
+import { parsePseudoBigInt } from './pseudo-bigint.js';
+import { checkRegularExpression, regularExpressionFlag, } from './regexp-checker.js';
+import { CommentDirective, CommentRange, } from './types.js';
+export { isIdentifierPart, isIdentifierStart } from './character-codes.js';
+const textToKeyword = new Map([
+    ['abstract', 127 /* SyntaxKind.AbstractKeyword */],
+    ['accessor', 128 /* SyntaxKind.AccessorKeyword */],
+    ['any', 132 /* SyntaxKind.AnyKeyword */],
+    ['as', 129 /* SyntaxKind.AsKeyword */],
+    ['asserts', 130 /* SyntaxKind.AssertsKeyword */],
+    ['assert', 131 /* SyntaxKind.AssertKeyword */],
+    ['bigint', 163 /* SyntaxKind.BigIntKeyword */],
+    ['boolean', 135 /* SyntaxKind.BooleanKeyword */],
+    ['break', 82 /* SyntaxKind.BreakKeyword */],
+    ['case', 83 /* SyntaxKind.CaseKeyword */],
+    ['catch', 84 /* SyntaxKind.CatchKeyword */],
+    ['class', 85 /* SyntaxKind.ClassKeyword */],
+    ['continue', 87 /* SyntaxKind.ContinueKeyword */],
+    ['const', 86 /* SyntaxKind.ConstKeyword */],
+    ['constructor', 136 /* SyntaxKind.ConstructorKeyword */],
+    ['debugger', 88 /* SyntaxKind.DebuggerKeyword */],
+    ['declare', 137 /* SyntaxKind.DeclareKeyword */],
+    ['default', 89 /* SyntaxKind.DefaultKeyword */],
+    ['defer', 166 /* SyntaxKind.DeferKeyword */],
+    ['delete', 90 /* SyntaxKind.DeleteKeyword */],
+    ['do', 91 /* SyntaxKind.DoKeyword */],
+    ['else', 92 /* SyntaxKind.ElseKeyword */],
+    ['enum', 93 /* SyntaxKind.EnumKeyword */],
+    ['export', 94 /* SyntaxKind.ExportKeyword */],
+    ['extends', 95 /* SyntaxKind.ExtendsKeyword */],
+    ['false', 96 /* SyntaxKind.FalseKeyword */],
+    ['finally', 97 /* SyntaxKind.FinallyKeyword */],
+    ['for', 98 /* SyntaxKind.ForKeyword */],
+    ['from', 161 /* SyntaxKind.FromKeyword */],
+    ['function', 99 /* SyntaxKind.FunctionKeyword */],
+    ['get', 138 /* SyntaxKind.GetKeyword */],
+    ['if', 100 /* SyntaxKind.IfKeyword */],
+    ['immediate', 139 /* SyntaxKind.ImmediateKeyword */],
+    ['implements', 118 /* SyntaxKind.ImplementsKeyword */],
+    ['import', 101 /* SyntaxKind.ImportKeyword */],
+    ['in', 102 /* SyntaxKind.InKeyword */],
+    ['infer', 140 /* SyntaxKind.InferKeyword */],
+    ['instanceof', 103 /* SyntaxKind.InstanceOfKeyword */],
+    ['interface', 119 /* SyntaxKind.InterfaceKeyword */],
+    ['intrinsic', 141 /* SyntaxKind.IntrinsicKeyword */],
+    ['is', 142 /* SyntaxKind.IsKeyword */],
+    ['keyof', 143 /* SyntaxKind.KeyOfKeyword */],
+    ['let', 120 /* SyntaxKind.LetKeyword */],
+    ['module', 144 /* SyntaxKind.ModuleKeyword */],
+    ['namespace', 145 /* SyntaxKind.NamespaceKeyword */],
+    ['never', 146 /* SyntaxKind.NeverKeyword */],
+    ['new', 104 /* SyntaxKind.NewKeyword */],
+    ['null', 105 /* SyntaxKind.NullKeyword */],
+    ['number', 150 /* SyntaxKind.NumberKeyword */],
+    ['object', 151 /* SyntaxKind.ObjectKeyword */],
+    ['package', 121 /* SyntaxKind.PackageKeyword */],
+    ['private', 122 /* SyntaxKind.PrivateKeyword */],
+    ['protected', 123 /* SyntaxKind.ProtectedKeyword */],
+    ['public', 124 /* SyntaxKind.PublicKeyword */],
+    ['override', 164 /* SyntaxKind.OverrideKeyword */],
+    ['out', 147 /* SyntaxKind.OutKeyword */],
+    ['readonly', 148 /* SyntaxKind.ReadonlyKeyword */],
+    ['require', 149 /* SyntaxKind.RequireKeyword */],
+    ['global', 162 /* SyntaxKind.GlobalKeyword */],
+    ['return', 106 /* SyntaxKind.ReturnKeyword */],
+    ['satisfies', 152 /* SyntaxKind.SatisfiesKeyword */],
+    ['set', 153 /* SyntaxKind.SetKeyword */],
+    ['static', 125 /* SyntaxKind.StaticKeyword */],
+    ['string', 154 /* SyntaxKind.StringKeyword */],
+    ['super', 107 /* SyntaxKind.SuperKeyword */],
+    ['switch', 108 /* SyntaxKind.SwitchKeyword */],
+    ['symbol', 155 /* SyntaxKind.SymbolKeyword */],
+    ['this', 109 /* SyntaxKind.ThisKeyword */],
+    ['throw', 110 /* SyntaxKind.ThrowKeyword */],
+    ['true', 111 /* SyntaxKind.TrueKeyword */],
+    ['try', 112 /* SyntaxKind.TryKeyword */],
+    ['type', 156 /* SyntaxKind.TypeKeyword */],
+    ['typeof', 113 /* SyntaxKind.TypeOfKeyword */],
+    ['undefined', 157 /* SyntaxKind.UndefinedKeyword */],
+    ['unique', 158 /* SyntaxKind.UniqueKeyword */],
+    ['unknown', 159 /* SyntaxKind.UnknownKeyword */],
+    ['using', 160 /* SyntaxKind.UsingKeyword */],
+    ['var', 114 /* SyntaxKind.VarKeyword */],
+    ['void', 115 /* SyntaxKind.VoidKeyword */],
+    ['while', 116 /* SyntaxKind.WhileKeyword */],
+    ['with', 117 /* SyntaxKind.WithKeyword */],
+    ['yield', 126 /* SyntaxKind.YieldKeyword */],
+    ['async', 133 /* SyntaxKind.AsyncKeyword */],
+    ['await', 134 /* SyntaxKind.AwaitKeyword */],
+    ['of', 165 /* SyntaxKind.OfKeyword */],
+]);
+const textToToken = new Map([
+    ['{', 18 /* SyntaxKind.OpenBraceToken */],
+    ['}', 19 /* SyntaxKind.CloseBraceToken */],
+    ['(', 20 /* SyntaxKind.OpenParenToken */],
+    [')', 21 /* SyntaxKind.CloseParenToken */],
+    ['[', 22 /* SyntaxKind.OpenBracketToken */],
+    [']', 23 /* SyntaxKind.CloseBracketToken */],
+    ['.', 24 /* SyntaxKind.DotToken */],
+    ['...', 25 /* SyntaxKind.DotDotDotToken */],
+    [';', 26 /* SyntaxKind.SemicolonToken */],
+    [',', 27 /* SyntaxKind.CommaToken */],
+    ['<', 29 /* SyntaxKind.LessThanToken */],
+    ['>', 31 /* SyntaxKind.GreaterThanToken */],
+    ['<=', 32 /* SyntaxKind.LessThanEqualsToken */],
+    ['>=', 33 /* SyntaxKind.GreaterThanEqualsToken */],
+    ['==', 34 /* SyntaxKind.EqualsEqualsToken */],
+    ['!=', 35 /* SyntaxKind.ExclamationEqualsToken */],
+    ['===', 36 /* SyntaxKind.EqualsEqualsEqualsToken */],
+    ['!==', 37 /* SyntaxKind.ExclamationEqualsEqualsToken */],
+    ['=>', 38 /* SyntaxKind.EqualsGreaterThanToken */],
+    ['+', 39 /* SyntaxKind.PlusToken */],
+    ['-', 40 /* SyntaxKind.MinusToken */],
+    ['**', 42 /* SyntaxKind.AsteriskAsteriskToken */],
+    ['*', 41 /* SyntaxKind.AsteriskToken */],
+    ['/', 43 /* SyntaxKind.SlashToken */],
+    ['%', 44 /* SyntaxKind.PercentToken */],
+    ['++', 45 /* SyntaxKind.PlusPlusToken */],
+    ['--', 46 /* SyntaxKind.MinusMinusToken */],
+    ['<<', 47 /* SyntaxKind.LessThanLessThanToken */],
+    ['</', 30 /* SyntaxKind.LessThanSlashToken */],
+    ['>>', 48 /* SyntaxKind.GreaterThanGreaterThanToken */],
+    ['>>>', 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */],
+    ['&', 50 /* SyntaxKind.AmpersandToken */],
+    ['|', 51 /* SyntaxKind.BarToken */],
+    ['^', 52 /* SyntaxKind.CaretToken */],
+    ['!', 53 /* SyntaxKind.ExclamationToken */],
+    ['~', 54 /* SyntaxKind.TildeToken */],
+    ['&&', 55 /* SyntaxKind.AmpersandAmpersandToken */],
+    ['||', 56 /* SyntaxKind.BarBarToken */],
+    ['?', 57 /* SyntaxKind.QuestionToken */],
+    ['??', 60 /* SyntaxKind.QuestionQuestionToken */],
+    ['?.', 28 /* SyntaxKind.QuestionDotToken */],
+    [':', 58 /* SyntaxKind.ColonToken */],
+    ['=', 63 /* SyntaxKind.EqualsToken */],
+    ['+=', 64 /* SyntaxKind.PlusEqualsToken */],
+    ['-=', 65 /* SyntaxKind.MinusEqualsToken */],
+    ['*=', 66 /* SyntaxKind.AsteriskEqualsToken */],
+    ['**=', 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */],
+    ['/=', 68 /* SyntaxKind.SlashEqualsToken */],
+    ['%=', 69 /* SyntaxKind.PercentEqualsToken */],
+    ['<<=', 70 /* SyntaxKind.LessThanLessThanEqualsToken */],
+    ['>>=', 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */],
+    ['>>>=', 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */],
+    ['&=', 73 /* SyntaxKind.AmpersandEqualsToken */],
+    ['|=', 74 /* SyntaxKind.BarEqualsToken */],
+    ['^=', 78 /* SyntaxKind.CaretEqualsToken */],
+    ['||=', 75 /* SyntaxKind.BarBarEqualsToken */],
+    ['&&=', 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */],
+    ['??=', 77 /* SyntaxKind.QuestionQuestionEqualsToken */],
+    ['@', 59 /* SyntaxKind.AtToken */],
+    ['#', 62 /* SyntaxKind.HashToken */],
+    ['`', 61 /* SyntaxKind.BacktickToken */],
+]);
+const tokenToText = [];
+for (let kind = 0; kind <= 166 /* SyntaxKind.LastToken */; kind++)
+    tokenToText.push('');
+for (const [text, kind] of textToToken)
+    tokenToText[kind] = text;
+for (const [text, kind] of textToKeyword)
+    tokenToText[kind] = text;
+// Keywords bucketed by first letter and length, so identifiers are classified
+// without allocating their text.
+const keywordBucketStart = new Int32Array(26 * 13 + 2);
+const keywordKinds = new Uint16Array(textToKeyword.size);
+// The code units of every keyword, 12 slots each, in bucket order.
+const keywordCodeUnits = new Uint16Array(textToKeyword.size * 12);
+{
+    for (const text of textToKeyword.keys())
+        keywordBucketStart[keywordBucket(text) + 2]++;
+    for (let i = 2; i < keywordBucketStart.length; i++)
+        keywordBucketStart[i] += keywordBucketStart[i - 1];
+    for (const [text, kind] of textToKeyword) {
+        const slot = keywordBucketStart[keywordBucket(text) + 1]++;
+        keywordKinds[slot] = kind;
+        for (let j = 0; j < text.length; j++)
+            keywordCodeUnits[slot * 12 + j] = text.charCodeAt(j);
+    }
+}
+function keywordBucket(text) {
+    return (text.charCodeAt(0) - 97 /* CharacterCodes.a */) * 13 + text.length;
+}
+/** The keyword kind of the code units `chars[start, end)`, or `Identifier`. */
+function keywordKindAt(chars, start, end) {
+    const length = (end - start) | 0;
+    if (length < 2 || length > 12)
+        return 79 /* SyntaxKind.Identifier */;
+    const first = chars[start] | 0;
+    if (first < 97 /* CharacterCodes.a */ || first > 122 /* CharacterCodes.z */)
+        return 79 /* SyntaxKind.Identifier */;
+    const bucket = ((first - 97 /* CharacterCodes.a */) * 13 + length) | 0;
+    const last = keywordBucketStart[bucket + 1] | 0;
+    for (let i = keywordBucketStart[bucket] | 0; i < last; i = (i + 1) | 0) {
+        const base = (i * 12) | 0;
+        let j = 1;
+        while (j < length && (keywordCodeUnits[(base + j) | 0] | 0) === (chars[(start + j) | 0] | 0))
+            j = (j + 1) | 0;
+        if (j === length)
+            return (keywordKinds[i] | 0);
+    }
+    return 79 /* SyntaxKind.Identifier */;
+}
+/** The keyword kind of `text`, or `Identifier`. */
+export function getIdentifierToken(text) {
+    if (text.length < 2 || text.length > 12)
+        return 79 /* SyntaxKind.Identifier */;
+    const first = text.charCodeAt(0);
+    if (first < 97 /* CharacterCodes.a */ || first > 122 /* CharacterCodes.z */)
+        return 79 /* SyntaxKind.Identifier */;
+    // `| 0`: a SyntaxKind is an int32, which lets its storage stay int32.
+    return (textToKeyword.get(text) ?? 79 /* SyntaxKind.Identifier */) | 0;
+}
+/** The keyword kind of an identifier's text, or `Unknown`. */
+export function identifierToKeywordKind(text) {
+    return (textToKeyword.get(text) ?? 0 /* SyntaxKind.Unknown */) | 0;
+}
+export function tokenToString(kind) {
+    return kind >= 0 && kind < tokenToText.length ? tokenToText[kind] : '';
+}
+export function stringToToken(text) {
+    return (textToToken.get(text) ?? textToKeyword.get(text) ?? 0 /* SyntaxKind.Unknown */) | 0;
+}
+/** Keywords longer than two characters, for spelling suggestions. */
+export function getViableKeywordSuggestions() {
+    const result = [];
+    for (const text of textToKeyword.keys())
+        if (text.length > 2)
+            result.push(text);
+    return result;
+}
+export function tokenIsIdentifierOrKeyword(token) {
+    return token >= 79 /* SyntaxKind.Identifier */;
+}
+/** Whether `name` is a valid identifier (JSX names may contain `-` and `:`). */
+export function isIdentifierText(name, languageVariant = 0 /* LanguageVariant.Standard */) {
+    let ch = codePointAt(name, 0, name.length);
+    if (!isIdentifierStart(ch))
+        return false;
+    for (let i = charSize(ch); i < name.length; i += charSize(ch)) {
+        ch = codePointAt(name, i, name.length);
+        if (!isIdentifierPart(ch, languageVariant))
+            return false;
+    }
+    return true;
+}
+/** Receives scanner diagnostics. An abstract class rather than a function so native builds dispatch statically. */
+export class ScannerErrorReporter {
+}
+const noArgs = [];
+/** A snapshot of the scanner's token state for `Scanner.rewind`. */
+export class ScannerState {
+    pos;
+    fullStartPos;
+    tokenStart;
+    token;
+    tokenFlags;
+    tokenValue;
+    valueStart;
+    valueEnd;
+    commentDirectiveCount;
+    skipJSDocLeadingAsterisks;
+    constructor(pos, fullStartPos, tokenStart, token, tokenFlags, tokenValue, valueStart, valueEnd, commentDirectiveCount, skipJSDocLeadingAsterisks) {
+        this.pos = pos | 0;
+        this.fullStartPos = fullStartPos | 0;
+        this.tokenStart = tokenStart | 0;
+        this.token = token;
+        this.tokenFlags = tokenFlags;
+        this.tokenValue = tokenValue;
+        this.valueStart = valueStart | 0;
+        this.valueEnd = valueEnd | 0;
+        this.commentDirectiveCount = commentDirectiveCount;
+        this.skipJSDocLeadingAsterisks = skipJSDocLeadingAsterisks;
+    }
+    /** @internal Overwrites this snapshot with the scanner's current state, like `Scanner.mark`. */
+    assign(scanner) {
+        this.pos = scanner.pos | 0;
+        this.fullStartPos = scanner.fullStartPos;
+        this.tokenStart = scanner.tokenStart;
+        this.token = scanner.token;
+        this.tokenFlags = scanner.tokenFlags;
+        this.tokenValue = scanner.tokenValue;
+        this.valueStart = scanner.valueStart;
+        this.valueEnd = scanner.valueEnd;
+        this.commentDirectiveCount = scanner.commentDirectives.length;
+        this.skipJSDocLeadingAsterisks = scanner.skipJSDocLeadingAsterisks;
+    }
+}
+/**
+ * `[A-Za-z0-9_$]`, for an int32 code unit. The scanner's hot loops test this inline rather than
+ * calling `isWordCharacter`, whose parameter native builds keep as a double.
+ */
+function isASCIIIdentifierPart(c) {
+    return ((c >= 97 /* CharacterCodes.a */ && c <= 122 /* CharacterCodes.z */) ||
+        (c >= 65 /* CharacterCodes.A */ && c <= 90 /* CharacterCodes.Z */) ||
+        (c >= 48 /* CharacterCodes._0 */ && c <= 57 /* CharacterCodes._9 */) ||
+        c === 95 /* CharacterCodes._ */ ||
+        c === 36 /* CharacterCodes.$ */);
+}
+/** FNV-1a over a range's code units. The identifier scan computes the same hash as it goes. */
+function rangeHash(chars, start, end) {
+    let hash = 0x811c9dc5 | 0;
+    for (let i = start | 0; i < end; i = (i + 1) | 0)
+        hash = Math.imul(hash ^ (chars[i] | 0), 0x01000193);
+    return finishHash(hash);
+}
+function finishHash(hash) {
+    return hash ^ (hash >>> 15);
+}
+/** Strings for ranges of one text, keyed by their code units: equal identifiers share one string. */
+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;
+    count;
+    // Per entry: 1 once its text was recorded among the file's identifier texts (`markRecorded`).
+    recorded;
+    // The entry the last `intern` returned.
+    lastEntry;
+    constructor(text) {
+        this.text = text;
+        this.slots = new Int32Array(512);
+        this.lengths = new Int32Array(128);
+        this.texts = [];
+        this.count = 0;
+        this.recorded = new Uint8Array(128);
+        this.lastEntry = -1;
+    }
+    /**
+     * 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.
+     */
+    markRecorded(text) {
+        const entry = this.lastEntry;
+        if (entry < 0 || this.texts[entry] !== 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;
+    }
+    /**
+     * `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.
+     */
+    intern(start, end, hash) {
+        start = start | 0;
+        end = end | 0;
+        hash = hash | 0;
+        const length = (end - start) | 0;
+        const slots = this.slots;
+        const mask = ((slots.length >> 1) - 1) | 0;
+        let slot = hash & mask;
+        for (;;) {
+            const entry = slots[(slot * 2) | 0] | 0;
+            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;
+                }
+            }
+            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);
+            lengths.set(this.lengths);
+            this.lengths = lengths;
+            const recorded = new Uint8Array(index * 2);
+            recorded.set(this.recorded);
+            this.recorded = recorded;
+        }
+        this.lengths[index] = length;
+        this.texts.push(value);
+        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;
+    }
+}
+/** `IdentifierTable` slots in a table twice the size. */
+function rehash(old) {
+    const slots = new Int32Array(old.length * 2);
+    const mask = slots.length / 2 - 1;
+    for (let i = 0; i < old.length; i += 2) {
+        const entry = old[i];
+        if (entry === 0)
+            continue;
+        const hash = old[i + 1];
+        let slot = hash & mask;
+        while (slots[slot * 2] !== 0)
+            slot = (slot + 1) & mask;
+        slots[slot * 2] = entry;
+        slots[slot * 2 + 1] = hash;
+    }
+    return slots;
+}
+/**
+ * The code units a scanner with code units on demand copies at a time: few enough that the comments
+ * of a large declaration file copy a small part of it, enough that a file whose comments are all
+ * parsed is copied in a few hundred writes.
+ */
+const unitBlockSize = 1024;
+function isLowSurrogate(ch) {
+    return ch >= 0xdc00 && ch <= 0xdfff;
+}
+/** The UTF-16 code units of `text`, followed by zeros so the scanner can peek past the end. */
+function toCodeUnits(text) {
+    const chars = new Uint16Array(text.length + 4);
+    Buffer.from(chars.buffer).write(text, 'utf16le');
+    return chars;
+}
+// The two loops below scan long runs. They index `chars` from `pos` on an int32 counter, which
+// native builds compile to an integer loop without allocating a view.
+/** The position of the next `` ` ``, `$`, `\\` or CR at or after `pos`, or `end`. */
+function skipTemplateText(chars, pos, end) {
+    for (let i = pos | 0; i < end; i = (i + 1) | 0) {
+        const c = chars[i] | 0;
+        if (c === 96 /* CharacterCodes.backtick */ ||
+            c === 36 /* CharacterCodes.$ */ ||
+            c === 92 /* CharacterCodes.backslash */ ||
+            c === 13 /* CharacterCodes.carriageReturn */)
+            return i;
+    }
+    return end;
+}
+/** The position of the next `*`, `@`, line break or non-ASCII unit at or after `pos`, or `end`. */
+function skipCommentText(chars, pos, end) {
+    for (let i = pos | 0; i < end; i = (i + 1) | 0) {
+        const c = chars[i] | 0;
+        if (c === 42 /* CharacterCodes.asterisk */ ||
+            c === 64 /* CharacterCodes.at */ ||
+            c === 10 /* CharacterCodes.lineFeed */ ||
+            c === 13 /* CharacterCodes.carriageReturn */ ||
+            c > 127 /* CharacterCodes.maxAsciiCharacter */)
+            return i;
+    }
+    return end;
+}
+function hasPrefixAt(text, pos, prefix) {
+    if (pos + prefix.length > text.length)
+        return false;
+    for (let i = 0; i < prefix.length; i++)
+        if (text.charCodeAt(pos + i) !== prefix.charCodeAt(i))
+            return false;
+    return true;
+}
+/** Whether `chars[pos, end)` starts with `tag` followed by whitespace, `}`, `*` or `end`. */
+function hasJSDocTag(chars, pos, end, tag) {
+    const tagEnd = pos + tag.length;
+    if (tagEnd > end)
+        return false;
+    for (let i = 0; i < tag.length; i++)
+        if (chars[pos + i] !== tag.charCodeAt(i))
+            return false;
+    if (tagEnd === end)
+        return true;
+    const ch = chars[tagEnd];
+    return (ch === 32 /* CharacterCodes.space */ ||
+        ch === 9 /* CharacterCodes.tab */ ||
+        ch === 10 /* CharacterCodes.lineFeed */ ||
+        ch === 13 /* CharacterCodes.carriageReturn */ ||
+        ch === 125 /* CharacterCodes.closeBrace */ ||
+        ch === 42 /* CharacterCodes.asterisk */);
+}
+/** Adds the `@deprecated` and `@see`/`@link` flags for a JSDoc tag name at `pos`. */
+function jsDocTagFlags(chars, pos, end, flags) {
+    if ((flags & 131072 /* TokenFlags.PrecedingJSDocWithDeprecated */) === 0 && hasJSDocTag(chars, pos, end, 'deprecated'))
+        flags |= 131072 /* TokenFlags.PrecedingJSDocWithDeprecated */;
+    if ((flags & 262144 /* TokenFlags.PrecedingJSDocWithSeeOrLink */) === 0 &&
+        (hasJSDocTag(chars, pos, end, 'see') ||
+            hasJSDocTag(chars, pos, end, 'link') ||
+            hasJSDocTag(chars, pos, end, 'linkcode') ||
+            hasJSDocTag(chars, pos, end, 'linkplain')))
+        flags |= 262144 /* TokenFlags.PrecedingJSDocWithSeeOrLink */;
+    return flags;
+}
+function hexByte(value) {
+    const hex = value.toString(16);
+    return hex.length < 2 ? '\\x0' + hex : '\\x' + hex;
+}
+function regularExpressionFlagName(target) {
+    switch (target) {
+        case 5 /* ScriptTarget.ES2018 */:
+            return 'es2018';
+        case 9 /* ScriptTarget.ES2022 */:
+            return 'es2022';
+        default:
+            return 'es2024';
+    }
+}
+/**
+ * Tokenizes TypeScript and JavaScript source text. Positions are UTF-16 offsets.
+ *
+ * ```ts
+ * const scanner = new Scanner();
+ * scanner.setText(text);
+ * while (scanner.scan() !== SyntaxKind.EndOfFile) console.log(scanner.getTokenText());
+ * ```
+ */
+export class Scanner {
+    /** @internal */ text;
+    // The text's UTF-16 code units: indexing a typed array is much cheaper than
+    // `charCodeAt` on large native strings.
+    /** @internal */ chars;
+    /** @internal */ end;
+    languageVariant;
+    scriptTarget;
+    onError;
+    skipTrivia;
+    // Writes of the token offsets below are coerced with `| 0` where the compiler can't bound the
+    // value, so native builds store them as 32-bit integers. `pos` too: every write (also in the
+    // regular expression checker) is `(pos + n) | 0` or an int32 value, never `++` or `+=`, and hot
+    // loops copy it into an int32 local and read code units as `chars[i] | 0`, so they run on
+    // integers instead of doubles. Positions stay far below 2^31, so `| 0` never changes a value.
+    /** @internal Current position; the end of the current token. */
+    pos;
+    /** @internal */ fullStartPos;
+    /** @internal */ tokenStart;
+    /** @internal */ token;
+    /** @internal */ tokenFlags;
+    // The token value is `text[valueStart, valueEnd)` while `valueStart >= 0`,
+    // so identifiers and keywords don't allocate until their value is read.
+    /** @internal */ tokenValue;
+    /** @internal */ valueStart;
+    /** @internal */ valueEnd;
+    // `rangeHash` of `chars[hashStart, hashEnd)`, which the ASCII identifier scan computes as it goes.
+    valueHash;
+    hashStart;
+    hashEnd;
+    /** @internal */ commentDirectives;
+    /** @internal */ skipJSDocLeadingAsterisks;
+    // The code units zeroed by `setTextEnd`.
+    cutUnits;
+    identifiers;
+    // With code units on demand: per block of `unitBlockSize` code units, 1 once `chars` holds them
+    // (`loadUnits`); `chars` is zero elsewhere.
+    loadedBlocks;
+    // The line breaks the text holds, computed on first use.
+    textKind;
+    // The first LF and CR at or after `lineFeedFrom` and `carriageReturnFrom`: `lineFeedAt` and
+    // `carriageReturnAt` (the text length where there is none), found by `nextLineFeed` and
+    // `nextCarriageReturn`. -1 for none found yet.
+    lineFeedFrom;
+    lineFeedAt;
+    carriageReturnFrom;
+    carriageReturnAt;
+    /**
+     * With `unitsOnDemand`, the code units of the text are copied only for the ranges passed to
+     * `loadUnits`, for scanning a few ranges of a large text.
+     */
+    constructor(text = '', unitsOnDemand = false) {
+        this.text = text;
+        if (unitsOnDemand) {
+            this.chars = new Uint16Array(text.length + 4);
+            this.loadedBlocks = new Uint8Array(((text.length + unitBlockSize - 1) / unitBlockSize) | 0);
+        }
+        else {
+            this.chars = toCodeUnits(text);
+            this.loadedBlocks = undefined;
+        }
+        this.end = text.length | 0;
+        this.languageVariant = 0 /* LanguageVariant.Standard */;
+        this.scriptTarget = 0 /* ScriptTarget.None */;
+        this.onError = undefined;
+        this.skipTrivia = true;
+        this.pos = 0;
+        this.fullStartPos = 0;
+        this.tokenStart = 0;
+        this.token = 0 /* SyntaxKind.Unknown */;
+        this.tokenFlags = 0 /* TokenFlags.None */;
+        this.tokenValue = '';
+        this.valueStart = -1;
+        this.valueEnd = -1;
+        this.valueHash = 0;
+        this.hashStart = -1;
+        this.hashEnd = -1;
+        this.commentDirectives = [];
+        this.skipJSDocLeadingAsterisks = 0;
+        this.cutUnits = new Uint16Array(4);
+        this.identifiers = new IdentifierTable(text);
+        this.textKind = 0 /* TextKind.Unknown */;
+        this.lineFeedFrom = -1;
+        this.lineFeedAt = -1;
+        this.carriageReturnFrom = -1;
+        this.carriageReturnAt = -1;
+    }
+    /** Sets the text to scan and resets the token state. */
+    setText(text) {
+        this.text = text;
+        this.chars = toCodeUnits(text);
+        this.loadedBlocks = undefined;
+        this.identifiers.setText(text);
+        this.textKind = 0 /* TextKind.Unknown */;
+        this.lineFeedFrom = -1;
+        this.lineFeedAt = -1;
+        this.carriageReturnFrom = -1;
+        this.carriageReturnAt = -1;
+        this.end = text.length | 0;
+        this.pos = 0;
+        this.fullStartPos = 0;
+        this.tokenStart = 0;
+        this.token = 0 /* SyntaxKind.Unknown */;
+        this.tokenFlags = 0 /* TokenFlags.None */;
+        this.tokenValue = '';
+        this.valueStart = -1;
+        this.hashStart = -1;
+        this.commentDirectives = [];
+        this.skipJSDocLeadingAsterisks = 0;
+    }
+    /** @internal Like `setText(text.substring(0, end))` without copying, but keeps comment directives; pass the text length to undo. */
+    setTextEnd(end) {
+        const chars = this.chars;
+        const cut = this.cutUnits;
+        // Restore the units zeroed by the previous call, then zero the units past `end`.
+        if (this.end < this.text.length)
+            for (let i = 0; i < 4; i++)
+                chars[this.end + i] = cut[i];
+        if (end < this.text.length)
+            for (let i = 0; i < 4; i++) {
+                cut[i] = chars[end + i];
+                chars[end + i] = 0;
+            }
+        this.end = end | 0;
+        this.pos = 0;
+        this.fullStartPos = 0;
+        this.tokenStart = 0;
+        this.token = 0 /* SyntaxKind.Unknown */;
+        this.tokenFlags = 0 /* TokenFlags.None */;
+        this.tokenValue = '';
+        this.valueStart = -1;
+        this.hashStart = -1;
+        this.skipJSDocLeadingAsterisks = 0;
+    }
+    /**
+     * @internal Where the scanner copies code units on demand, copies those of `text[start, end)`
+     * and the four around each end, a block of `unitBlockSize` units at a time (and whole surrogate
+     * pairs); otherwise does nothing.
+     */
+    loadUnits(start, end) {
+        const blocks = this.loadedBlocks;
+        if (blocks === undefined)
+            return;
+        const text = this.text;
+        const length = text.length;
+        const last = Math.min(blocks.length - 1, ((end + 4) / unitBlockSize) | 0);
+        for (let block = (Math.max(0, start - 4) / unitBlockSize) | 0; block <= last; block++) {
+            if (blocks[block] !== 0)
+                continue;
+            // The run of blocks not copied yet.
+            let runEnd = block;
+            while (runEnd < last && blocks[runEnd + 1] === 0)
+                runEnd++;
+            let from = block * unitBlockSize;
+            let to = Math.min(length, (runEnd + 1) * unitBlockSize);
+            if (from > 0 && isLowSurrogate(text.charCodeAt(from)))
+                from--;
+            if (to < length && isLowSurrogate(text.charCodeAt(to)))
+                to++;
+            Buffer.from(this.chars.buffer, from * 2, (to - from) * 2).write(text.substring(from, to), 'utf16le');
+            blocks.fill(1, block, runEnd + 1);
+            block = runEnd;
+        }
+    }
+    setOnError(reporter) {
+        this.onError = reporter;
+    }
+    setLanguageVariant(languageVariant) {
+        this.languageVariant = languageVariant;
+    }
+    setScriptTarget(scriptTarget) {
+        this.scriptTarget = scriptTarget;
+    }
+    /** When false, `scan` returns whitespace, newline and comment trivia tokens. */
+    setSkipTrivia(skip) {
+        this.skipTrivia = skip;
+    }
+    /** Nests skipping of JSDoc leading `*` after line breaks; balance every `true` with a `false`. */
+    setSkipJSDocLeadingAsterisks(skip) {
+        this.skipJSDocLeadingAsterisks += skip ? 1 : -1;
+    }
+    getText() {
+        return this.text;
+    }
+    getToken() {
+        return this.token;
+    }
+    getTokenFlags() {
+        return this.tokenFlags;
+    }
+    /** Start of the token including leading trivia. */
+    getTokenFullStart() {
+        return this.fullStartPos;
+    }
+    getTokenStart() {
+        return this.tokenStart;
+    }
+    getTokenEnd() {
+        return this.pos;
+    }
+    getTokenText() {
+        return this.text.substring(this.tokenStart, this.pos);
+    }
+    /** The cooked value: identifier text, string contents, normalized number, etc. */
+    getTokenValue() {
+        if (this.valueStart >= 0) {
+            this.tokenValue = this.text.substring(this.valueStart, this.valueEnd);
+            this.valueStart = -1;
+        }
+        return this.tokenValue;
+    }
+    /**
+     * Whether `text`, the identifier value just returned by `getIdentifierValue`, is the first of its
+     * file to be recorded; files record each identifier text once.
+     */
+    recordIdentifierValue(text) {
+        return this.identifiers.markRecorded(text);
+    }
+    /** @internal Like `getTokenValue`, but identifiers with the same text share one string. */
+    getIdentifierValue() {
+        const start = this.valueStart;
+        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);
+            this.valueStart = -1;
+        }
+        return this.tokenValue;
+    }
+    getCommentDirectives() {
+        return this.commentDirectives;
+    }
+    hasUnicodeEscape() {
+        return (this.tokenFlags & 1024 /* TokenFlags.UnicodeEscape */) !== 0;
+    }
+    hasExtendedUnicodeEscape() {
+        return (this.tokenFlags & 8 /* TokenFlags.ExtendedUnicodeEscape */) !== 0;
+    }
+    hasPrecedingLineBreak() {
+        return (this.tokenFlags & 1 /* TokenFlags.PrecedingLineBreak */) !== 0;
+    }
+    hasPrecedingJSDocComment() {
+        return (this.tokenFlags & 2 /* TokenFlags.PrecedingJSDocComment */) !== 0;
+    }
+    hasPrecedingJSDocLeadingAsterisks() {
+        return (this.tokenFlags & 32768 /* TokenFlags.PrecedingJSDocLeadingAsterisks */) !== 0;
+    }
+    hasPrecedingJSDocWithDeprecatedTag() {
+        return (this.tokenFlags & 131072 /* TokenFlags.PrecedingJSDocWithDeprecated */) !== 0;
+    }
+    hasPrecedingJSDocWithSeeOrLink() {
+        return (this.tokenFlags & 262144 /* TokenFlags.PrecedingJSDocWithSeeOrLink */) !== 0;
+    }
+    isUnterminated() {
+        return (this.tokenFlags & 4 /* TokenFlags.Unterminated */) !== 0;
+    }
+    mark() {
+        return new ScannerState(this.pos, this.fullStartPos, this.tokenStart, this.token, this.tokenFlags, this.tokenValue, this.valueStart, this.valueEnd, this.commentDirectives.length, this.skipJSDocLeadingAsterisks);
+    }
+    rewind(state) {
+        this.pos = state.pos;
+        this.fullStartPos = state.fullStartPos;
+        this.tokenStart = state.tokenStart;
+        this.token = state.token;
+        this.tokenFlags = state.tokenFlags;
+        this.tokenValue = state.tokenValue;
+        this.valueStart = state.valueStart;
+        this.valueEnd = state.valueEnd;
+        while (this.commentDirectives.length > state.commentDirectiveCount)
+            this.commentDirectives.pop();
+        this.skipJSDocLeadingAsterisks = state.skipJSDocLeadingAsterisks;
+    }
+    /** Runs `callback` and restores the scanner state afterwards. */
+    lookAhead(callback) {
+        const state = this.mark();
+        const result = callback();
+        this.rewind(state);
+        return result;
+    }
+    /** Runs `callback` and restores the scanner state if it returns `undefined`. */
+    tryScan(callback) {
+        const state = this.mark();
+        const result = callback();
+        if (result === undefined)
+            this.rewind(state);
+        return result;
+    }
+    /** Moves to `pos` without changing the current token. */
+    resetPos(pos) {
+        if (pos < 0)
+            throw new Error('Cannot reset token state to negative position');
+        this.pos = pos | 0;
+        this.fullStartPos = pos | 0;
+        this.tokenStart = pos | 0;
+    }
+    resetTokenState(pos) {
+        this.resetPos(pos);
+        this.token = 0 /* SyntaxKind.Unknown */;
+        this.tokenValue = '';
+        this.valueStart = -1;
+        this.tokenFlags = 0 /* TokenFlags.None */;
+    }
+    /** @internal */
+    languageVersion() {
+        return this.scriptTarget === 0 /* ScriptTarget.None */ ? 99 /* ScriptTarget.Latest */ : this.scriptTarget;
+    }
+    error(message) {
+        this.errorAt(message, this.pos, 0, noArgs);
+    }
+    /** @internal */
+    errorAt(message, start, length, args) {
+        if (this.onError !== undefined)
+            this.onError.onError(message, start, length, args);
+    }
+    /** @internal The code unit at `pos`, or -1 at the end. */
+    char() {
+        return this.pos < this.end ? this.chars[this.pos] | 0 : -1 /* CharacterCodes.EOF */;
+    }
+    /** @internal The code unit at `pos + offset`, or -1 past the end. */
+    peek(offset) {
+        const at = (this.pos + offset) | 0;
+        return at < this.end ? this.chars[at] | 0 : -1 /* CharacterCodes.EOF */;
+    }
+    /** @internal The code point at `pos`, or -1 at the end. */
+    codePoint() {
+        return this.codePointAt(this.pos, this.end);
+    }
+    /** @internal The code point at `pos`, combining a surrogate pair; -1 at or past `end`. */
+    codePointAt(pos, end) {
+        if (pos >= end)
+            return -1 /* CharacterCodes.EOF */;
+        const chars = this.chars;
+        const ch = chars[pos] | 0;
+        if (ch >= 0xd800 && ch <= 0xdbff && pos + 1 < end) {
+            const low = chars[pos + 1] | 0;
+            if (low >= 0xdc00 && low <= 0xdfff)
+                return (ch - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+        }
+        return ch;
+    }
+    /** The code point ending just before `pos`; -1 at the start. */
+    codePointBefore(pos) {
+        if (pos <= 0)
+            return -1 /* CharacterCodes.EOF */;
+        const ch = this.chars[pos - 1] | 0;
+        if (ch >= 0xdc00 && ch <= 0xdfff && pos >= 2) {
+            const high = this.chars[pos - 2] | 0;
+            if (high >= 0xd800 && high <= 0xdbff)
+                return (high - 0xd800) * 0x400 + (ch - 0xdc00) + 0x10000;
+        }
+        return ch;
+    }
+    setValue(value) {
+        this.tokenValue = value;
+        this.valueStart = -1;
+    }
+    setValueSlice(start, end) {
+        this.valueStart = start | 0;
+        this.valueEnd = end | 0;
+    }
+    scan() {
+        // `chars` is zero-padded, so peeking a few units past the end is safe.
+        const chars = this.chars;
+        this.fullStartPos = this.pos | 0;
+        this.tokenFlags = 0 /* TokenFlags.None */;
+        for (;;) {
+            const ch = this.pos < this.end ? chars[this.pos] | 0 : -1 /* CharacterCodes.EOF */;
+            this.tokenStart = this.pos | 0;
+            switch (ch) {
+                case 9 /* CharacterCodes.tab */:
+                case 11 /* CharacterCodes.verticalTab */:
+                case 12 /* CharacterCodes.formFeed */:
+                case 32 /* CharacterCodes.space */:
+                    if (this.skipTrivia) {
+                        let pos = (this.pos + 1) | 0;
+                        const end = this.end;
+                        while (pos < end) {
+                            const c = chars[pos] | 0;
+                            if (c !== 32 /* CharacterCodes.space */ && c !== 9 /* CharacterCodes.tab */)
+                                break;
+                            pos = (pos + 1) | 0;
+                        }
+                        this.pos = pos;
+                        continue;
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    while (this.pos < this.end && isWhiteSpaceSingleLine(chars[this.pos] | 0))
+                        this.pos = (this.pos + 1) | 0;
+                    return (this.token = 5 /* SyntaxKind.WhitespaceTrivia */);
+                case 10 /* CharacterCodes.lineFeed */:
+                case 13 /* CharacterCodes.carriageReturn */:
+                    this.tokenFlags |= 1 /* TokenFlags.PrecedingLineBreak */;
+                    if (this.skipTrivia) {
+                        let pos = (this.pos + 1) | 0;
+                        const end = this.end;
+                        while (pos < end) {
+                            const c = chars[pos] | 0;
+                            if (c !== 32 /* CharacterCodes.space */ && (c < 9 /* CharacterCodes.tab */ || c > 13 /* CharacterCodes.carriageReturn */))
+                                break;
+                            pos = (pos + 1) | 0;
+                        }
+                        this.pos = pos;
+                        continue;
+                    }
+                    this.pos =
+                        (this.pos +
+                            (ch === 13 /* CharacterCodes.carriageReturn */ && (chars[this.pos + 1] | 0) === 10 /* CharacterCodes.lineFeed */ ? 2 : 1)) |
+                            0;
+                    return (this.token = 4 /* SyntaxKind.NewLineTrivia */);
+                case 33 /* CharacterCodes.exclamation */:
+                    if ((chars[this.pos + 1] | 0) === 61 /* CharacterCodes.equals */) {
+                        if ((chars[this.pos + 2] | 0) === 61 /* CharacterCodes.equals */) {
+                            this.pos = (this.pos + 3) | 0;
+                            return (this.token = 37 /* SyntaxKind.ExclamationEqualsEqualsToken */);
+                        }
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 35 /* SyntaxKind.ExclamationEqualsToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 53 /* SyntaxKind.ExclamationToken */);
+                case 34 /* CharacterCodes.doubleQuote */:
+                case 39 /* CharacterCodes.singleQuote */:
+                    this.scanString(false);
+                    return (this.token = 10 /* SyntaxKind.StringLiteral */);
+                case 96 /* CharacterCodes.backtick */:
+                    return (this.token = this.scanTemplateAndSetTokenValue(false));
+                case 37 /* CharacterCodes.percent */:
+                    if ((chars[this.pos + 1] | 0) === 61 /* CharacterCodes.equals */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 69 /* SyntaxKind.PercentEqualsToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 44 /* SyntaxKind.PercentToken */);
+                case 38 /* CharacterCodes.ampersand */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (next === 38 /* CharacterCodes.ampersand */) {
+                        if ((chars[this.pos + 2] | 0) === 61 /* CharacterCodes.equals */) {
+                            this.pos = (this.pos + 3) | 0;
+                            return (this.token = 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */);
+                        }
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 55 /* SyntaxKind.AmpersandAmpersandToken */);
+                    }
+                    if (next === 61 /* CharacterCodes.equals */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 73 /* SyntaxKind.AmpersandEqualsToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 50 /* SyntaxKind.AmpersandToken */);
+                }
+                case 40 /* CharacterCodes.openParen */:
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 20 /* SyntaxKind.OpenParenToken */);
+                case 41 /* CharacterCodes.closeParen */:
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 21 /* SyntaxKind.CloseParenToken */);
+                case 42 /* CharacterCodes.asterisk */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (next === 61 /* CharacterCodes.equals */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 66 /* SyntaxKind.AsteriskEqualsToken */);
+                    }
+                    if (next === 42 /* CharacterCodes.asterisk */) {
+                        if ((chars[this.pos + 2] | 0) === 61 /* CharacterCodes.equals */) {
+                            this.pos = (this.pos + 3) | 0;
+                            return (this.token = 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */);
+                        }
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 42 /* SyntaxKind.AsteriskAsteriskToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    if (this.skipJSDocLeadingAsterisks !== 0 &&
+                        (this.tokenFlags & 32768 /* TokenFlags.PrecedingJSDocLeadingAsterisks */) === 0 &&
+                        (this.tokenFlags & 1 /* TokenFlags.PrecedingLineBreak */) !== 0) {
+                        this.tokenFlags |= 32768 /* TokenFlags.PrecedingJSDocLeadingAsterisks */;
+                        continue;
+                    }
+                    return (this.token = 41 /* SyntaxKind.AsteriskToken */);
+                }
+                case 43 /* CharacterCodes.plus */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (next === 61 /* CharacterCodes.equals */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 64 /* SyntaxKind.PlusEqualsToken */);
+                    }
+                    if (next === 43 /* CharacterCodes.plus */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 45 /* SyntaxKind.PlusPlusToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 39 /* SyntaxKind.PlusToken */);
+                }
+                case 44 /* CharacterCodes.comma */:
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 27 /* SyntaxKind.CommaToken */);
+                case 45 /* CharacterCodes.minus */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (next === 61 /* CharacterCodes.equals */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 65 /* SyntaxKind.MinusEqualsToken */);
+                    }
+                    if (next === 45 /* CharacterCodes.minus */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 46 /* SyntaxKind.MinusMinusToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 40 /* SyntaxKind.MinusToken */);
+                }
+                case 46 /* CharacterCodes.dot */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (isDigit(next))
+                        return (this.token = this.scanNumber());
+                    if (next === 46 /* CharacterCodes.dot */ && (chars[this.pos + 2] | 0) === 46 /* CharacterCodes.dot */) {
+                        this.pos = (this.pos + 3) | 0;
+                        return (this.token = 25 /* SyntaxKind.DotDotDotToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 24 /* SyntaxKind.DotToken */);
+                }
+                case 47 /* CharacterCodes.slash */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (next === 47 /* CharacterCodes.slash */) {
+                        const pos = this.lineCommentEnd((this.pos + 2) | 0);
+                        this.pos = pos;
+                        this.processCommentDirective(this.tokenStart, pos, false);
+                        if (this.skipTrivia)
+                            continue;
+                        return (this.token = 2 /* SyntaxKind.SingleLineCommentTrivia */);
+                    }
+                    if (next === 42 /* CharacterCodes.asterisk */) {
+                        if (this.scanMultiLineComment())
+                            continue;
+                        return (this.token = 3 /* SyntaxKind.MultiLineCommentTrivia */);
+                    }
+                    if (next === 61 /* CharacterCodes.equals */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 68 /* SyntaxKind.SlashEqualsToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 43 /* SyntaxKind.SlashToken */);
+                }
+                case 48 /* CharacterCodes._0 */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (next === 88 /* CharacterCodes.X */ || next === 120 /* CharacterCodes.x */)
+                        return (this.token = this.scanHexNumber());
+                    if (next === 66 /* CharacterCodes.B */ || next === 98 /* CharacterCodes.b */)
+                        return (this.token = this.scanBinaryOrOctalNumber(2));
+                    if (next === 79 /* CharacterCodes.O */ || next === 111 /* CharacterCodes.o */)
+                        return (this.token = this.scanBinaryOrOctalNumber(8));
+                    return (this.token = this.scanNumber());
+                }
+                case 49 /* CharacterCodes._1 */:
+                case 50 /* CharacterCodes._2 */:
+                case 51 /* CharacterCodes._3 */:
+                case 52 /* CharacterCodes._4 */:
+                case 53 /* CharacterCodes._5 */:
+                case 54 /* CharacterCodes._6 */:
+                case 55 /* CharacterCodes._7 */:
+                case 56 /* CharacterCodes._8 */:
+                case 57 /* CharacterCodes._9 */:
+                    return (this.token = this.scanNumber());
+                case 58 /* CharacterCodes.colon */:
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 58 /* SyntaxKind.ColonToken */);
+                case 59 /* CharacterCodes.semicolon */:
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 26 /* SyntaxKind.SemicolonToken */);
+                case 60 /* CharacterCodes.lessThan */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (next === 60 /* CharacterCodes.lessThan */ && isConflictMarkerTrivia(this.text, this.pos)) {
+                        if (this.scanConflictMarker())
+                            continue;
+                        return (this.token = 6 /* SyntaxKind.ConflictMarkerTrivia */);
+                    }
+                    if (next === 60 /* CharacterCodes.lessThan */) {
+                        if ((chars[this.pos + 2] | 0) === 61 /* CharacterCodes.equals */) {
+                            this.pos = (this.pos + 3) | 0;
+                            return (this.token = 70 /* SyntaxKind.LessThanLessThanEqualsToken */);
+                        }
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 47 /* SyntaxKind.LessThanLessThanToken */);
+                    }
+                    if (next === 61 /* CharacterCodes.equals */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 32 /* SyntaxKind.LessThanEqualsToken */);
+                    }
+                    if (this.languageVariant === 1 /* LanguageVariant.JSX */ &&
+                        next === 47 /* CharacterCodes.slash */ &&
+                        (chars[this.pos + 2] | 0) !== 42 /* CharacterCodes.asterisk */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 30 /* SyntaxKind.LessThanSlashToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 29 /* SyntaxKind.LessThanToken */);
+                }
+                case 61 /* CharacterCodes.equals */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (next === 61 /* CharacterCodes.equals */ && isConflictMarkerTrivia(this.text, this.pos)) {
+                        if (this.scanConflictMarker())
+                            continue;
+                        return (this.token = 6 /* SyntaxKind.ConflictMarkerTrivia */);
+                    }
+                    if (next === 61 /* CharacterCodes.equals */) {
+                        if ((chars[this.pos + 2] | 0) === 61 /* CharacterCodes.equals */) {
+                            this.pos = (this.pos + 3) | 0;
+                            return (this.token = 36 /* SyntaxKind.EqualsEqualsEqualsToken */);
+                        }
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 34 /* SyntaxKind.EqualsEqualsToken */);
+                    }
+                    if (next === 62 /* CharacterCodes.greaterThan */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 38 /* SyntaxKind.EqualsGreaterThanToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 63 /* SyntaxKind.EqualsToken */);
+                }
+                case 62 /* CharacterCodes.greaterThan */:
+                    if ((chars[this.pos + 1] | 0) === 62 /* CharacterCodes.greaterThan */ && isConflictMarkerTrivia(this.text, this.pos)) {
+                        if (this.scanConflictMarker())
+                            continue;
+                        return (this.token = 6 /* SyntaxKind.ConflictMarkerTrivia */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 31 /* SyntaxKind.GreaterThanToken */);
+                case 63 /* CharacterCodes.question */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (next === 46 /* CharacterCodes.dot */ && !isDigit(chars[this.pos + 2] | 0)) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 28 /* SyntaxKind.QuestionDotToken */);
+                    }
+                    if (next === 63 /* CharacterCodes.question */) {
+                        if ((chars[this.pos + 2] | 0) === 61 /* CharacterCodes.equals */) {
+                            this.pos = (this.pos + 3) | 0;
+                            return (this.token = 77 /* SyntaxKind.QuestionQuestionEqualsToken */);
+                        }
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 60 /* SyntaxKind.QuestionQuestionToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 57 /* SyntaxKind.QuestionToken */);
+                }
+                case 91 /* CharacterCodes.openBracket */:
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 22 /* SyntaxKind.OpenBracketToken */);
+                case 93 /* CharacterCodes.closeBracket */:
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 23 /* SyntaxKind.CloseBracketToken */);
+                case 94 /* CharacterCodes.caret */:
+                    if ((chars[this.pos + 1] | 0) === 61 /* CharacterCodes.equals */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 78 /* SyntaxKind.CaretEqualsToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 52 /* SyntaxKind.CaretToken */);
+                case 123 /* CharacterCodes.openBrace */:
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 18 /* SyntaxKind.OpenBraceToken */);
+                case 124 /* CharacterCodes.bar */: {
+                    const next = chars[this.pos + 1] | 0;
+                    if (next === 124 /* CharacterCodes.bar */ && isConflictMarkerTrivia(this.text, this.pos)) {
+                        if (this.scanConflictMarker())
+                            continue;
+                        return (this.token = 6 /* SyntaxKind.ConflictMarkerTrivia */);
+                    }
+                    if (next === 124 /* CharacterCodes.bar */) {
+                        if ((chars[this.pos + 2] | 0) === 61 /* CharacterCodes.equals */) {
+                            this.pos = (this.pos + 3) | 0;
+                            return (this.token = 75 /* SyntaxKind.BarBarEqualsToken */);
+                        }
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 56 /* SyntaxKind.BarBarToken */);
+                    }
+                    if (next === 61 /* CharacterCodes.equals */) {
+                        this.pos = (this.pos + 2) | 0;
+                        return (this.token = 74 /* SyntaxKind.BarEqualsToken */);
+                    }
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 51 /* SyntaxKind.BarToken */);
+                }
+                case 125 /* CharacterCodes.closeBrace */:
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 19 /* SyntaxKind.CloseBraceToken */);
+                case 126 /* CharacterCodes.tilde */:
+                    this.pos = (this.pos + 1) | 0;
+                    return (this.token = 54 /* SyntaxKind.TildeToken */);
+                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());
+                        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;
+                        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)) {
+                        this.errorAt(94 /* Diagnostics.Invalid_character */, this.pos - 1, 1, noArgs);
+                        this.setValue('#');
+                    }
+                    return (this.token = 80 /* SyntaxKind.PrivateIdentifier */);
+                default: {
+                    if (ch < 0)
+                        return (this.token = 1 /* SyntaxKind.EndOfFile */);
+                    if (this.scanIdentifier(0))
+                        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.pos = this.end;
+                        return (this.token = 7 /* SyntaxKind.NonTextFileMarkerTrivia */);
+                    }
+                    if (isWhiteSpaceSingleLine(codePoint)) {
+                        this.pos = (this.pos + 1) | 0;
+                        if (codePoint === 133 /* CharacterCodes.nextLine */ || this.skipTrivia)
+                            continue;
+                        while (this.pos < this.end && isWhiteSpaceSingleLine(chars[this.pos] | 0))
+                            this.pos = (this.pos + 1) | 0;
+                        return (this.token = 5 /* SyntaxKind.WhitespaceTrivia */);
+                    }
+                    if (isLineBreak(codePoint)) {
+                        this.tokenFlags |= 1 /* TokenFlags.PrecedingLineBreak */;
+                        this.pos = (this.pos + 1) | 0;
+                        continue;
+                    }
+                    return this.scanInvalidCharacter();
+                }
+            }
+        }
+    }
+    /** The kind of the identifier just scanned by `scanIdentifier`. */
+    identifierKind() {
+        return this.valueStart >= 0
+            ? keywordKindAt(this.chars, this.valueStart, this.valueEnd)
+            : getIdentifierToken(this.tokenValue);
+    }
+    /** The line breaks the text holds, found once per text. */
+    getTextKind() {
+        let kind = this.textKind;
+        if (kind === 0 /* TextKind.Unknown */) {
+            const text = this.text;
+            // Natively, the UTF-8 length is known without a search, and ASCII texts hold no separators.
+            if (Buffer.byteLength(text, 'utf8') !== text.length &&
+                (text.indexOf('\u2028') >= 0 || text.indexOf('\u2029') >= 0))
+                kind = 3 /* TextKind.Separators */;
+            else
+                kind = text.indexOf('\r') >= 0 ? 2 /* TextKind.LFAndCR */ : 1 /* TextKind.LF */;
+            this.textKind = kind;
+        }
+        return kind;
+    }
+    /**
+     * The end of the line comment whose text starts at `pos`: the next line break, or `end`. Found with
+     * string searches (natively, byte searches) instead of a loop over code units, except in texts with
+     * line or paragraph separators.
+     */
+    lineCommentEnd(pos) {
+        const end = this.end;
+        const kind = this.getTextKind();
+        if (kind !== 3 /* TextKind.Separators */) {
+            let at = this.nextLineFeed(pos);
+            if (kind === 2 /* TextKind.LFAndCR */)
+                at = Math.min(at, this.nextCarriageReturn(pos));
+            return at > end ? end : at | 0;
+        }
+        const chars = this.chars;
+        while (pos < end && !isLineBreak(chars[pos] | 0))
+            pos = (pos + 1) | 0;
+        return pos;
+    }
+    /**
+     * The position of the first LF at or after `pos`, or the text length. The last result is kept: as
+     * the scanner moves forward each search starts where the previous one ended, so a text with few
+     * LFs (CR line breaks) is not searched to its end once per line comment.
+     */
+    nextLineFeed(pos) {
+        if (pos >= this.lineFeedFrom && pos <= this.lineFeedAt)
+            return this.lineFeedAt;
+        const text = this.text;
+        const at = text.indexOf('\n', pos);
+        this.lineFeedFrom = pos;
+        this.lineFeedAt = at < 0 ? text.length : at;
+        return this.lineFeedAt;
+    }
+    /** Like `nextLineFeed`, for CR: a text with LF line breaks and few CRs is searched once. */
+    nextCarriageReturn(pos) {
+        if (pos >= this.carriageReturnFrom && pos <= this.carriageReturnAt)
+            return this.carriageReturnAt;
+        const text = this.text;
+        const at = text.indexOf('\r', pos);
+        this.carriageReturnFrom = pos;
+        this.carriageReturnAt = at < 0 ? text.length : at;
+        return this.carriageReturnAt;
+    }
+    /** Scans `/* … *\/`; returns true if the comment is skipped as trivia. */
+    scanMultiLineComment() {
+        const chars = this.chars;
+        const end = this.end;
+        let pos = (this.pos + 2) | 0;
+        const isJSDoc = pos < end && (chars[pos] | 0) === 42 /* CharacterCodes.asterisk */ && (chars[pos + 1] | 0) !== 47 /* CharacterCodes.slash */;
+        let closed = false;
+        let lastLineStart = this.tokenStart;
+        let flags = this.tokenFlags;
+        if (isJSDoc)
+            flags |= 2 /* TokenFlags.PrecedingJSDocComment */;
+        const kind = this.getTextKind();
+        if (kind !== 3 /* TextKind.Separators */) {
+            // String searches for the closing `*/`, then for the line breaks and JSDoc tags in the comment,
+            // instead of a loop over code units; not in texts with line or paragraph separators.
+            const text = this.text;
+            const close = text.indexOf('*/', pos);
+            closed = close >= 0 && close + 2 <= end;
+            const bodyEnd = closed ? close : end;
+            if (pos < bodyEnd) {
+                const body = text.substring(pos, bodyEnd);
+                // A forward search first: most comments have no line break, and searching back is slower.
+                let lastBreak = body.indexOf('\n') >= 0 ? body.lastIndexOf('\n') : -1;
+                if (kind === 2 /* TextKind.LFAndCR */ && body.indexOf('\r') >= 0)
+                    lastBreak = Math.max(lastBreak, body.lastIndexOf('\r'));
+                if (lastBreak >= 0) {
+                    lastLineStart = (pos + lastBreak + 1) | 0;
+                    flags |= 1 /* TokenFlags.PrecedingLineBreak */;
+                }
+                if (isJSDoc)
+                    for (let at = body.indexOf('@'); at >= 0; at = body.indexOf('@', at + 1))
+                        flags = jsDocTagFlags(chars, pos + at + 1, end, flags);
+            }
+            pos = closed ? (close + 2) | 0 : end;
+        }
+        else {
+            while (pos < end) {
+                pos = skipCommentText(chars, pos, end) | 0;
+                if (pos >= end)
+                    break;
+                const c = chars[pos] | 0;
+                pos = (pos + 1) | 0;
+                if (c === 42 /* CharacterCodes.asterisk */) {
+                    if ((chars[pos] | 0) === 47 /* CharacterCodes.slash */) {
+                        pos = (pos + 1) | 0;
+                        closed = true;
+                        break;
+                    }
+                }
+                else if (c === 10 /* CharacterCodes.lineFeed */ || c === 13 /* CharacterCodes.carriageReturn */ || c >= 0x2028) {
+                    if (isLineBreak(c)) {
+                        lastLineStart = pos;
+                        flags |= 1 /* TokenFlags.PrecedingLineBreak */;
+                    }
+                }
+                else if (c === 64 /* CharacterCodes.at */ && isJSDoc) {
+                    flags = jsDocTagFlags(chars, pos, end, flags);
+                }
+            }
+        }
+        this.pos = pos;
+        this.tokenFlags = flags;
+        this.processCommentDirective(lastLineStart, pos, true);
+        if (!closed)
+            this.error(6 /* Diagnostics.Asterisk_Slash_expected */);
+        if (this.skipTrivia)
+            return true;
+        if (!closed)
+            this.tokenFlags |= 4 /* TokenFlags.Unterminated */;
+        return false;
+    }
+    /** Scans a merge conflict marker; returns true if it is skipped as trivia. */
+    scanConflictMarker() {
+        this.pos = scanConflictMarkerTrivia(this.text, this.pos, this) | 0;
+        return this.skipTrivia;
+    }
+    processCommentDirective(start, end, multiline) {
+        const text = this.text;
+        const chars = this.chars;
+        let pos = start;
+        if (multiline) {
+            while (pos < end && (chars[pos] === 32 /* CharacterCodes.space */ || chars[pos] === 9 /* CharacterCodes.tab */))
+                pos++;
+            while (pos < end && (chars[pos] === 47 /* CharacterCodes.slash */ || chars[pos] === 42 /* CharacterCodes.asterisk */))
+                pos++;
+        }
+        else {
+            pos += 2;
+            while (pos < end && chars[pos] === 47 /* CharacterCodes.slash */)
+                pos++;
+        }
+        while (pos < end && (chars[pos] === 32 /* CharacterCodes.space */ || chars[pos] === 9 /* CharacterCodes.tab */))
+            pos++;
+        if (!(pos < end && chars[pos] === 64 /* CharacterCodes.at */))
+            return;
+        pos++;
+        let kind;
+        if (hasPrefixAt(text, pos, 'ts-expect-error'))
+            kind = 1 /* CommentDirectiveKind.ExpectError */;
+        else if (hasPrefixAt(text, pos, 'ts-ignore'))
+            kind = 2 /* CommentDirectiveKind.Ignore */;
+        else
+            return;
+        this.commentDirectives.push(new CommentDirective(start, end, kind));
+    }
+    /** @internal Scans an identifier after `prefixLength` units; sets the token value. */
+    scanIdentifier(prefixLength) {
+        const text = this.text;
+        const chars = this.chars;
+        const start = this.pos;
+        this.pos = (this.pos + prefixLength) | 0;
+        let ch = this.char();
+        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;
+            // The FNV-1a offset basis, as in `rangeHash` (a literal: native builds load module constants).
+            let hash = 0x811c9dc5 | 0;
+            for (let i = start; i < pos; i = (i + 1) | 0)
+                hash = Math.imul(hash ^ (chars[i] | 0), 0x01000193);
+            while (pos < end) {
+                const c = chars[pos] | 0;
+                if (!isASCIIIdentifierPart(c))
+                    break;
+                hash = Math.imul(hash ^ c, 0x01000193);
+                pos = (pos + 1) | 0;
+            }
+            this.pos = pos;
+            ch = pos < end ? chars[pos] | 0 : -1 /* CharacterCodes.EOF */;
+            if (ch <= 127 /* CharacterCodes.maxAsciiCharacter */ && ch !== 92 /* CharacterCodes.backslash */) {
+                this.setValueSlice(start, pos);
+                this.valueHash = finishHash(hash);
+                this.hashStart = start;
+                this.hashEnd = pos;
+                return true;
+            }
+            this.pos = (start + prefixLength) | 0;
+        }
+        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;
+    }
+    /** Scans identifier parts including `\u` escapes and returns their cooked text. */
+    scanIdentifierParts() {
+        let result = '';
+        let start = this.pos;
+        for (;;) {
+            const ch = this.codePoint();
+            if (isIdentifierPart(ch)) {
+                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));
+                    start = this.pos;
+                    continue;
+                }
+            }
+            break;
+        }
+        return start === this.pos ? result : result + this.text.substring(start, this.pos);
+    }
+    scanInvalidCharacter() {
+        const size = charSize(this.codePoint());
+        this.errorAt(94 /* Diagnostics.Invalid_character */, this.pos, size, noArgs);
+        this.pos = (this.pos + size) | 0;
+        return (this.token = 0 /* SyntaxKind.Unknown */);
+    }
+    /** Scans a quoted string and sets its cooked value. */
+    scanString(jsxAttributeString) {
+        const text = this.text;
+        const chars = this.chars;
+        const quote = this.char();
+        if (quote === 39 /* CharacterCodes.singleQuote */)
+            this.tokenFlags |= 65536 /* TokenFlags.SingleQuote */;
+        let start = (this.pos + 1) | 0;
+        // Fast path: no escapes or line breaks before the closing quote.
+        let pos = start;
+        const end = this.end;
+        while (pos < end) {
+            const ch = chars[pos] | 0;
+            if (ch === quote) {
+                this.setValueSlice(start, pos);
+                this.pos = (pos + 1) | 0;
+                return;
+            }
+            if (!jsxAttributeString &&
+                (ch === 92 /* CharacterCodes.backslash */ || ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */))
+                break;
+            pos = (pos + 1) | 0;
+        }
+        this.pos = pos;
+        let result = '';
+        for (;;) {
+            const ch = this.char();
+            if (ch < 0) {
+                result += text.substring(start, this.pos);
+                this.tokenFlags |= 4 /* TokenFlags.Unterminated */;
+                this.error(0 /* Diagnostics.Unterminated_string_literal */);
+                break;
+            }
+            if (ch === quote) {
+                result += text.substring(start, this.pos);
+                this.pos = (this.pos + 1) | 0;
+                break;
+            }
+            if (ch === 92 /* CharacterCodes.backslash */ && !jsxAttributeString) {
+                result += text.substring(start, this.pos);
+                result += this.scanEscapeSequence(1 /* EscapeSequenceScanningFlags.String */ | 2 /* EscapeSequenceScanningFlags.ReportErrors */);
+                start = this.pos;
+                continue;
+            }
+            if ((ch === 10 /* CharacterCodes.lineFeed */ || ch === 13 /* CharacterCodes.carriageReturn */) && !jsxAttributeString) {
+                result += text.substring(start, this.pos);
+                this.tokenFlags |= 4 /* TokenFlags.Unterminated */;
+                this.error(0 /* Diagnostics.Unterminated_string_literal */);
+                break;
+            }
+            this.pos = (this.pos + 1) | 0;
+        }
+        this.setValue(result);
+    }
+    /** Scans a template literal part starting at `` ` `` or `}`. */
+    scanTemplateAndSetTokenValue(shouldEmitInvalidEscapeError) {
+        const text = this.text;
+        const chars = this.chars;
+        const end = this.end;
+        const startedWithBacktick = this.char() === 96 /* CharacterCodes.backtick */;
+        let start = this.pos + 1;
+        let pos = start;
+        // The value is `text[start, pos)` unless escapes or CRs make it `cooked`.
+        let cooked = false;
+        let result = '';
+        let token = 0 /* SyntaxKind.Unknown */;
+        for (;;) {
+            pos = skipTemplateText(chars, pos, end);
+            const ch = pos < end ? chars[pos] : -1 /* CharacterCodes.EOF */;
+            if (ch < 0 || ch === 96 /* CharacterCodes.backtick */) {
+                this.pos = pos | 0;
+                if (ch === 96 /* CharacterCodes.backtick */) {
+                    this.pos = (this.pos + 1) | 0;
+                }
+                else {
+                    this.tokenFlags |= 4 /* TokenFlags.Unterminated */;
+                    this.error(117 /* Diagnostics.Unterminated_template_literal */);
+                }
+                token = startedWithBacktick ? 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */ : 17 /* SyntaxKind.TemplateTail */;
+                break;
+            }
+            if (ch === 36 /* CharacterCodes.$ */) {
+                if (chars[pos + 1] !== 123 /* CharacterCodes.openBrace */) {
+                    pos++;
+                    continue;
+                }
+                this.pos = (pos + 2) | 0;
+                token = startedWithBacktick ? 15 /* SyntaxKind.TemplateHead */ : 16 /* SyntaxKind.TemplateMiddle */;
+                break;
+            }
+            result += text.substring(start, pos);
+            cooked = true;
+            if (ch === 92 /* CharacterCodes.backslash */) {
+                this.pos = pos | 0;
+                result += this.scanEscapeSequence(shouldEmitInvalidEscapeError
+                    ? 1 /* EscapeSequenceScanningFlags.String */ | 2 /* EscapeSequenceScanningFlags.ReportErrors */
+                    : 1 /* EscapeSequenceScanningFlags.String */);
+                pos = this.pos;
+            }
+            else {
+                // <CR><LF> and <CR> are normalized to <LF> in template values.
+                result += '\n';
+                pos++;
+                if (pos < end && chars[pos] === 10 /* CharacterCodes.lineFeed */)
+                    pos++;
+            }
+            start = pos;
+        }
+        if (cooked)
+            this.setValue(result + text.substring(start, pos));
+        else
+            this.setValueSlice(start, pos);
+        return token;
+    }
+    /** Scans an escape sequence at `\` and returns its cooked value. */
+    scanEscapeSequence(flags) {
+        const start = this.pos;
+        const value = this.scanEscapeCodePoint(flags);
+        if (value >= 0)
+            return String.fromCodePoint(value);
+        return value === -1 /* EscapeValue.Empty */ ? '' : this.text.substring(start, this.pos);
+    }
+    /**
+     * @internal Scans an escape sequence at `\`. Returns its code point, `EscapeValue.Empty`
+     * for a line continuation, or `EscapeValue.Raw` when the value is the escape's own text.
+     */
+    scanEscapeCodePoint(flags) {
+        const start = this.pos;
+        this.pos = (this.pos + 1) | 0;
+        let ch = this.char();
+        if (ch < 0) {
+            this.error(93 /* Diagnostics.Unexpected_end_of_text */);
+            return -1 /* EscapeValue.Empty */;
+        }
+        this.pos = (this.pos + 1) | 0;
+        switch (ch) {
+            case 48 /* CharacterCodes._0 */:
+            case 49 /* CharacterCodes._1 */:
+            case 50 /* CharacterCodes._2 */:
+            case 51 /* CharacterCodes._3 */:
+            case 52 /* CharacterCodes._4 */:
+            case 53 /* CharacterCodes._5 */:
+            case 54 /* CharacterCodes._6 */:
+            case 55 /* CharacterCodes._7 */: {
+                // '\0' not followed by a digit is the null character; '\08' is '\0' + '8'.
+                if (ch === 48 /* CharacterCodes._0 */ && !isDigit(this.char()))
+                    return 0;
+                // '\1', '\17', '\177', but '\4', '\47' and not '\477'.
+                if (ch <= 51 /* CharacterCodes._3 */ && isOctalDigit(this.char()))
+                    this.pos = (this.pos + 1) | 0;
+                if (isOctalDigit(this.char()))
+                    this.pos = (this.pos + 1) | 0;
+                this.tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */;
+                if ((flags & 6 /* EscapeSequenceScanningFlags.ReportInvalidEscapeErrors */) !== 0) {
+                    const code = parseInt(this.text.substring(start + 1, this.pos), 8);
+                    const args = [hexByte(code)];
+                    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);
+                    else
+                        this.errorAt(402 /* Diagnostics.Octal_escape_sequences_are_not_allowed_Use_the_syntax_0 */, start, this.pos - start, args);
+                    return code;
+                }
+                return -2 /* EscapeValue.Raw */;
+            }
+            case 56 /* CharacterCodes._8 */:
+            case 57 /* CharacterCodes._9 */:
+                this.tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */;
+                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);
+                    else
+                        this.errorAt(403 /* Diagnostics.Escape_sequence_0_is_not_allowed */, start, this.pos - start, [
+                            this.text.substring(start, this.pos),
+                        ]);
+                    return ch;
+                }
+                return -2 /* EscapeValue.Raw */;
+            case 98 /* CharacterCodes.b */:
+                return 8 /* CharacterCodes.backspace */;
+            case 116 /* CharacterCodes.t */:
+                return 9 /* CharacterCodes.tab */;
+            case 110 /* CharacterCodes.n */:
+                return 10 /* CharacterCodes.lineFeed */;
+            case 118 /* CharacterCodes.v */:
+                return 11 /* CharacterCodes.verticalTab */;
+            case 102 /* CharacterCodes.f */:
+                return 12 /* CharacterCodes.formFeed */;
+            case 114 /* CharacterCodes.r */:
+                return 13 /* CharacterCodes.carriageReturn */;
+            case 39 /* CharacterCodes.singleQuote */:
+                return 39 /* CharacterCodes.singleQuote */;
+            case 34 /* CharacterCodes.doubleQuote */:
+                return 34 /* CharacterCodes.doubleQuote */;
+            case 117 /* CharacterCodes.u */: {
+                // '\uDDDD' and '\u{DDDDDD}'
+                const extended = this.char() === 123 /* CharacterCodes.openBrace */;
+                this.pos = (this.pos - 2) | 0;
+                const reportErrors = (flags & 6 /* EscapeSequenceScanningFlags.ReportInvalidEscapeErrors */) !== 0;
+                const codePoint = this.scanUnicodeEscape(reportErrors);
+                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);
+                }
+                if (codePoint < 0)
+                    return -2 /* EscapeValue.Raw */;
+                // In any-Unicode regular expressions, '\uHigh\uLow' is one code point.
+                if (!extended &&
+                    (flags & 4 /* EscapeSequenceScanningFlags.RegularExpression */) !== 0 &&
+                    (flags & 16 /* EscapeSequenceScanningFlags.AnyUnicodeMode */) !== 0 &&
+                    codePoint >= 0xd800 &&
+                    codePoint <= 0xdbff &&
+                    this.char() === 92 /* CharacterCodes.backslash */ &&
+                    this.peek(1) === 117 /* CharacterCodes.u */ &&
+                    this.peek(2) !== 123 /* CharacterCodes.openBrace */) {
+                    const savedPos = this.pos;
+                    const low = this.scanUnicodeEscape(reportErrors);
+                    if (low >= 0xdc00 && low <= 0xdfff)
+                        return (codePoint - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+                    this.pos = savedPos | 0;
+                }
+                // In strings, a high surrogate escape joins a following low surrogate escape.
+                if ((flags & 4 /* EscapeSequenceScanningFlags.RegularExpression */) === 0 &&
+                    codePoint >= 0xd800 &&
+                    codePoint <= 0xdbff) {
+                    const low = this.scanLowSurrogateEscape();
+                    if (low >= 0)
+                        return (codePoint - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+                }
+                return codePoint;
+            }
+            case 120 /* CharacterCodes.x */:
+                // '\xDD'
+                for (; this.pos < start + 4; this.pos = (this.pos + 1) | 0) {
+                    if (!isHexDigit(this.char())) {
+                        this.tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */;
+                        if ((flags & 6 /* EscapeSequenceScanningFlags.ReportInvalidEscapeErrors */) !== 0)
+                            this.error(92 /* Diagnostics.Hexadecimal_digit_expected */);
+                        return -2 /* EscapeValue.Raw */;
+                    }
+                }
+                this.tokenFlags |= 4096 /* TokenFlags.HexEscape */;
+                return parseInt(this.text.substring(start + 2, this.pos), 16);
+            case 13 /* CharacterCodes.carriageReturn */:
+                // A line continuation is the empty code unit sequence.
+                if (this.char() === 10 /* CharacterCodes.lineFeed */)
+                    this.pos = (this.pos + 1) | 0;
+                return -1 /* EscapeValue.Empty */;
+            case 10 /* CharacterCodes.lineFeed */:
+            case 8232 /* CharacterCodes.lineSeparator */:
+            case 8233 /* CharacterCodes.paragraphSeparator */:
+                return -1 /* EscapeValue.Empty */;
+            default:
+                if (ch >= 0xd800 && ch <= 0xdbff) {
+                    this.pos = (this.pos - 1) | 0;
+                    ch = this.codePoint();
+                    this.pos = (this.pos + charSize(ch)) | 0;
+                }
+                if ((flags & 16 /* EscapeSequenceScanningFlags.AnyUnicodeMode */) !== 0 ||
+                    ((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);
+                return ch;
+        }
+    }
+    /** After a high surrogate escape: the low surrogate of a following `\u` escape, or -1. */
+    scanLowSurrogateEscape() {
+        if (this.char() !== 92 /* CharacterCodes.backslash */ || this.peek(1) !== 117 /* CharacterCodes.u */)
+            return -1;
+        const pos = this.pos;
+        const flags = this.tokenFlags;
+        // Errors are reported when the escape is scanned again on its own.
+        const low = this.scanUnicodeEscape(false);
+        if (low >= 0xdc00 && low <= 0xdfff)
+            return low;
+        this.pos = pos | 0;
+        this.tokenFlags = flags;
+        return -1;
+    }
+    /** Scans `\uXXXX` or `\u{X…}` at `pos`; returns the code point or -1 if invalid. */
+    scanUnicodeEscape(shouldEmitInvalidEscapeError) {
+        this.pos = (this.pos + 2) | 0;
+        const start = this.pos;
+        const extended = this.char() === 123 /* CharacterCodes.openBrace */;
+        let value;
+        if (extended) {
+            this.pos = (this.pos + 1) | 0;
+            value = this.scanHexValue(1, true);
+        }
+        else {
+            this.tokenFlags |= 1024 /* TokenFlags.UnicodeEscape */;
+            value = this.scanHexValue(4, false);
+        }
+        if (value < 0) {
+            this.tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */;
+            if (shouldEmitInvalidEscapeError)
+                this.error(92 /* Diagnostics.Hexadecimal_digit_expected */);
+            return -1;
+        }
+        if (extended) {
+            let invalid = false;
+            if (value > 0x10ffff) {
+                if (shouldEmitInvalidEscapeError)
+                    this.errorAt(154 /* Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive */, start + 1, this.pos - start - 1, noArgs);
+                invalid = true;
+            }
+            if (this.pos >= this.end) {
+                if (shouldEmitInvalidEscapeError)
+                    this.error(93 /* Diagnostics.Unexpected_end_of_text */);
+                invalid = true;
+            }
+            else if (this.char() === 125 /* CharacterCodes.closeBrace */) {
+                this.pos = (this.pos + 1) | 0;
+            }
+            else {
+                if (shouldEmitInvalidEscapeError)
+                    this.error(155 /* Diagnostics.Unterminated_Unicode_escape_sequence */);
+                invalid = true;
+            }
+            if (invalid) {
+                this.tokenFlags |= 2048 /* TokenFlags.ContainsInvalidEscape */;
+                return -1;
+            }
+            this.tokenFlags |= 8 /* TokenFlags.ExtendedUnicodeEscape */;
+        }
+        return value;
+    }
+    /** At `\`: the code point of a following `\u` escape, or -1. Leaves the scanner unchanged. */
+    peekUnicodeEscape() {
+        if (this.peek(1) !== 117 /* CharacterCodes.u */)
+            return -1;
+        const pos = this.pos;
+        const flags = this.tokenFlags;
+        const codePoint = this.scanUnicodeEscape(false);
+        this.pos = pos | 0;
+        this.tokenFlags = flags;
+        return codePoint;
+    }
+    /** Scans hex digits (no separators) and returns their value, or -1 if fewer than `minCount`. */
+    scanHexValue(minCount, scanAsManyAsPossible) {
+        let count = 0;
+        let value = 0;
+        while (count < minCount || scanAsManyAsPossible) {
+            const ch = this.char();
+            let digit;
+            if (ch >= 48 /* CharacterCodes._0 */ && ch <= 57 /* CharacterCodes._9 */)
+                digit = ch - 48 /* CharacterCodes._0 */;
+            else if (ch >= 65 /* CharacterCodes.A */ && ch <= 70 /* CharacterCodes.F */)
+                digit = ch - 65 /* CharacterCodes.A */ + 10;
+            else if (ch >= 97 /* CharacterCodes.a */ && ch <= 102 /* CharacterCodes.f */)
+                digit = ch - 97 /* CharacterCodes.a */ + 10;
+            else
+                break;
+            value = value * 16 + digit;
+            count++;
+            this.pos = (this.pos + 1) | 0;
+        }
+        return count < minCount ? -1 : value;
+    }
+    /** `text[start, end)` without numeric separators. */
+    withoutSeparators(start, end) {
+        if ((this.tokenFlags & 512 /* TokenFlags.ContainsSeparator */) === 0)
+            return this.text.substring(start, end);
+        let result = '';
+        let from = start;
+        for (let i = start; i < end; i++) {
+            if (this.chars[i] !== 95 /* CharacterCodes._ */)
+                continue;
+            result += this.text.substring(from, i);
+            from = i + 1;
+        }
+        return result + this.text.substring(from, end);
+    }
+    scanNumber() {
+        let start = this.pos;
+        if (this.char() === 48 /* CharacterCodes._0 */) {
+            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.pos = start | 0;
+                this.scanNumberFragment();
+            }
+            else {
+                const digitsStart = this.pos;
+                let isOctal = true;
+                while (isDigit(this.char())) {
+                    if (!isOctalDigit(this.char()))
+                        isOctal = false;
+                    this.pos = (this.pos + 1) | 0;
+                }
+                if (this.pos > digitsStart && isOctal) {
+                    // Legacy octal literal, e.g. `0777`.
+                    const value = parseInt(this.text.substring(digitsStart, this.pos), 8);
+                    this.setValue(String(value));
+                    this.tokenFlags |= 32 /* TokenFlags.Octal */;
+                    const withMinus = this.token === 40 /* SyntaxKind.MinusToken */;
+                    const literal = (withMinus ? '-0o' : '0o') + value.toString(8);
+                    if (withMinus)
+                        start--;
+                    this.errorAt(89 /* Diagnostics.Octal_literals_are_not_allowed_Use_the_syntax_0 */, start, this.pos - start, [literal]);
+                    return 8 /* SyntaxKind.NumericLiteral */;
+                }
+                if (this.pos > digitsStart)
+                    this.tokenFlags |= 8192 /* TokenFlags.ContainsLeadingZero */;
+            }
+        }
+        else {
+            this.scanNumberFragment();
+        }
+        const fixedPartEnd = this.pos;
+        if (this.char() === 46 /* CharacterCodes.dot */) {
+            this.pos = (this.pos + 1) | 0;
+            this.scanNumberFragment();
+        }
+        let end = this.pos;
+        if (this.char() === 69 /* CharacterCodes.E */ || this.char() === 101 /* CharacterCodes.e */) {
+            this.pos = (this.pos + 1) | 0;
+            this.tokenFlags |= 16 /* TokenFlags.Scientific */;
+            if (this.char() === 43 /* CharacterCodes.plus */ || this.char() === 45 /* CharacterCodes.minus */)
+                this.pos = (this.pos + 1) | 0;
+            if (this.scanNumberFragment() === 0)
+                this.error(91 /* Diagnostics.Digit_expected */);
+            else
+                end = this.pos;
+        }
+        // Integers of up to 15 digits without separators are already canonical.
+        if (fixedPartEnd === this.pos &&
+            this.pos - start <= 15 &&
+            (this.tokenFlags & (512 /* TokenFlags.ContainsSeparator */ | 8192 /* TokenFlags.ContainsLeadingZero */)) === 0 &&
+            this.chars[this.pos] !== 110 /* CharacterCodes.n */) {
+            this.setValueSlice(start, this.pos);
+            if (!isIdentifierStart(this.codePoint()))
+                return 8 /* SyntaxKind.NumericLiteral */;
+        }
+        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.setValue(String(Number(raw)));
+            return 8 /* SyntaxKind.NumericLiteral */;
+        }
+        let result;
+        if (fixedPartEnd === this.pos) {
+            this.setValue(raw);
+            result = this.scanBigIntSuffix();
+        }
+        else {
+            this.setValue(String(Number(raw)));
+            result = 8 /* SyntaxKind.NumericLiteral */;
+        }
+        if (isIdentifierStart(this.codePoint())) {
+            const idStart = this.pos;
+            const id = this.scanIdentifierParts();
+            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);
+                    return result;
+                }
+                if (fixedPartEnd < idStart) {
+                    this.errorAt(287 /* Diagnostics.A_bigint_literal_must_be_an_integer */, start, this.pos - start, noArgs);
+                    return result;
+                }
+            }
+            this.errorAt(285 /* Diagnostics.An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal */, idStart, this.pos - idStart, noArgs);
+            this.pos = idStart | 0;
+        }
+        return result;
+    }
+    /** Scans decimal digits with numeric separators; returns how many digits. */
+    scanNumberFragment() {
+        let count = 0;
+        let allowSeparator = false;
+        let isPreviousTokenSeparator = false;
+        for (;;) {
+            const ch = this.char();
+            if (isDigit(ch)) {
+                allowSeparator = true;
+                isPreviousTokenSeparator = false;
+                count++;
+            }
+            else if (ch === 95 /* CharacterCodes._ */) {
+                this.tokenFlags |= 512 /* TokenFlags.ContainsSeparator */;
+                if (allowSeparator) {
+                    allowSeparator = false;
+                    isPreviousTokenSeparator = true;
+                }
+                else {
+                    this.tokenFlags |= 16384 /* TokenFlags.ContainsInvalidSeparator */;
+                    if (isPreviousTokenSeparator)
+                        this.errorAt(1343 /* 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);
+                }
+            }
+            else {
+                break;
+            }
+            this.pos = (this.pos + 1) | 0;
+        }
+        if (isPreviousTokenSeparator) {
+            this.tokenFlags |= 16384 /* TokenFlags.ContainsInvalidSeparator */;
+            this.errorAt(1342 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos - 1, 1, noArgs);
+        }
+        return count;
+    }
+    /** Scans digits of a `0x`, `0b` or `0o` literal (allowing separators); returns how many. */
+    scanSpecifierDigits(base) {
+        let count = 0;
+        let allowSeparator = false;
+        let isPreviousTokenSeparator = false;
+        for (;;) {
+            const ch = this.char();
+            if (base === 16 ? isHexDigit(ch) : isDigit(ch) && ch - 48 /* CharacterCodes._0 */ < base) {
+                allowSeparator = true;
+                isPreviousTokenSeparator = false;
+                count++;
+            }
+            else if (ch === 95 /* CharacterCodes._ */) {
+                this.tokenFlags |= 512 /* TokenFlags.ContainsSeparator */;
+                if (allowSeparator) {
+                    allowSeparator = false;
+                    isPreviousTokenSeparator = true;
+                }
+                else if (isPreviousTokenSeparator) {
+                    this.errorAt(1343 /* 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);
+                }
+            }
+            else {
+                break;
+            }
+            this.pos = (this.pos + 1) | 0;
+        }
+        if (isPreviousTokenSeparator)
+            this.errorAt(1342 /* Diagnostics.Numeric_separators_are_not_allowed_here */, this.pos - 1, 1, noArgs);
+        return count;
+    }
+    scanHexNumber() {
+        this.pos = (this.pos + 2) | 0;
+        const digitsStart = this.pos;
+        let digits;
+        if (this.scanSpecifierDigits(16) === 0) {
+            this.error(92 /* Diagnostics.Hexadecimal_digit_expected */);
+            digits = '0';
+        }
+        else {
+            digits = this.withoutSeparators(digitsStart, this.pos).toLowerCase();
+        }
+        this.setValue('0x' + digits);
+        this.tokenFlags |= 64 /* TokenFlags.HexSpecifier */;
+        return this.scanBigIntSuffix();
+    }
+    scanBinaryOrOctalNumber(base) {
+        this.pos = (this.pos + 2) | 0;
+        const digitsStart = this.pos;
+        let digits;
+        if (this.scanSpecifierDigits(base) === 0) {
+            this.error(base === 2 ? 133 /* Diagnostics.Binary_digit_expected */ : 134 /* Diagnostics.Octal_digit_expected */);
+            digits = '0';
+        }
+        else {
+            digits = this.withoutSeparators(digitsStart, this.pos);
+        }
+        this.setValue((base === 2 ? '0b' : '0o') + digits);
+        this.tokenFlags |= base === 2 ? 128 /* TokenFlags.BinarySpecifier */ : 256 /* TokenFlags.OctalSpecifier */;
+        return this.scanBigIntSuffix();
+    }
+    /** Completes a numeric literal whose value is set: a `n` suffix makes it a bigint. */
+    scanBigIntSuffix() {
+        if (this.char() === 110 /* CharacterCodes.n */) {
+            if ((this.tokenFlags & 384 /* TokenFlags.BinaryOrOctalSpecifier */) !== 0)
+                this.setValue(parsePseudoBigInt(this.tokenValue) + 'n');
+            else
+                this.setValue(this.tokenValue + 'n');
+            this.pos = (this.pos + 1) | 0;
+            return 9 /* SyntaxKind.BigIntLiteral */;
+        }
+        this.setValue(String(Number(this.tokenValue)));
+        return 8 /* SyntaxKind.NumericLiteral */;
+    }
+    /** Splits `<<` into `<`. */
+    reScanLessThanToken() {
+        if (this.token === 47 /* SyntaxKind.LessThanLessThanToken */) {
+            this.pos = (this.tokenStart + 1) | 0;
+            this.token = 29 /* SyntaxKind.LessThanToken */;
+        }
+        return this.token;
+    }
+    /** Joins `>` with following `>`, `>=`, `>>`, `>>=` or `=`. */
+    reScanGreaterThanToken() {
+        if (this.token !== 31 /* SyntaxKind.GreaterThanToken */)
+            return this.token;
+        this.pos = (this.tokenStart + 1) | 0;
+        if (this.char() === 62 /* CharacterCodes.greaterThan */) {
+            if (this.peek(1) === 62 /* CharacterCodes.greaterThan */) {
+                if (this.peek(2) === 61 /* CharacterCodes.equals */) {
+                    this.pos = (this.pos + 3) | 0;
+                    return (this.token = 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */);
+                }
+                this.pos = (this.pos + 2) | 0;
+                return (this.token = 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */);
+            }
+            if (this.peek(1) === 61 /* CharacterCodes.equals */) {
+                this.pos = (this.pos + 2) | 0;
+                return (this.token = 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */);
+            }
+            this.pos = (this.pos + 1) | 0;
+            return (this.token = 48 /* SyntaxKind.GreaterThanGreaterThanToken */);
+        }
+        if (this.char() === 61 /* CharacterCodes.equals */) {
+            this.pos = (this.pos + 1) | 0;
+            return (this.token = 33 /* SyntaxKind.GreaterThanEqualsToken */);
+        }
+        return this.token;
+    }
+    /** Rescans a `}` as a template middle or tail. */
+    reScanTemplateToken(isTaggedTemplate) {
+        this.pos = this.tokenStart;
+        return (this.token = this.scanTemplateAndSetTokenValue(!isTaggedTemplate));
+    }
+    /** Splits `*=` into `*` and `=`, returning `=`. */
+    reScanAsteriskEqualsToken() {
+        if (this.token !== 66 /* SyntaxKind.AsteriskEqualsToken */)
+            throw new Error("'reScanAsteriskEqualsToken' should only be called on a '*='");
+        this.pos = (this.tokenStart + 1) | 0;
+        return (this.token = 63 /* SyntaxKind.EqualsToken */);
+    }
+    /** Rescans `/` or `/=` as a regular expression literal, optionally checking its syntax. */
+    reScanSlashToken(reportErrors = false) {
+        if (this.token !== 43 /* SyntaxKind.SlashToken */ && this.token !== 68 /* SyntaxKind.SlashEqualsToken */)
+            return this.token;
+        const chars = this.chars;
+        // Find the end of the body quickly so the flags are known before checking it.
+        const bodyStart = this.tokenStart + 1;
+        let p = bodyStart;
+        let inEscape = false;
+        let namedCaptureGroups = false;
+        // A `[` inside a class does not nest here, even in Unicode Sets mode: `/[[]/` is terminated.
+        let inCharacterClass = false;
+        for (;;) {
+            if (p >= this.end) {
+                this.tokenFlags |= 4 /* TokenFlags.Unterminated */;
+                break;
+            }
+            const ch = chars[p];
+            if (isLineBreak(ch)) {
+                this.tokenFlags |= 4 /* TokenFlags.Unterminated */;
+                break;
+            }
+            if (inEscape) {
+                inEscape = false;
+            }
+            else if (ch === 47 /* CharacterCodes.slash */ && !inCharacterClass) {
+                break;
+            }
+            else if (ch === 91 /* CharacterCodes.openBracket */) {
+                inCharacterClass = true;
+            }
+            else if (ch === 92 /* CharacterCodes.backslash */) {
+                inEscape = true;
+            }
+            else if (ch === 93 /* CharacterCodes.closeBracket */) {
+                inCharacterClass = false;
+            }
+            else if (!inCharacterClass &&
+                ch === 40 /* CharacterCodes.openParen */ &&
+                p + 2 < this.end &&
+                chars[p + 1] === 63 /* CharacterCodes.question */ &&
+                chars[p + 2] === 60 /* CharacterCodes.lessThan */ &&
+                (p + 3 >= this.end || (chars[p + 3] !== 61 /* CharacterCodes.equals */ && chars[p + 3] !== 33 /* CharacterCodes.exclamation */))) {
+                namedCaptureGroups = true;
+            }
+            p++;
+        }
+        const bodyEnd = p;
+        if ((this.tokenFlags & 4 /* TokenFlags.Unterminated */) !== 0) {
+            // Recover at the nearest unbalanced bracket, counting nested classes.
+            p = bodyStart;
+            inEscape = false;
+            let classDepth = 0;
+            let inDecimalQuantifier = false;
+            let groupDepth = 0;
+            while (p < bodyEnd) {
+                const ch = chars[p];
+                if (inEscape) {
+                    inEscape = false;
+                }
+                else if (ch === 92 /* CharacterCodes.backslash */) {
+                    inEscape = true;
+                }
+                else if (ch === 91 /* CharacterCodes.openBracket */) {
+                    classDepth++;
+                }
+                else if (ch === 93 /* CharacterCodes.closeBracket */ && classDepth !== 0) {
+                    classDepth--;
+                }
+                else if (classDepth === 0) {
+                    if (ch === 123 /* CharacterCodes.openBrace */) {
+                        inDecimalQuantifier = true;
+                    }
+                    else if (ch === 125 /* CharacterCodes.closeBrace */ && inDecimalQuantifier) {
+                        inDecimalQuantifier = false;
+                    }
+                    else if (!inDecimalQuantifier) {
+                        if (ch === 40 /* CharacterCodes.openParen */)
+                            groupDepth++;
+                        else if (ch === 41 /* CharacterCodes.closeParen */ && groupDepth !== 0)
+                            groupDepth--;
+                        else if (ch === 41 /* CharacterCodes.closeParen */ ||
+                            ch === 93 /* CharacterCodes.closeBracket */ ||
+                            ch === 125 /* CharacterCodes.closeBrace */)
+                            break;
+                    }
+                }
+                p++;
+            }
+            // Trailing whitespace and semicolons are unlikely to belong to the regex.
+            while (p > bodyStart) {
+                const ch = chars[p - 1];
+                if (!isWhiteSpaceLike(ch) && ch !== 59 /* CharacterCodes.semicolon */)
+                    break;
+                p--;
+            }
+            this.errorAt(118 /* Diagnostics.Unterminated_regular_expression_literal */, this.tokenStart, p - this.tokenStart, noArgs);
+        }
+        else {
+            p++; // the closing slash
+            let flags = 0 /* RegularExpressionFlags.None */;
+            while (p < this.end) {
+                const ch = this.codePointAt(p, this.end);
+                if (ch === 65533 /* CharacterCodes.replacementCharacter */ || !isIdentifierPart(ch))
+                    break;
+                const size = charSize(ch);
+                if (reportErrors) {
+                    const flag = regularExpressionFlag(ch);
+                    if (flag === 0 /* RegularExpressionFlags.None */)
+                        this.errorAt(414 /* Diagnostics.Unknown_regular_expression_flag */, p, size, noArgs);
+                    else if ((flags & flag) !== 0)
+                        this.errorAt(415 /* 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);
+                    else {
+                        flags |= flag;
+                        this.checkRegularExpressionFlagAvailability(flag, p, size);
+                    }
+                }
+                p += size;
+            }
+            if (reportErrors) {
+                const savedEnd = this.end;
+                const savedTokenStart = this.tokenStart;
+                const savedTokenFlags = this.tokenFlags;
+                this.pos = bodyStart | 0;
+                this.end = bodyEnd | 0;
+                checkRegularExpression(this, bodyEnd, flags, namedCaptureGroups);
+                this.end = savedEnd;
+                this.tokenStart = savedTokenStart;
+                this.tokenFlags = savedTokenFlags;
+            }
+        }
+        this.pos = p | 0;
+        this.setValueSlice(this.tokenStart, p);
+        return (this.token = 13 /* SyntaxKind.RegularExpressionLiteral */);
+    }
+    /** @internal Reports a regular expression flag unavailable at the current target. */
+    checkRegularExpressionFlagAvailability(flag, pos, size) {
+        let availableFrom;
+        if (flag === 1 /* RegularExpressionFlags.HasIndices */)
+            availableFrom = 9 /* ScriptTarget.ES2022 */;
+        else if (flag === 16 /* RegularExpressionFlags.DotAll */)
+            availableFrom = 5 /* ScriptTarget.ES2018 */;
+        else if (flag === 64 /* RegularExpressionFlags.UnicodeSets */)
+            availableFrom = 11 /* ScriptTarget.ES2024 */;
+        else
+            return;
+        if (this.languageVersion() < availableFrom)
+            this.errorAt(416 /* Diagnostics.This_regular_expression_flag_is_only_available_when_targeting_0_or_later */, pos, size, [
+                regularExpressionFlagName(availableFrom),
+            ]);
+    }
+    /** Rescans from the token's full start as JSX text or a JSX token. */
+    reScanJsxToken(allowMultilineJsxText = true) {
+        this.pos = this.fullStartPos;
+        this.tokenStart = this.fullStartPos;
+        return (this.token = this.scanJsxToken(allowMultilineJsxText));
+    }
+    /** Splits a private identifier into `#` and the name. */
+    reScanHashToken() {
+        if (this.token === 80 /* SyntaxKind.PrivateIdentifier */) {
+            this.pos = (this.tokenStart + 1) | 0;
+            this.token = 62 /* SyntaxKind.HashToken */;
+        }
+        return this.token;
+    }
+    /** Splits `??` into `?`. */
+    reScanQuestionToken() {
+        if (this.token !== 60 /* SyntaxKind.QuestionQuestionToken */)
+            throw new Error("'reScanQuestionToken' should only be called on a '??'");
+        this.pos = (this.tokenStart + 1) | 0;
+        return (this.token = 57 /* SyntaxKind.QuestionToken */);
+    }
+    /** Scans JSX children: text, `<`, `</` or `{`. */
+    scanJsxToken(allowMultilineJsxText = true) {
+        this.fullStartPos = this.pos | 0;
+        this.tokenStart = this.pos | 0;
+        const ch = this.char();
+        if (ch < 0)
+            return (this.token = 1 /* SyntaxKind.EndOfFile */);
+        if (ch === 60 /* CharacterCodes.lessThan */) {
+            if (this.peek(1) === 47 /* CharacterCodes.slash */) {
+                this.pos = (this.pos + 2) | 0;
+                return (this.token = 30 /* SyntaxKind.LessThanSlashToken */);
+            }
+            this.pos = (this.pos + 1) | 0;
+            return (this.token = 29 /* SyntaxKind.LessThanToken */);
+        }
+        if (ch === 123 /* CharacterCodes.openBrace */) {
+            this.pos = (this.pos + 1) | 0;
+            return (this.token = 18 /* SyntaxKind.OpenBraceToken */);
+        }
+        // 0: only whitespace so far; -1: only whitespace and a line break, which is ignored.
+        let firstNonWhitespace = 0;
+        while (this.pos < this.end) {
+            const c = this.chars[this.pos] | 0;
+            if (c === 123 /* CharacterCodes.openBrace */)
+                break;
+            if (c === 60 /* CharacterCodes.lessThan */) {
+                if (isConflictMarkerTrivia(this.text, this.pos)) {
+                    this.pos = scanConflictMarkerTrivia(this.text, this.pos, this) | 0;
+                    return (this.token = 6 /* SyntaxKind.ConflictMarkerTrivia */);
+                }
+                break;
+            }
+            if (c === 62 /* CharacterCodes.greaterThan */)
+                this.errorAt(311 /* Diagnostics.Unexpected_token_Did_you_mean_or_gt */, this.pos, 1, noArgs);
+            else if (c === 125 /* CharacterCodes.closeBrace */)
+                this.errorAt(310 /* Diagnostics.Unexpected_token_Did_you_mean_or_rbrace */, this.pos, 1, noArgs);
+            if (isLineBreak(c) && firstNonWhitespace === 0)
+                firstNonWhitespace = -1;
+            else if (!allowMultilineJsxText && isLineBreak(c) && firstNonWhitespace > 0)
+                break;
+            else if (!isWhiteSpaceLike(c))
+                firstNonWhitespace = this.pos;
+            this.pos = (this.pos + 1) | 0;
+        }
+        this.setValueSlice(this.fullStartPos, this.pos);
+        return (this.token = firstNonWhitespace === -1 ? 12 /* SyntaxKind.JsxTextAllWhiteSpaces */ : 11 /* SyntaxKind.JsxText */);
+    }
+    /** Extends an identifier or keyword with `-` and further parts, as JSX names allow. */
+    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;
+        }
+        this.setValue(value);
+        return (this.token = getIdentifierToken(value));
+    }
+    /** Scans a JSX attribute value after `=`: a string, or any other token. */
+    scanJsxAttributeValue() {
+        this.fullStartPos = this.pos | 0;
+        while (this.pos < this.end && isWhiteSpaceLike(this.chars[this.pos] | 0))
+            this.pos = (this.pos + 1) | 0;
+        this.tokenStart = this.pos | 0;
+        const ch = this.char();
+        if (ch === 34 /* CharacterCodes.doubleQuote */ || ch === 39 /* CharacterCodes.singleQuote */) {
+            this.scanString(true);
+            return (this.token = 10 /* SyntaxKind.StringLiteral */);
+        }
+        return this.scan();
+    }
+    reScanJsxAttributeValue() {
+        this.pos = this.fullStartPos;
+        this.tokenStart = this.fullStartPos;
+        return this.scanJsxAttributeValue();
+    }
+    /** Scans JSDoc comment text up to a line break, backtick, `{` or tag; falls back to `scanJSDocToken`. */
+    scanJSDocCommentTextToken(inBackticks) {
+        this.fullStartPos = this.pos | 0;
+        this.tokenFlags = 0 /* TokenFlags.None */;
+        if (this.pos >= this.end)
+            return (this.token = 1 /* SyntaxKind.EndOfFile */);
+        this.tokenStart = this.pos | 0;
+        while (this.pos < this.end) {
+            // Fast path: an ASCII unit that ends no text run.
+            const unit = this.chars[this.pos] | 0;
+            if (unit < 0x80 &&
+                unit !== 10 /* CharacterCodes.lineFeed */ &&
+                unit !== 13 /* CharacterCodes.carriageReturn */ &&
+                unit !== 96 /* CharacterCodes.backtick */ &&
+                unit !== 123 /* CharacterCodes.openBrace */ &&
+                unit !== 64 /* CharacterCodes.at */) {
+                this.pos = (this.pos + 1) | 0;
+                continue;
+            }
+            const ch = this.codePointAt(this.pos, this.end);
+            if (isLineBreak(ch) || ch === 96 /* CharacterCodes.backtick */)
+                break;
+            const size = charSize(ch);
+            if (!inBackticks) {
+                if (ch === 123 /* CharacterCodes.openBrace */)
+                    break;
+                // Outside backticks, `@` starts a tag after whitespace and before an identifier.
+                if (ch === 64 /* CharacterCodes.at */ &&
+                    isWhiteSpaceSingleLine(this.codePointBefore(this.pos)) &&
+                    isIdentifierStart(this.codePointAt((this.pos + size) | 0, this.end)))
+                    break;
+            }
+            this.pos = (this.pos + size) | 0;
+        }
+        if (this.pos === this.tokenStart)
+            return this.scanJSDocToken();
+        this.setValueSlice(this.tokenStart, this.pos);
+        return (this.token = 81 /* SyntaxKind.JSDocCommentTextToken */);
+    }
+    /** After `@`: whether a tag name (or an incomplete tag) can follow. */
+    canFollowJSDocAt() {
+        if (this.pos >= this.end)
+            return true;
+        const ch = this.codePointAt(this.pos, this.end);
+        return isIdentifierStart(ch) || isWhiteSpaceSingleLine(ch) || isLineBreak(ch);
+    }
+    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 */);
+        this.tokenStart = this.pos | 0;
+        const ch = this.codePointAt(this.pos, this.end);
+        this.pos = (this.pos + charSize(ch)) | 0;
+        switch (ch) {
+            case 9 /* CharacterCodes.tab */:
+            case 11 /* CharacterCodes.verticalTab */:
+            case 12 /* CharacterCodes.formFeed */:
+            case 32 /* CharacterCodes.space */:
+                while (this.pos < this.end && isWhiteSpaceSingleLine(chars[this.pos] | 0))
+                    this.pos = (this.pos + 1) | 0;
+                return (this.token = 5 /* SyntaxKind.WhitespaceTrivia */);
+            case 64 /* CharacterCodes.at */:
+                return (this.token = 59 /* SyntaxKind.AtToken */);
+            case 13 /* CharacterCodes.carriageReturn */:
+            case 10 /* CharacterCodes.lineFeed */:
+                if (ch === 13 /* CharacterCodes.carriageReturn */ && this.char() === 10 /* CharacterCodes.lineFeed */)
+                    this.pos = (this.pos + 1) | 0;
+                this.tokenFlags |= 1 /* TokenFlags.PrecedingLineBreak */;
+                return (this.token = 4 /* SyntaxKind.NewLineTrivia */);
+            case 42 /* CharacterCodes.asterisk */:
+                return (this.token = 41 /* SyntaxKind.AsteriskToken */);
+            case 123 /* CharacterCodes.openBrace */:
+                return (this.token = 18 /* SyntaxKind.OpenBraceToken */);
+            case 125 /* CharacterCodes.closeBrace */:
+                return (this.token = 19 /* SyntaxKind.CloseBraceToken */);
+            case 91 /* CharacterCodes.openBracket */:
+                return (this.token = 22 /* SyntaxKind.OpenBracketToken */);
+            case 93 /* CharacterCodes.closeBracket */:
+                return (this.token = 23 /* SyntaxKind.CloseBracketToken */);
+            case 40 /* CharacterCodes.openParen */:
+                return (this.token = 20 /* SyntaxKind.OpenParenToken */);
+            case 41 /* CharacterCodes.closeParen */:
+                return (this.token = 21 /* SyntaxKind.CloseParenToken */);
+            case 60 /* CharacterCodes.lessThan */:
+                return (this.token = 29 /* SyntaxKind.LessThanToken */);
+            case 62 /* CharacterCodes.greaterThan */:
+                return (this.token = 31 /* SyntaxKind.GreaterThanToken */);
+            case 61 /* CharacterCodes.equals */:
+                return (this.token = 63 /* SyntaxKind.EqualsToken */);
+            case 44 /* CharacterCodes.comma */:
+                return (this.token = 27 /* SyntaxKind.CommaToken */);
+            case 46 /* CharacterCodes.dot */:
+                return (this.token = 24 /* SyntaxKind.DotToken */);
+            case 96 /* CharacterCodes.backtick */:
+                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());
+    }
+}
+const mergeConflictMarkerLength = 7;
+function utf8Length(ch) {
+    return ch < 0x80 ? 1 : ch < 0x800 ? 2 : ch >= 0xd800 && ch <= 0xdfff ? 4 : 3;
+}
+// Whether a conflict marker at `pos` is at a line start, as TypeScript 7 decides it:
+// after a CR or LF, or after a line terminator followed by two bytes of UTF-8
+// (two ASCII characters or one two-byte character).
+function isConflictMarkerLineStart(text, pos) {
+    if (pos === 0)
+        return true;
+    const previous = text.charCodeAt(pos - 1);
+    if (previous === 10 /* CharacterCodes.lineFeed */ || previous === 13 /* CharacterCodes.carriageReturn */)
+        return true;
+    const length = utf8Length(previous);
+    if (length === 2)
+        return pos >= 2 && isLineBreak(text.charCodeAt(pos - 2));
+    if (length === 1 && pos >= 3 && text.charCodeAt(pos - 2) < 0x80)
+        return isLineBreak(text.charCodeAt(pos - 3));
+    return false;
+}
+/** Whether `text` has a `<<<<<<<`, `|||||||`, `=======` or `>>>>>>>` marker at `pos`. */
+export function isConflictMarkerTrivia(text, pos) {
+    if (pos + 1 >= text.length || text.charCodeAt(pos + 1) !== text.charCodeAt(pos))
+        return false;
+    if (!isConflictMarkerLineStart(text, pos) || pos + mergeConflictMarkerLength >= text.length)
+        return false;
+    const ch = text.charCodeAt(pos);
+    for (let i = 2; i < mergeConflictMarkerLength; i++)
+        if (text.charCodeAt(pos + i) !== ch)
+            return false;
+    return ch === 61 /* CharacterCodes.equals */ || text.charCodeAt(pos + mergeConflictMarkerLength) === 32 /* CharacterCodes.space */;
+}
+/** Skips a conflict marker and returns the position after it; reports it if `scanner` is given. */
+function scanConflictMarkerTrivia(text, pos, scanner) {
+    if (scanner !== undefined)
+        scanner.errorAt(141 /* Diagnostics.Merge_conflict_marker_encountered */, pos, mergeConflictMarkerLength, noArgs);
+    const ch = text.charCodeAt(pos);
+    const length = text.length;
+    if (ch === 60 /* CharacterCodes.lessThan */ || ch === 62 /* CharacterCodes.greaterThan */) {
+        while (pos < length && !isLineBreak(text.charCodeAt(pos)))
+            pos++;
+        return pos;
+    }
+    // Consume from a ||||||| or ======= marker to the next ======= or >>>>>>> marker.
+    while (pos < length) {
+        const current = text.charCodeAt(pos);
+        if ((current === 61 /* CharacterCodes.equals */ || current === 62 /* CharacterCodes.greaterThan */) &&
+            current !== ch &&
+            isConflictMarkerTrivia(text, pos))
+            break;
+        pos++;
+    }
+    return pos;
+}
+function scanShebangTrivia(text, pos) {
+    pos += 2;
+    while (pos < text.length && !isLineBreak(text.charCodeAt(pos)))
+        pos++;
+    return pos;
+}
+function isShebangTrivia(text) {
+    return (text.length >= 2 && text.charCodeAt(0) === 35 /* CharacterCodes.hash */ && text.charCodeAt(1) === 33 /* CharacterCodes.exclamation */);
+}
+/** The `#!` line at the start of `text`, or `''`. */
+export function getShebang(text) {
+    return isShebangTrivia(text) ? text.substring(0, scanShebangTrivia(text, 0)) : '';
+}
+/** Whether trivia could start at `pos`; a fast pre-check for `skipTrivia`. */
+export function couldStartTrivia(text, pos) {
+    const ch = text.charCodeAt(pos);
+    switch (ch) {
+        case 13 /* CharacterCodes.carriageReturn */:
+        case 10 /* CharacterCodes.lineFeed */:
+        case 9 /* CharacterCodes.tab */:
+        case 11 /* CharacterCodes.verticalTab */:
+        case 12 /* CharacterCodes.formFeed */:
+        case 32 /* CharacterCodes.space */:
+        case 47 /* CharacterCodes.slash */:
+        case 60 /* CharacterCodes.lessThan */:
+        case 124 /* CharacterCodes.bar */:
+        case 61 /* CharacterCodes.equals */:
+        case 62 /* CharacterCodes.greaterThan */:
+            return true;
+        case 35 /* CharacterCodes.hash */:
+            return pos === 0;
+        default:
+            return ch > 127 /* CharacterCodes.maxAsciiCharacter */;
+    }
+}
+/** Returns the position after whitespace, comments, conflict markers and a leading shebang. */
+export function skipTrivia(text, pos, stopAfterLineBreak = false, stopAtComments = false, inJSDoc = false) {
+    if (pos < 0)
+        return pos;
+    const length = text.length;
+    let canConsumeStar = false;
+    for (;;) {
+        if (pos >= length)
+            return pos;
+        const ch = text.charCodeAt(pos);
+        switch (ch) {
+            case 13 /* CharacterCodes.carriageReturn */:
+            case 10 /* CharacterCodes.lineFeed */:
+                if (ch === 13 /* CharacterCodes.carriageReturn */ &&
+                    pos + 1 < length &&
+                    text.charCodeAt(pos + 1) === 10 /* CharacterCodes.lineFeed */)
+                    pos++;
+                pos++;
+                if (stopAfterLineBreak)
+                    return pos;
+                canConsumeStar = inJSDoc;
+                continue;
+            case 9 /* CharacterCodes.tab */:
+            case 11 /* CharacterCodes.verticalTab */:
+            case 12 /* CharacterCodes.formFeed */:
+            case 32 /* CharacterCodes.space */:
+                pos++;
+                continue;
+            case 47 /* CharacterCodes.slash */:
+                if (stopAtComments || pos + 1 >= length)
+                    return pos;
+                if (text.charCodeAt(pos + 1) === 47 /* CharacterCodes.slash */) {
+                    pos += 2;
+                    while (pos < length && !isLineBreak(text.charCodeAt(pos)))
+                        pos++;
+                    canConsumeStar = false;
+                    continue;
+                }
+                if (text.charCodeAt(pos + 1) === 42 /* CharacterCodes.asterisk */) {
+                    const close = text.indexOf('*/', pos + 2);
+                    pos = close < 0 ? length : close + 2;
+                    canConsumeStar = false;
+                    continue;
+                }
+                return pos;
+            case 60 /* CharacterCodes.lessThan */:
+            case 124 /* CharacterCodes.bar */:
+            case 61 /* CharacterCodes.equals */:
+            case 62 /* CharacterCodes.greaterThan */:
+                if (isConflictMarkerTrivia(text, pos)) {
+                    pos = scanConflictMarkerTrivia(text, pos, undefined);
+                    canConsumeStar = false;
+                    continue;
+                }
+                return pos;
+            case 35 /* CharacterCodes.hash */:
+                if (pos === 0 && isShebangTrivia(text)) {
+                    pos = scanShebangTrivia(text, pos);
+                    canConsumeStar = false;
+                    continue;
+                }
+                return pos;
+            case 42 /* CharacterCodes.asterisk */:
+                if (canConsumeStar) {
+                    pos++;
+                    canConsumeStar = false;
+                    continue;
+                }
+                return pos;
+            default:
+                if (ch > 127 /* CharacterCodes.maxAsciiCharacter */ && isWhiteSpaceLike(ch)) {
+                    pos++;
+                    continue;
+                }
+                return pos;
+        }
+    }
+}
+/** Comments before the next token at `pos`; those on the first line are skipped unless `pos` is 0. */
+export function getLeadingCommentRanges(text, pos) {
+    return collectCommentRanges(text, pos, false);
+}
+/** Comments after `pos` up to the next line break. */
+export function getTrailingCommentRanges(text, pos) {
+    return collectCommentRanges(text, pos, true);
+}
+function collectCommentRanges(text, pos, trailing) {
+    let result;
+    let pendingPos = 0;
+    let pendingEnd = 0;
+    let pendingKind = 0 /* SyntaxKind.Unknown */;
+    let pendingHasTrailingNewLine = false;
+    let hasPending = false;
+    let collecting = trailing;
+    if (pos === 0) {
+        collecting = true;
+        if (isShebangTrivia(text))
+            pos = scanShebangTrivia(text, pos);
+    }
+    const length = text.length;
+    scan: while (pos >= 0 && pos < length) {
+        const ch = text.charCodeAt(pos);
+        switch (ch) {
+            case 13 /* CharacterCodes.carriageReturn */:
+            case 10 /* CharacterCodes.lineFeed */:
+                if (ch === 13 /* CharacterCodes.carriageReturn */ &&
+                    pos + 1 < length &&
+                    text.charCodeAt(pos + 1) === 10 /* CharacterCodes.lineFeed */)
+                    pos++;
+                pos++;
+                if (trailing)
+                    break scan;
+                collecting = true;
+                if (hasPending)
+                    pendingHasTrailingNewLine = true;
+                continue;
+            case 9 /* CharacterCodes.tab */:
+            case 11 /* CharacterCodes.verticalTab */:
+            case 12 /* CharacterCodes.formFeed */:
+            case 32 /* CharacterCodes.space */:
+                pos++;
+                continue;
+            case 47 /* CharacterCodes.slash */: {
+                const next = pos + 1 < length ? text.charCodeAt(pos + 1) : 0;
+                if (next !== 47 /* CharacterCodes.slash */ && next !== 42 /* CharacterCodes.asterisk */)
+                    break scan;
+                const kind = next === 47 /* CharacterCodes.slash */ ? 2 /* SyntaxKind.SingleLineCommentTrivia */ : 3 /* SyntaxKind.MultiLineCommentTrivia */;
+                const start = pos;
+                let hasTrailingNewLine = false;
+                pos += 2;
+                if (next === 47 /* CharacterCodes.slash */) {
+                    while (pos < length) {
+                        if (isLineBreak(text.charCodeAt(pos))) {
+                            hasTrailingNewLine = true;
+                            break;
+                        }
+                        pos++;
+                    }
+                }
+                else {
+                    const close = text.indexOf('*/', pos);
+                    pos = close < 0 ? length : close + 2;
+                }
+                if (collecting) {
+                    if (hasPending) {
+                        if (result === undefined)
+                            result = [];
+                        result.push(new CommentRange(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine));
+                    }
+                    pendingPos = start;
+                    pendingEnd = pos;
+                    pendingKind = kind;
+                    pendingHasTrailingNewLine = hasTrailingNewLine;
+                    hasPending = true;
+                }
+                continue;
+            }
+            default:
+                if (ch > 127 /* CharacterCodes.maxAsciiCharacter */ && isWhiteSpaceLike(ch)) {
+                    if (hasPending && isLineBreak(ch))
+                        pendingHasTrailingNewLine = true;
+                    pos++;
+                    continue;
+                }
+                break scan;
+        }
+    }
+    if (hasPending) {
+        if (result === undefined)
+            result = [];
+        result.push(new CommentRange(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine));
+    }
+    return result;
+}
+/** Start positions of each line, split at CR, LF, CRLF, LS and PS. */
+export function computeLineStarts(text) {
+    // Most texts break lines at LF only, which a search finds fastest.
+    if (text.indexOf('\r') < 0 && text.indexOf('\u2028') < 0 && text.indexOf('\u2029') < 0) {
+        const starts = [0];
+        for (let i = text.indexOf('\n'); i >= 0; i = text.indexOf('\n', i + 1))
+            starts.push(i + 1);
+        return starts;
+    }
+    const result = [];
+    let lineStart = 0;
+    let pos = 0;
+    while (pos < text.length) {
+        const ch = text.charCodeAt(pos);
+        pos++;
+        if (ch === 13 /* CharacterCodes.carriageReturn */) {
+            if (pos < text.length && text.charCodeAt(pos) === 10 /* CharacterCodes.lineFeed */)
+                pos++;
+        }
+        else if (ch !== 10 /* CharacterCodes.lineFeed */ &&
+            ch !== 8232 /* CharacterCodes.lineSeparator */ &&
+            ch !== 8233 /* CharacterCodes.paragraphSeparator */) {
+            continue;
+        }
+        result.push(lineStart);
+        lineStart = pos;
+    }
+    result.push(lineStart);
+    return result;
+}
+/** The zero-based line containing `pos`. */
+export function computeLineOfPosition(lineStarts, pos) {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low <= high) {
+        const middle = low + ((high - low) >> 1);
+        const value = lineStarts[middle];
+        if (value < pos)
+            low = middle + 1;
+        else if (value > pos)
+            high = middle - 1;
+        else
+            return middle;
+    }
+    return low - 1;
+}