tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/regexp-checker.js

@@ -0,0 +1,942 @@
+import { charSize, codePointAt, isASCIILetter, isDigit, isIdentifierPart, isWordCharacter, } from './character-codes.js';
+import { getSpellingSuggestion } from './spelling.js';
+import { binaryUnicodeProperties, binaryUnicodePropertiesOfStrings, generalCategoryValues, nonBinaryUnicodeProperties, valuesOfNonBinaryUnicodeProperty, } from './unicode-properties.js';
+/** The flag for a regular expression flag character, or `None`. */
+export function regularExpressionFlag(ch) {
+    switch (ch) {
+        case 100 /* CharacterCodes.d */:
+            return 1 /* RegularExpressionFlags.HasIndices */;
+        case 103 /* CharacterCodes.g */:
+            return 2 /* RegularExpressionFlags.Global */;
+        case 105 /* CharacterCodes.i */:
+            return 4 /* RegularExpressionFlags.IgnoreCase */;
+        case 109 /* CharacterCodes.m */:
+            return 8 /* RegularExpressionFlags.Multiline */;
+        case 115 /* CharacterCodes.s */:
+            return 16 /* RegularExpressionFlags.DotAll */;
+        case 117 /* CharacterCodes.u */:
+            return 32 /* RegularExpressionFlags.Unicode */;
+        case 118 /* CharacterCodes.v */:
+            return 64 /* RegularExpressionFlags.UnicodeSets */;
+        case 121 /* CharacterCodes.y */:
+            return 128 /* RegularExpressionFlags.Sticky */;
+        default:
+            return 0 /* RegularExpressionFlags.None */;
+    }
+}
+class GroupNameReference {
+    pos;
+    end;
+    name;
+    constructor(pos, end, name) {
+        this.pos = pos;
+        this.end = end;
+        this.name = name;
+    }
+}
+class DecimalEscape {
+    pos;
+    end;
+    value;
+    constructor(pos, end, value) {
+        this.pos = pos;
+        this.end = end;
+        this.value = value;
+    }
+}
+const noArgs = [];
+/**
+ * Checks the body of a regular expression literal, which the scanner has bounded
+ * to `[scanner.pos, end)`, and reports syntax errors through the scanner.
+ */
+export function checkRegularExpression(scanner, end, flags, namedCaptureGroups) {
+    new RegularExpressionChecker(scanner, end, flags, namedCaptureGroups).check();
+}
+function compareDecimalStrings(a, b) {
+    let i = 0;
+    while (i < a.length && a.charCodeAt(i) === 48 /* CharacterCodes._0 */)
+        i++;
+    let j = 0;
+    while (j < b.length && b.charCodeAt(j) === 48 /* CharacterCodes._0 */)
+        j++;
+    const x = i === a.length ? '0' : a.substring(i);
+    const y = j === b.length ? '0' : b.substring(j);
+    if (x.length !== y.length)
+        return x.length < y.length ? -1 : 1;
+    return x < y ? -1 : x > y ? 1 : 0;
+}
+function mapKeys(map) {
+    const result = [];
+    for (const key of map.keys())
+        result.push(key);
+    return result;
+}
+function setToArray(set) {
+    const result = [];
+    for (const value of set)
+        result.push(value);
+    return result;
+}
+class RegularExpressionChecker {
+    scanner;
+    text;
+    end;
+    anyUnicodeMode;
+    unicodeSetsMode;
+    annexB;
+    // Checked strictly in Unicode modes or without Annex B's looser grammar.
+    anyUnicodeModeOrNonAnnexB;
+    namedCaptureGroups;
+    // See scanClassSetExpression.
+    mayContainStrings;
+    numberOfCapturingGroups;
+    groupSpecifiers;
+    groupNameReferences;
+    decimalEscapes;
+    // Scopes of named capturing groups; see scanGroupName.
+    namedCapturingGroups;
+    constructor(scanner, end, flags, namedCaptureGroups) {
+        this.scanner = scanner;
+        this.text = scanner.text;
+        this.end = end;
+        this.anyUnicodeMode = (flags & 96 /* RegularExpressionFlags.AnyUnicodeMode */) !== 0;
+        this.unicodeSetsMode = (flags & 64 /* RegularExpressionFlags.UnicodeSets */) !== 0;
+        this.annexB = true;
+        this.anyUnicodeModeOrNonAnnexB = this.anyUnicodeMode || !this.annexB;
+        this.namedCaptureGroups = namedCaptureGroups;
+        this.mayContainStrings = false;
+        this.numberOfCapturingGroups = 0;
+        this.groupSpecifiers = new Set();
+        this.groupNameReferences = [];
+        this.decimalEscapes = [];
+        this.namedCapturingGroups = [];
+    }
+    char() {
+        return this.scanner.char();
+    }
+    /** The code unit at absolute position `pos`, or -1 past the body. */
+    charAt(pos) {
+        return pos < this.end ? this.text.charCodeAt(pos) : -1 /* CharacterCodes.EOF */;
+    }
+    error(message, start, length, args) {
+        this.scanner.errorAt(message, start, length, args);
+    }
+    /** Checks the expression and returns its number of capturing groups. */
+    check() {
+        this.scanDisjunction(false);
+        for (const reference of this.groupNameReferences) {
+            if (this.groupSpecifiers.has(reference.name))
+                continue;
+            this.error(447 /* Diagnostics.There_is_no_capturing_group_named_0_in_this_regular_expression */, reference.pos, reference.end - reference.pos, [reference.name]);
+            if (this.groupSpecifiers.size > 0) {
+                const suggestion = getSpellingSuggestion(reference.name, setToArray(this.groupSpecifiers));
+                if (suggestion !== '')
+                    this.error(303 /* Diagnostics.Did_you_mean_0 */, reference.pos, reference.end - reference.pos, [suggestion]);
+            }
+        }
+        // Annex B reads such escapes as octal or identity escapes, but they are most likely mistakes.
+        for (const escape of this.decimalEscapes) {
+            if (escape.value <= this.numberOfCapturingGroups)
+                continue;
+            if (this.numberOfCapturingGroups > 0)
+                this.error(448 /* Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_only_0_capturing_groups_in_this_regular_expression */, escape.pos, escape.end - escape.pos, [String(this.numberOfCapturingGroups)]);
+            else
+                this.error(449 /* Diagnostics.This_backreference_refers_to_a_group_that_does_not_exist_There_are_no_capturing_groups_in_this_regular_expression */, escape.pos, escape.end - escape.pos, noArgs);
+        }
+        return this.numberOfCapturingGroups;
+    }
+    // Disjunction ::= Alternative ('|' Alternative)*
+    scanDisjunction(isInGroup) {
+        for (;;) {
+            this.namedCapturingGroups.push(new Set());
+            this.scanAlternative(isInGroup);
+            this.namedCapturingGroups.pop();
+            if (this.char() !== 124 /* CharacterCodes.bar */)
+                return;
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+        }
+    }
+    // Alternative ::= Term*
+    // Term ::= Assertion | Atom Quantifier?
+    scanAlternative(isInGroup) {
+        let isPreviousTermQuantifiable = false;
+        while (this.scanner.pos < this.end) {
+            const start = this.scanner.pos;
+            const ch = this.char();
+            switch (ch) {
+                case 94 /* CharacterCodes.caret */:
+                case 36 /* CharacterCodes.$ */:
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    isPreviousTermQuantifiable = false;
+                    continue;
+                case 92 /* CharacterCodes.backslash */:
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    if (this.char() === 98 /* CharacterCodes.b */ || this.char() === 66 /* CharacterCodes.B */) {
+                        this.scanner.pos = (this.scanner.pos + 1) | 0;
+                        isPreviousTermQuantifiable = false;
+                    }
+                    else {
+                        this.scanAtomEscape(this.char());
+                        isPreviousTermQuantifiable = true;
+                    }
+                    continue;
+                case 40 /* CharacterCodes.openParen */:
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    if (this.char() === 63 /* CharacterCodes.question */) {
+                        this.scanner.pos = (this.scanner.pos + 1) | 0;
+                        const next = this.char();
+                        if (next === 61 /* CharacterCodes.equals */ || next === 33 /* CharacterCodes.exclamation */) {
+                            this.scanner.pos = (this.scanner.pos + 1) | 0;
+                            // Annex B makes `(?=…)` and `(?!…)` quantifiable.
+                            isPreviousTermQuantifiable = !this.anyUnicodeModeOrNonAnnexB;
+                        }
+                        else if (next === 60 /* CharacterCodes.lessThan */) {
+                            const groupNameStart = this.scanner.pos;
+                            this.scanner.pos = (this.scanner.pos + 1) | 0;
+                            if (this.char() === 61 /* CharacterCodes.equals */ || this.char() === 33 /* CharacterCodes.exclamation */) {
+                                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                                isPreviousTermQuantifiable = false;
+                            }
+                            else {
+                                this.scanGroupName(false);
+                                this.scanExpectedChar(62 /* CharacterCodes.greaterThan */);
+                                if (this.scanner.languageVersion() < 5 /* ScriptTarget.ES2018 */)
+                                    this.error(418 /* Diagnostics.Named_capturing_groups_are_only_available_when_targeting_ES2018_or_later */, groupNameStart, this.scanner.pos - groupNameStart, noArgs);
+                                this.numberOfCapturingGroups++;
+                                isPreviousTermQuantifiable = true;
+                            }
+                        }
+                        else {
+                            const flagsStart = this.scanner.pos;
+                            const setFlags = this.scanPatternModifiers(0 /* RegularExpressionFlags.None */);
+                            if (this.char() === 45 /* CharacterCodes.minus */) {
+                                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                                this.scanPatternModifiers(setFlags);
+                                if (this.scanner.pos === flagsStart + 1)
+                                    this.error(419 /* Diagnostics.Subpattern_flags_must_be_present_when_there_is_a_minus_sign */, flagsStart, this.scanner.pos - flagsStart, noArgs);
+                            }
+                            this.scanExpectedChar(58 /* CharacterCodes.colon */);
+                            isPreviousTermQuantifiable = true;
+                        }
+                    }
+                    else {
+                        this.numberOfCapturingGroups++;
+                        isPreviousTermQuantifiable = true;
+                    }
+                    this.scanDisjunction(true);
+                    this.scanExpectedChar(41 /* CharacterCodes.closeParen */);
+                    continue;
+                case 123 /* CharacterCodes.openBrace */: {
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    const digitsStart = this.scanner.pos;
+                    const min = this.scanDigits();
+                    if (!this.anyUnicodeModeOrNonAnnexB && min === '') {
+                        isPreviousTermQuantifiable = true;
+                        continue;
+                    }
+                    if (this.char() === 44 /* CharacterCodes.comma */) {
+                        this.scanner.pos = (this.scanner.pos + 1) | 0;
+                        const max = this.scanDigits();
+                        if (min === '') {
+                            if (max !== '' || this.char() === 125 /* CharacterCodes.closeBrace */) {
+                                this.error(420 /* Diagnostics.Incomplete_quantifier_Digit_expected */, digitsStart, 0, noArgs);
+                            }
+                            else {
+                                this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, start, 1, [
+                                    String.fromCharCode(ch),
+                                ]);
+                                isPreviousTermQuantifiable = true;
+                                continue;
+                            }
+                        }
+                        else if (max !== '' &&
+                            compareDecimalStrings(min, max) > 0 &&
+                            (this.anyUnicodeModeOrNonAnnexB || this.char() === 125 /* CharacterCodes.closeBrace */)) {
+                            this.error(421 /* Diagnostics.Numbers_out_of_order_in_quantifier */, digitsStart, this.scanner.pos - digitsStart, noArgs);
+                        }
+                    }
+                    else if (min === '') {
+                        if (this.anyUnicodeModeOrNonAnnexB)
+                            this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, start, 1, [
+                                String.fromCharCode(ch),
+                            ]);
+                        isPreviousTermQuantifiable = true;
+                        continue;
+                    }
+                    if (this.char() !== 125 /* CharacterCodes.closeBrace */) {
+                        if (!this.anyUnicodeModeOrNonAnnexB) {
+                            isPreviousTermQuantifiable = true;
+                            continue;
+                        }
+                        this.error(2 /* Diagnostics.X_0_expected */, this.scanner.pos, 0, ['}']);
+                        this.scanner.pos = (this.scanner.pos - 1) | 0;
+                    }
+                    isPreviousTermQuantifiable = this.scanQuantifier(start, isPreviousTermQuantifiable);
+                    continue;
+                }
+                case 42 /* CharacterCodes.asterisk */:
+                case 43 /* CharacterCodes.plus */:
+                case 63 /* CharacterCodes.question */:
+                    isPreviousTermQuantifiable = this.scanQuantifier(start, isPreviousTermQuantifiable);
+                    continue;
+                case 46 /* CharacterCodes.dot */:
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    isPreviousTermQuantifiable = true;
+                    continue;
+                case 91 /* CharacterCodes.openBracket */:
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    if (this.unicodeSetsMode)
+                        this.scanClassSetExpression();
+                    else
+                        this.scanClassRanges();
+                    this.scanExpectedChar(93 /* CharacterCodes.closeBracket */);
+                    isPreviousTermQuantifiable = true;
+                    continue;
+                case 41 /* CharacterCodes.closeParen */:
+                case 93 /* CharacterCodes.closeBracket */:
+                case 125 /* CharacterCodes.closeBrace */:
+                    if (ch === 41 /* CharacterCodes.closeParen */ && isInGroup)
+                        return;
+                    if (this.anyUnicodeModeOrNonAnnexB || ch === 41 /* CharacterCodes.closeParen */)
+                        this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
+                            String.fromCharCode(ch),
+                        ]);
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    isPreviousTermQuantifiable = true;
+                    continue;
+                case 47 /* CharacterCodes.slash */:
+                case 124 /* CharacterCodes.bar */:
+                    return;
+                default:
+                    this.scanSourceCharacter();
+                    isPreviousTermQuantifiable = true;
+                    continue;
+            }
+        }
+    }
+    /** Scans the last character of a quantifier and an optional `?`; returns false. */
+    scanQuantifier(start, isPreviousTermQuantifiable) {
+        this.scanner.pos = (this.scanner.pos + 1) | 0;
+        if (this.char() === 63 /* CharacterCodes.question */)
+            this.scanner.pos = (this.scanner.pos + 1) | 0; // non-greedy
+        if (!isPreviousTermQuantifiable)
+            this.error(422 /* Diagnostics.There_is_nothing_available_for_repetition */, start, this.scanner.pos - start, noArgs);
+        return false;
+    }
+    scanPatternModifiers(currentFlags) {
+        while (this.scanner.pos < this.end) {
+            const ch = codePointAt(this.text, this.scanner.pos, this.end);
+            if (ch === 65533 /* CharacterCodes.replacementCharacter */ || !isIdentifierPart(ch))
+                break;
+            const size = charSize(ch);
+            const flag = regularExpressionFlag(ch);
+            if (flag === 0 /* RegularExpressionFlags.None */)
+                this.error(414 /* Diagnostics.Unknown_regular_expression_flag */, this.scanner.pos, size, noArgs);
+            else if ((currentFlags & flag) !== 0)
+                this.error(415 /* Diagnostics.Duplicate_regular_expression_flag */, this.scanner.pos, size, noArgs);
+            else if ((flag & 28 /* RegularExpressionFlags.Modifiers */) === 0)
+                this.error(424 /* Diagnostics.This_regular_expression_flag_cannot_be_toggled_within_a_subpattern */, this.scanner.pos, size, noArgs);
+            else {
+                currentFlags |= flag;
+                this.scanner.checkRegularExpressionFlagAvailability(flag, this.scanner.pos, size);
+            }
+            this.scanner.pos = (this.scanner.pos + size) | 0;
+        }
+        return currentFlags;
+    }
+    // AtomEscape ::= DecimalEscape | CharacterClassEscape | CharacterEscape | 'k<' RegExpIdentifierName '>'
+    scanAtomEscape(ch) {
+        switch (ch) {
+            case 107 /* CharacterCodes.k */:
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                if (this.char() === 60 /* CharacterCodes.lessThan */) {
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    this.scanGroupName(true);
+                    this.scanExpectedChar(62 /* CharacterCodes.greaterThan */);
+                }
+                else if (this.anyUnicodeModeOrNonAnnexB || this.namedCaptureGroups) {
+                    this.error(425 /* Diagnostics.X_k_must_be_followed_by_a_capturing_group_name_enclosed_in_angle_brackets */, this.scanner.pos - 2, 2, noArgs);
+                }
+                return;
+            case 113 /* CharacterCodes.q */:
+                if (this.unicodeSetsMode) {
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    this.error(426 /* Diagnostics.X_q_is_only_available_inside_character_class */, this.scanner.pos - 2, 2, noArgs);
+                    return;
+                }
+                break;
+        }
+        // Regex literals cannot contain line breaks, so a character escape always consumes something.
+        if (!this.scanCharacterClassEscape() && !this.scanDecimalEscape())
+            this.scanCharacterEscape(true);
+    }
+    // DecimalEscape ::= [1-9] [0-9]*
+    scanDecimalEscape() {
+        const ch = this.char();
+        if (ch < 49 /* CharacterCodes._1 */ || ch > 57 /* CharacterCodes._9 */)
+            return false;
+        const start = this.scanner.pos;
+        const digits = this.scanDigits();
+        this.decimalEscapes.push(new DecimalEscape(start, this.scanner.pos, Number(digits)));
+        return true;
+    }
+    // CharacterEscape ::= 'c' ControlLetter | IdentityEscape | (sequences handled by scanEscapeSequence)
+    scanCharacterEscape(atomEscape) {
+        let ch = this.char();
+        switch (ch) {
+            case -1 /* CharacterCodes.EOF */:
+                this.error(428 /* Diagnostics.Undetermined_character_escape */, this.scanner.pos - 1, 1, noArgs);
+                return 92 /* CharacterCodes.backslash */;
+            case 99 /* CharacterCodes.c */:
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                ch = this.char();
+                if (isASCIILetter(ch)) {
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    return ch & 0x1f;
+                }
+                if (this.anyUnicodeModeOrNonAnnexB) {
+                    this.error(427 /* Diagnostics.X_c_must_be_followed_by_an_ASCII_letter */, this.scanner.pos - 2, 2, noArgs);
+                }
+                else if (atomEscape) {
+                    this.scanner.pos = (this.scanner.pos - 1) | 0;
+                    return 92 /* CharacterCodes.backslash */;
+                }
+                return ch < 0 ? 65533 /* CharacterCodes.replacementCharacter */ : ch;
+            case 94 /* CharacterCodes.caret */:
+            case 36 /* CharacterCodes.$ */:
+            case 47 /* CharacterCodes.slash */:
+            case 92 /* CharacterCodes.backslash */:
+            case 46 /* CharacterCodes.dot */:
+            case 42 /* CharacterCodes.asterisk */:
+            case 43 /* CharacterCodes.plus */:
+            case 63 /* CharacterCodes.question */:
+            case 40 /* CharacterCodes.openParen */:
+            case 41 /* CharacterCodes.closeParen */:
+            case 91 /* CharacterCodes.openBracket */:
+            case 93 /* CharacterCodes.closeBracket */:
+            case 123 /* CharacterCodes.openBrace */:
+            case 125 /* CharacterCodes.closeBrace */:
+            case 124 /* CharacterCodes.bar */:
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                return ch;
+            default: {
+                this.scanner.pos = (this.scanner.pos - 1) | 0; // include the backslash
+                let flags = 4 /* EscapeSequenceScanningFlags.RegularExpression */;
+                if (this.annexB)
+                    flags |= 8 /* EscapeSequenceScanningFlags.AnnexB */;
+                if (this.anyUnicodeMode)
+                    flags |= 16 /* EscapeSequenceScanningFlags.AnyUnicodeMode */;
+                if (atomEscape)
+                    flags |= 32 /* EscapeSequenceScanningFlags.AtomEscape */;
+                const value = this.scanner.scanEscapeCodePoint(flags);
+                return value === -2 /* EscapeValue.Raw */ ? -2 /* ClassValue.String */ : value;
+            }
+        }
+    }
+    scanGroupName(isReference) {
+        const scanner = this.scanner;
+        scanner.tokenStart = this.scanner.pos | 0;
+        scanner.scanIdentifier(0);
+        const start = scanner.tokenStart;
+        if (this.scanner.pos === start) {
+            this.error(429 /* Diagnostics.Expected_a_capturing_group_name */, this.scanner.pos, 0, noArgs);
+            return;
+        }
+        const name = scanner.getTokenValue();
+        if (isReference) {
+            this.groupNameReferences.push(new GroupNameReference(start, this.scanner.pos, name));
+        }
+        else if (this.namedCapturingGroupsContains(name)) {
+            this.error(430 /* Diagnostics.Named_capturing_groups_with_the_same_name_must_be_mutually_exclusive_to_each_other */, start, this.scanner.pos - start, noArgs);
+        }
+        else {
+            if (this.namedCapturingGroups.length > 0)
+                this.namedCapturingGroups[this.namedCapturingGroups.length - 1].add(name);
+            this.groupSpecifiers.add(name);
+        }
+    }
+    namedCapturingGroupsContains(name) {
+        for (const group of this.namedCapturingGroups)
+            if (group.has(name))
+                return true;
+        return false;
+    }
+    isClassContentExit(ch) {
+        return ch === 93 /* CharacterCodes.closeBracket */ || this.scanner.pos >= this.end;
+    }
+    // ClassRanges ::= '^'? (ClassAtom ('-' ClassAtom)?)*
+    // Returns MayContainStrings, which is false for class ranges.
+    scanClassRanges() {
+        if (this.char() === 94 /* CharacterCodes.caret */)
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+        while (this.scanner.pos < this.end) {
+            if (this.isClassContentExit(this.char()))
+                return false;
+            const minStart = this.scanner.pos;
+            const min = this.scanClassAtom();
+            if (this.char() !== 45 /* CharacterCodes.minus */)
+                continue;
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+            if (this.isClassContentExit(this.char()))
+                return false;
+            if (min === -1 /* ClassValue.None */ && this.anyUnicodeModeOrNonAnnexB)
+                this.error(431 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, minStart, this.scanner.pos - 1 - minStart, noArgs);
+            const maxStart = this.scanner.pos;
+            const max = this.scanClassAtom();
+            if (max === -1 /* ClassValue.None */ && this.anyUnicodeModeOrNonAnnexB) {
+                this.error(431 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, maxStart, this.scanner.pos - maxStart, noArgs);
+                continue;
+            }
+            if (min >= 0 && max >= 0 && min > max)
+                this.error(432 /* Diagnostics.Range_out_of_order_in_character_class */, minStart, this.scanner.pos - minStart, noArgs);
+        }
+        return false;
+    }
+    // ClassSetExpression ::= '^'? (ClassUnion | ClassIntersection | ClassSubtraction)
+    // ClassUnion ::= (ClassSetRange | ClassSetOperand)*
+    // ClassIntersection ::= ClassSetOperand ('&&' ClassSetOperand)+
+    // ClassSubtraction ::= ClassSetOperand ('--' ClassSetOperand)+
+    // ClassSetRange ::= ClassSetCharacter '-' ClassSetCharacter
+    //
+    // mayContainStrings tracks the MayContainStrings static semantics: some operand of a
+    // union, every operand of an intersection, or the first operand of a subtraction.
+    scanClassSetExpression() {
+        let isCharacterComplement = false;
+        if (this.char() === 94 /* CharacterCodes.caret */) {
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+            isCharacterComplement = true;
+        }
+        let expressionMayContainStrings = false;
+        let ch = this.char();
+        if (this.isClassContentExit(ch))
+            return this.mayContainStrings;
+        let start = this.scanner.pos;
+        let operand = -1 /* ClassValue.None */;
+        if (this.isDoublePunctuatorOperator()) {
+            this.error(435 /* Diagnostics.Expected_a_class_set_operand */, this.scanner.pos, 0, noArgs);
+            this.mayContainStrings = false;
+        }
+        else {
+            operand = this.scanClassSetOperand();
+        }
+        switch (this.char()) {
+            case 45 /* CharacterCodes.minus */:
+                if (this.scanner.pos + 1 < this.end && this.charAt(this.scanner.pos + 1) === 45 /* CharacterCodes.minus */) {
+                    if (isCharacterComplement && this.mayContainStrings)
+                        this.error(433 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, start, this.scanner.pos - start, noArgs);
+                    expressionMayContainStrings = this.mayContainStrings;
+                    this.scanClassSetSubExpression(3 /* ClassSetExpressionType.ClassSubtraction */);
+                    this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+                    return this.mayContainStrings;
+                }
+                break;
+            case 38 /* CharacterCodes.ampersand */:
+                if (this.scanner.pos + 1 < this.end && this.charAt(this.scanner.pos + 1) === 38 /* CharacterCodes.ampersand */) {
+                    this.scanClassSetSubExpression(2 /* ClassSetExpressionType.ClassIntersection */);
+                    if (isCharacterComplement && this.mayContainStrings)
+                        this.error(433 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, start, this.scanner.pos - start, noArgs);
+                    expressionMayContainStrings = this.mayContainStrings;
+                    this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+                    return this.mayContainStrings;
+                }
+                this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
+                    String.fromCharCode(ch),
+                ]);
+                break;
+            default:
+                if (isCharacterComplement && this.mayContainStrings)
+                    this.error(433 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, start, this.scanner.pos - start, noArgs);
+                expressionMayContainStrings = this.mayContainStrings;
+                break;
+        }
+        while (this.scanner.pos < this.end) {
+            ch = this.char();
+            if (ch === 45 /* CharacterCodes.minus */) {
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                ch = this.char();
+                if (this.isClassContentExit(ch)) {
+                    this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+                    return this.mayContainStrings;
+                }
+                if (ch === 45 /* CharacterCodes.minus */) {
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
+                    start = this.scanner.pos - 2;
+                    operand = -2 /* ClassValue.String */;
+                    continue;
+                }
+                if (operand === -1 /* ClassValue.None */)
+                    this.error(431 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, start, this.scanner.pos - 1 - start, noArgs);
+                const secondStart = this.scanner.pos;
+                const secondOperand = this.scanClassSetOperand();
+                if (isCharacterComplement && this.mayContainStrings)
+                    this.error(433 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, secondStart, this.scanner.pos - secondStart, noArgs);
+                expressionMayContainStrings = expressionMayContainStrings || this.mayContainStrings;
+                if (secondOperand === -1 /* ClassValue.None */) {
+                    this.error(431 /* Diagnostics.A_character_class_range_must_not_be_bounded_by_another_character_class */, secondStart, this.scanner.pos - secondStart, noArgs);
+                }
+                else if (operand >= 0 && secondOperand >= 0 && operand > secondOperand) {
+                    this.error(432 /* Diagnostics.Range_out_of_order_in_character_class */, start, this.scanner.pos - start, noArgs);
+                }
+            }
+            else if (ch === 38 /* CharacterCodes.ampersand */) {
+                start = this.scanner.pos;
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                if (this.char() === 38 /* CharacterCodes.ampersand */) {
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
+                    if (this.char() === 38 /* CharacterCodes.ampersand */) {
+                        this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
+                            String.fromCharCode(ch),
+                        ]);
+                        this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    }
+                }
+                else {
+                    this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos - 1, 1, [
+                        String.fromCharCode(ch),
+                    ]);
+                }
+                operand = this.scanner.pos - start === 1 ? 38 /* CharacterCodes.ampersand */ : -2 /* ClassValue.String */;
+                continue;
+            }
+            if (this.isClassContentExit(this.char()))
+                break;
+            start = this.scanner.pos;
+            if (this.isDoublePunctuatorOperator()) {
+                this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos, 2, noArgs);
+                this.scanner.pos = (this.scanner.pos + 2) | 0;
+                operand = -2 /* ClassValue.String */;
+            }
+            else {
+                operand = this.scanClassSetOperand();
+            }
+        }
+        this.mayContainStrings = !isCharacterComplement && expressionMayContainStrings;
+        return this.mayContainStrings;
+    }
+    /** Whether `--` or `&&` starts at the current position. */
+    isDoublePunctuatorOperator() {
+        if (this.scanner.pos + 1 >= this.end)
+            return false;
+        const ch = this.text.charCodeAt(this.scanner.pos);
+        return ((ch === 45 /* CharacterCodes.minus */ || ch === 38 /* CharacterCodes.ampersand */) &&
+            this.text.charCodeAt(this.scanner.pos + 1) === ch);
+    }
+    scanClassSetSubExpression(expressionType) {
+        let expressionMayContainStrings = this.mayContainStrings;
+        while (this.scanner.pos < this.end) {
+            let ch = this.char();
+            if (this.isClassContentExit(ch))
+                break;
+            if (ch === 45 /* CharacterCodes.minus */) {
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                if (this.char() === 45 /* CharacterCodes.minus */) {
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    if (expressionType !== 3 /* ClassSetExpressionType.ClassSubtraction */)
+                        this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
+                }
+                else {
+                    this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 1, 1, noArgs);
+                }
+            }
+            else if (ch === 38 /* CharacterCodes.ampersand */) {
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                if (this.char() === 38 /* CharacterCodes.ampersand */) {
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    if (expressionType !== 2 /* ClassSetExpressionType.ClassIntersection */)
+                        this.error(434 /* Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead */, this.scanner.pos - 2, 2, noArgs);
+                    if (this.char() === 38 /* CharacterCodes.ampersand */) {
+                        this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
+                            String.fromCharCode(ch),
+                        ]);
+                        this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    }
+                }
+                else {
+                    this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos - 1, 1, [
+                        String.fromCharCode(ch),
+                    ]);
+                }
+            }
+            else if (expressionType === 3 /* ClassSetExpressionType.ClassSubtraction */) {
+                this.error(2 /* Diagnostics.X_0_expected */, this.scanner.pos, 0, ['--']);
+            }
+            else if (expressionType === 2 /* ClassSetExpressionType.ClassIntersection */) {
+                this.error(2 /* Diagnostics.X_0_expected */, this.scanner.pos, 0, ['&&']);
+            }
+            ch = this.char();
+            if (this.isClassContentExit(ch)) {
+                this.error(435 /* Diagnostics.Expected_a_class_set_operand */, this.scanner.pos, 0, noArgs);
+                break;
+            }
+            this.scanClassSetOperand();
+            if (expressionType === 2 /* ClassSetExpressionType.ClassIntersection */)
+                expressionMayContainStrings = expressionMayContainStrings && this.mayContainStrings;
+        }
+        this.mayContainStrings = expressionMayContainStrings;
+    }
+    // ClassSetOperand ::= '[' ClassSetExpression ']' | '\' CharacterClassEscape | '\q{' ClassStringDisjunctionContents '}' | ClassSetCharacter
+    scanClassSetOperand() {
+        this.mayContainStrings = false;
+        const ch = this.char();
+        if (ch === 91 /* CharacterCodes.openBracket */) {
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+            this.scanClassSetExpression();
+            this.scanExpectedChar(93 /* CharacterCodes.closeBracket */);
+            return -1 /* ClassValue.None */;
+        }
+        if (ch === 92 /* CharacterCodes.backslash */) {
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+            if (this.scanCharacterClassEscape())
+                return -1 /* ClassValue.None */;
+            if (this.char() === 113 /* CharacterCodes.q */) {
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                if (this.char() === 123 /* CharacterCodes.openBrace */) {
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    this.scanClassStringDisjunctionContents();
+                    this.scanExpectedChar(125 /* CharacterCodes.closeBrace */);
+                    return -1 /* ClassValue.None */;
+                }
+                this.error(436 /* Diagnostics.X_q_must_be_followed_by_string_alternatives_enclosed_in_braces */, this.scanner.pos - 2, 2, noArgs);
+                return 113 /* CharacterCodes.q */;
+            }
+            this.scanner.pos = (this.scanner.pos - 1) | 0;
+        }
+        return this.scanClassSetCharacter();
+    }
+    // ClassStringDisjunctionContents ::= ClassSetCharacter* ('|' ClassSetCharacter*)*
+    scanClassStringDisjunctionContents() {
+        let characterCount = 0;
+        while (this.scanner.pos < this.end) {
+            const ch = this.char();
+            if (ch === 125 /* CharacterCodes.closeBrace */) {
+                if (characterCount !== 1)
+                    this.mayContainStrings = true;
+                return this.mayContainStrings;
+            }
+            if (ch === 124 /* CharacterCodes.bar */) {
+                if (characterCount !== 1)
+                    this.mayContainStrings = true;
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                characterCount = 0;
+            }
+            else {
+                this.scanClassSetCharacter();
+                characterCount++;
+            }
+        }
+        return this.mayContainStrings;
+    }
+    // ClassSetCharacter ::= SourceCharacter -- ClassSetSyntaxCharacter -- ClassSetReservedDoublePunctuator
+    //   | '\' (CharacterEscape | ClassSetReservedPunctuator | 'b')
+    scanClassSetCharacter() {
+        const ch = this.char();
+        if (ch === 92 /* CharacterCodes.backslash */) {
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+            const inner = this.char();
+            switch (inner) {
+                case 98 /* CharacterCodes.b */:
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    return 8 /* CharacterCodes.backspace */;
+                case 38 /* CharacterCodes.ampersand */:
+                case 45 /* CharacterCodes.minus */:
+                case 33 /* CharacterCodes.exclamation */:
+                case 35 /* CharacterCodes.hash */:
+                case 37 /* CharacterCodes.percent */:
+                case 44 /* CharacterCodes.comma */:
+                case 58 /* CharacterCodes.colon */:
+                case 59 /* CharacterCodes.semicolon */:
+                case 60 /* CharacterCodes.lessThan */:
+                case 61 /* CharacterCodes.equals */:
+                case 62 /* CharacterCodes.greaterThan */:
+                case 64 /* CharacterCodes.at */:
+                case 96 /* CharacterCodes.backtick */:
+                case 126 /* CharacterCodes.tilde */:
+                    this.scanner.pos = (this.scanner.pos + 1) | 0;
+                    return inner;
+                default:
+                    return this.scanCharacterEscape(false);
+            }
+        }
+        if (this.scanner.pos + 1 < this.end && ch === this.charAt(this.scanner.pos + 1)) {
+            switch (ch) {
+                case 38 /* CharacterCodes.ampersand */:
+                case 33 /* CharacterCodes.exclamation */:
+                case 35 /* CharacterCodes.hash */:
+                case 37 /* CharacterCodes.percent */:
+                case 42 /* CharacterCodes.asterisk */:
+                case 43 /* CharacterCodes.plus */:
+                case 44 /* CharacterCodes.comma */:
+                case 46 /* CharacterCodes.dot */:
+                case 58 /* CharacterCodes.colon */:
+                case 59 /* CharacterCodes.semicolon */:
+                case 60 /* CharacterCodes.lessThan */:
+                case 61 /* CharacterCodes.equals */:
+                case 62 /* CharacterCodes.greaterThan */:
+                case 63 /* CharacterCodes.question */:
+                case 64 /* CharacterCodes.at */:
+                case 96 /* CharacterCodes.backtick */:
+                case 126 /* CharacterCodes.tilde */:
+                    this.error(437 /* Diagnostics.A_character_class_must_not_contain_a_reserved_double_punctuator_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 2, noArgs);
+                    this.scanner.pos = (this.scanner.pos + 2) | 0;
+                    return -2 /* ClassValue.String */;
+            }
+        }
+        switch (ch) {
+            case 47 /* CharacterCodes.slash */:
+            case 40 /* CharacterCodes.openParen */:
+            case 41 /* CharacterCodes.closeParen */:
+            case 91 /* CharacterCodes.openBracket */:
+            case 93 /* CharacterCodes.closeBracket */:
+            case 123 /* CharacterCodes.openBrace */:
+            case 125 /* CharacterCodes.closeBrace */:
+            case 45 /* CharacterCodes.minus */:
+            case 124 /* CharacterCodes.bar */:
+                this.error(423 /* Diagnostics.Unexpected_0_Did_you_mean_to_escape_it_with_backslash */, this.scanner.pos, 1, [
+                    String.fromCharCode(ch),
+                ]);
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                return ch;
+        }
+        return this.scanSourceCharacter();
+    }
+    // ClassAtom ::= SourceCharacter but not '\' or ']' | '\' ClassEscape
+    // ClassEscape ::= 'b' | '-' | CharacterClassEscape | CharacterEscape
+    scanClassAtom() {
+        if (this.char() !== 92 /* CharacterCodes.backslash */)
+            return this.scanSourceCharacter();
+        this.scanner.pos = (this.scanner.pos + 1) | 0;
+        const ch = this.char();
+        if (ch === 98 /* CharacterCodes.b */) {
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+            return 8 /* CharacterCodes.backspace */;
+        }
+        if (ch === 45 /* CharacterCodes.minus */) {
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+            return 45 /* CharacterCodes.minus */;
+        }
+        if (this.scanCharacterClassEscape())
+            return -1 /* ClassValue.None */;
+        return this.scanCharacterEscape(false);
+    }
+    // CharacterClassEscape ::= 'd' | 'D' | 's' | 'S' | 'w' | 'W'
+    //   | [+AnyUnicodeMode] ('P' | 'p') '{' UnicodePropertyValueExpression '}'
+    scanCharacterClassEscape() {
+        const start = this.scanner.pos - 1;
+        const ch = this.char();
+        switch (ch) {
+            case 100 /* CharacterCodes.d */:
+            case 68 /* CharacterCodes.D */:
+            case 115 /* CharacterCodes.s */:
+            case 83 /* CharacterCodes.S */:
+            case 119 /* CharacterCodes.w */:
+            case 87 /* CharacterCodes.W */:
+                this.scanner.pos = (this.scanner.pos + 1) | 0;
+                return true;
+            case 80 /* CharacterCodes.P */:
+            case 112 /* CharacterCodes.p */:
+                break;
+            default:
+                return false;
+        }
+        const isCharacterComplement = ch === 80 /* CharacterCodes.P */;
+        this.scanner.pos = (this.scanner.pos + 1) | 0;
+        if (this.char() !== 123 /* CharacterCodes.openBrace */) {
+            if (!this.anyUnicodeModeOrNonAnnexB) {
+                this.scanner.pos = (this.scanner.pos - 1) | 0;
+                return false;
+            }
+            this.error(446 /* Diagnostics.X_0_must_be_followed_by_a_Unicode_property_value_expression_enclosed_in_braces */, this.scanner.pos - 2, 2, [String.fromCharCode(ch)]);
+            return true;
+        }
+        this.scanner.pos = (this.scanner.pos + 1) | 0;
+        const nameOrValueStart = this.scanner.pos;
+        const nameOrValue = this.scanWordCharacters();
+        if (this.char() === 61 /* CharacterCodes.equals */) {
+            const propertyName = nonBinaryUnicodeProperties.get(nameOrValue) ?? '';
+            if (this.scanner.pos === nameOrValueStart) {
+                this.error(438 /* Diagnostics.Expected_a_Unicode_property_name */, this.scanner.pos, 0, noArgs);
+            }
+            else if (propertyName === '') {
+                this.error(439 /* Diagnostics.Unknown_Unicode_property_name */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
+                const suggestion = getSpellingSuggestion(nameOrValue, mapKeys(nonBinaryUnicodeProperties));
+                if (suggestion !== '')
+                    this.error(303 /* Diagnostics.Did_you_mean_0 */, nameOrValueStart, this.scanner.pos - nameOrValueStart, [suggestion]);
+            }
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+            const valueStart = this.scanner.pos;
+            const value = this.scanWordCharacters();
+            if (this.scanner.pos === valueStart) {
+                this.error(440 /* Diagnostics.Expected_a_Unicode_property_value */, this.scanner.pos, 0, noArgs);
+            }
+            else if (propertyName !== '') {
+                const values = valuesOfNonBinaryUnicodeProperty(propertyName);
+                if (!values.has(value)) {
+                    this.error(441 /* Diagnostics.Unknown_Unicode_property_value */, valueStart, this.scanner.pos - valueStart, noArgs);
+                    const suggestion = getSpellingSuggestion(value, setToArray(values));
+                    if (suggestion !== '')
+                        this.error(303 /* Diagnostics.Did_you_mean_0 */, valueStart, this.scanner.pos - valueStart, [suggestion]);
+                }
+            }
+        }
+        else if (this.scanner.pos === nameOrValueStart) {
+            this.error(442 /* Diagnostics.Expected_a_Unicode_property_name_or_value */, this.scanner.pos, 0, noArgs);
+        }
+        else if (binaryUnicodePropertiesOfStrings.has(nameOrValue)) {
+            if (!this.unicodeSetsMode)
+                this.error(443 /* Diagnostics.Any_Unicode_property_that_would_possibly_match_more_than_a_single_character_is_only_available_when_the_Unicode_Sets_v_flag_is_set */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
+            else if (isCharacterComplement)
+                this.error(433 /* Diagnostics.Anything_that_would_possibly_match_more_than_a_single_character_is_invalid_inside_a_negated_character_class */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
+            else
+                this.mayContainStrings = true;
+        }
+        else if (!generalCategoryValues.has(nameOrValue) && !binaryUnicodeProperties.has(nameOrValue)) {
+            this.error(444 /* Diagnostics.Unknown_Unicode_property_name_or_value */, nameOrValueStart, this.scanner.pos - nameOrValueStart, noArgs);
+            const candidates = setToArray(generalCategoryValues);
+            for (const name of binaryUnicodeProperties)
+                candidates.push(name);
+            for (const name of binaryUnicodePropertiesOfStrings)
+                candidates.push(name);
+            const suggestion = getSpellingSuggestion(nameOrValue, candidates);
+            if (suggestion !== '')
+                this.error(303 /* Diagnostics.Did_you_mean_0 */, nameOrValueStart, this.scanner.pos - nameOrValueStart, [suggestion]);
+        }
+        this.scanExpectedChar(125 /* CharacterCodes.closeBrace */);
+        if (!this.anyUnicodeMode)
+            this.error(445 /* Diagnostics.Unicode_property_value_expressions_are_only_available_when_the_Unicode_u_flag_or_the_Unicode_Sets_v_flag_is_set */, start, this.scanner.pos - start, noArgs);
+        return true;
+    }
+    scanWordCharacters() {
+        const start = this.scanner.pos;
+        while (this.scanner.pos < this.end && isWordCharacter(this.char()))
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+        return this.text.substring(start, this.scanner.pos);
+    }
+    /** One code point in Unicode modes, otherwise one UTF-16 code unit. */
+    scanSourceCharacter() {
+        if (this.scanner.pos >= this.end)
+            return -1 /* ClassValue.None */;
+        if (!this.anyUnicodeMode) {
+            const ch = this.scanner.chars[this.scanner.pos];
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+            return ch;
+        }
+        const ch = this.scanner.codePointAt(this.scanner.pos, this.end);
+        this.scanner.pos = (this.scanner.pos + charSize(ch)) | 0;
+        // Like TypeScript 7, treat U+FFFD as an undecodable character.
+        return ch === 65533 /* CharacterCodes.replacementCharacter */ ? -1 /* ClassValue.None */ : ch;
+    }
+    scanExpectedChar(ch) {
+        if (this.char() === ch)
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+        else
+            this.error(2 /* Diagnostics.X_0_expected */, this.scanner.pos, 0, [String.fromCharCode(ch)]);
+    }
+    scanDigits() {
+        const start = this.scanner.pos;
+        while (this.scanner.pos < this.end && isDigit(this.char()))
+            this.scanner.pos = (this.scanner.pos + 1) | 0;
+        return this.text.substring(start, this.scanner.pos);
+    }
+}