tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/scanner.d.ts

@@ -0,0 +1,256 @@
+import type { DiagnosticMessage } from './diagnostics.js';
+import { EscapeSequenceScanningFlags, RegularExpressionFlags } from './regexp-checker.js';
+import { SyntaxKind } from './syntax-kind.js';
+import { CommentDirective, CommentRange, LanguageVariant, ScriptTarget, TokenFlags } from './types.js';
+export { isIdentifierPart, isIdentifierStart } from './character-codes.js';
+export { EscapeSequenceScanningFlags, EscapeValue } from './regexp-checker.js';
+/** The keyword kind of `text`, or `Identifier`. */
+export declare function getIdentifierToken(text: string): SyntaxKind;
+/** The keyword kind of an identifier's text, or `Unknown`. */
+export declare function identifierToKeywordKind(text: string): SyntaxKind;
+export declare function tokenToString(kind: SyntaxKind): string;
+export declare function stringToToken(text: string): SyntaxKind;
+/** Keywords longer than two characters, for spelling suggestions. */
+export declare function getViableKeywordSuggestions(): string[];
+export declare function tokenIsIdentifierOrKeyword(token: SyntaxKind): boolean;
+/** Whether `name` is a valid identifier (JSX names may contain `-` and `:`). */
+export declare function isIdentifierText(name: string, languageVariant?: LanguageVariant): boolean;
+/** Receives scanner diagnostics. An abstract class rather than a function so native builds dispatch statically. */
+export declare abstract class ScannerErrorReporter {
+    abstract onError(message: DiagnosticMessage, start: number, length: number, args: readonly string[]): void;
+}
+/** A snapshot of the scanner's token state for `Scanner.rewind`. */
+export declare class ScannerState {
+    pos: number;
+    fullStartPos: number;
+    tokenStart: number;
+    token: SyntaxKind;
+    tokenFlags: TokenFlags;
+    tokenValue: string;
+    valueStart: number;
+    valueEnd: number;
+    commentDirectiveCount: number;
+    skipJSDocLeadingAsterisks: number;
+    constructor(pos: number, fullStartPos: number, tokenStart: number, token: SyntaxKind, tokenFlags: TokenFlags, tokenValue: string, valueStart: number, valueEnd: number, commentDirectiveCount: number, skipJSDocLeadingAsterisks: number);
+    /** @internal Overwrites this snapshot with the scanner's current state, like `Scanner.mark`. */
+    assign(scanner: Scanner): void;
+}
+/**
+ * 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 declare class Scanner {
+    /** @internal */ text: string;
+    /** @internal */ chars: Uint16Array;
+    /** @internal */ end: number;
+    private languageVariant;
+    private scriptTarget;
+    private onError;
+    private skipTrivia;
+    /** @internal Current position; the end of the current token. */
+    pos: number;
+    /** @internal */ fullStartPos: number;
+    /** @internal */ tokenStart: number;
+    /** @internal */ token: SyntaxKind;
+    /** @internal */ tokenFlags: TokenFlags;
+    /** @internal */ tokenValue: string;
+    /** @internal */ valueStart: number;
+    /** @internal */ valueEnd: number;
+    private valueHash;
+    private hashStart;
+    private hashEnd;
+    /** @internal */ commentDirectives: CommentDirective[];
+    /** @internal */ skipJSDocLeadingAsterisks: number;
+    private readonly cutUnits;
+    private readonly identifiers;
+    private loadedBlocks;
+    private textKind;
+    private lineFeedFrom;
+    private lineFeedAt;
+    private carriageReturnFrom;
+    private 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?: string, unitsOnDemand?: boolean);
+    /** Sets the text to scan and resets the token state. */
+    setText(text: string): void;
+    /** @internal Like `setText(text.substring(0, end))` without copying, but keeps comment directives; pass the text length to undo. */
+    setTextEnd(end: number): void;
+    /**
+     * @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: number, end: number): void;
+    setOnError(reporter: ScannerErrorReporter | undefined): void;
+    setLanguageVariant(languageVariant: LanguageVariant): void;
+    setScriptTarget(scriptTarget: ScriptTarget): void;
+    /** When false, `scan` returns whitespace, newline and comment trivia tokens. */
+    setSkipTrivia(skip: boolean): void;
+    /** Nests skipping of JSDoc leading `*` after line breaks; balance every `true` with a `false`. */
+    setSkipJSDocLeadingAsterisks(skip: boolean): void;
+    getText(): string;
+    getToken(): SyntaxKind;
+    getTokenFlags(): TokenFlags;
+    /** Start of the token including leading trivia. */
+    getTokenFullStart(): number;
+    getTokenStart(): number;
+    getTokenEnd(): number;
+    getTokenText(): string;
+    /** The cooked value: identifier text, string contents, normalized number, etc. */
+    getTokenValue(): string;
+    /**
+     * 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: string): boolean;
+    /** @internal Like `getTokenValue`, but identifiers with the same text share one string. */
+    getIdentifierValue(): string;
+    getCommentDirectives(): readonly CommentDirective[];
+    hasUnicodeEscape(): boolean;
+    hasExtendedUnicodeEscape(): boolean;
+    hasPrecedingLineBreak(): boolean;
+    hasPrecedingJSDocComment(): boolean;
+    hasPrecedingJSDocLeadingAsterisks(): boolean;
+    hasPrecedingJSDocWithDeprecatedTag(): boolean;
+    hasPrecedingJSDocWithSeeOrLink(): boolean;
+    isUnterminated(): boolean;
+    mark(): ScannerState;
+    rewind(state: ScannerState): void;
+    /** Runs `callback` and restores the scanner state afterwards. */
+    lookAhead<T>(callback: () => T): T;
+    /** Runs `callback` and restores the scanner state if it returns `undefined`. */
+    tryScan<T>(callback: () => T | undefined): T | undefined;
+    /** Moves to `pos` without changing the current token. */
+    resetPos(pos: number): void;
+    resetTokenState(pos: number): void;
+    /** @internal */
+    languageVersion(): ScriptTarget;
+    private error;
+    /** @internal */
+    errorAt(message: DiagnosticMessage, start: number, length: number, args: readonly string[]): void;
+    /** @internal The code unit at `pos`, or -1 at the end. */
+    char(): number;
+    /** @internal The code unit at `pos + offset`, or -1 past the end. */
+    peek(offset: number): number;
+    /** @internal The code point at `pos`, or -1 at the end. */
+    codePoint(): number;
+    /** @internal The code point at `pos`, combining a surrogate pair; -1 at or past `end`. */
+    codePointAt(pos: number, end: number): number;
+    /** The code point ending just before `pos`; -1 at the start. */
+    private codePointBefore;
+    private setValue;
+    private setValueSlice;
+    scan(): SyntaxKind;
+    /** The kind of the identifier just scanned by `scanIdentifier`. */
+    private identifierKind;
+    /** The line breaks the text holds, found once per text. */
+    private getTextKind;
+    /**
+     * 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.
+     */
+    private lineCommentEnd;
+    /**
+     * 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.
+     */
+    private nextLineFeed;
+    /** Like `nextLineFeed`, for CR: a text with LF line breaks and few CRs is searched once. */
+    private nextCarriageReturn;
+    /** Scans `/* … *\/`; returns true if the comment is skipped as trivia. */
+    private scanMultiLineComment;
+    /** Scans a merge conflict marker; returns true if it is skipped as trivia. */
+    private scanConflictMarker;
+    private processCommentDirective;
+    /** @internal Scans an identifier after `prefixLength` units; sets the token value. */
+    scanIdentifier(prefixLength: number): boolean;
+    /** Scans identifier parts including `\u` escapes and returns their cooked text. */
+    private scanIdentifierParts;
+    private scanInvalidCharacter;
+    /** Scans a quoted string and sets its cooked value. */
+    private scanString;
+    /** Scans a template literal part starting at `` ` `` or `}`. */
+    private scanTemplateAndSetTokenValue;
+    /** Scans an escape sequence at `\` and returns its cooked value. */
+    private scanEscapeSequence;
+    /**
+     * @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: EscapeSequenceScanningFlags): number;
+    /** After a high surrogate escape: the low surrogate of a following `\u` escape, or -1. */
+    private scanLowSurrogateEscape;
+    /** Scans `\uXXXX` or `\u{X…}` at `pos`; returns the code point or -1 if invalid. */
+    private scanUnicodeEscape;
+    /** At `\`: the code point of a following `\u` escape, or -1. Leaves the scanner unchanged. */
+    private peekUnicodeEscape;
+    /** Scans hex digits (no separators) and returns their value, or -1 if fewer than `minCount`. */
+    private scanHexValue;
+    /** `text[start, end)` without numeric separators. */
+    private withoutSeparators;
+    private scanNumber;
+    /** Scans decimal digits with numeric separators; returns how many digits. */
+    private scanNumberFragment;
+    /** Scans digits of a `0x`, `0b` or `0o` literal (allowing separators); returns how many. */
+    private scanSpecifierDigits;
+    private scanHexNumber;
+    private scanBinaryOrOctalNumber;
+    /** Completes a numeric literal whose value is set: a `n` suffix makes it a bigint. */
+    private scanBigIntSuffix;
+    /** Splits `<<` into `<`. */
+    reScanLessThanToken(): SyntaxKind;
+    /** Joins `>` with following `>`, `>=`, `>>`, `>>=` or `=`. */
+    reScanGreaterThanToken(): SyntaxKind;
+    /** Rescans a `}` as a template middle or tail. */
+    reScanTemplateToken(isTaggedTemplate: boolean): SyntaxKind;
+    /** Splits `*=` into `*` and `=`, returning `=`. */
+    reScanAsteriskEqualsToken(): SyntaxKind;
+    /** Rescans `/` or `/=` as a regular expression literal, optionally checking its syntax. */
+    reScanSlashToken(reportErrors?: boolean): SyntaxKind;
+    /** @internal Reports a regular expression flag unavailable at the current target. */
+    checkRegularExpressionFlagAvailability(flag: RegularExpressionFlags, pos: number, size: number): void;
+    /** Rescans from the token's full start as JSX text or a JSX token. */
+    reScanJsxToken(allowMultilineJsxText?: boolean): SyntaxKind;
+    /** Splits a private identifier into `#` and the name. */
+    reScanHashToken(): SyntaxKind;
+    /** Splits `??` into `?`. */
+    reScanQuestionToken(): SyntaxKind;
+    /** Scans JSX children: text, `<`, `</` or `{`. */
+    scanJsxToken(allowMultilineJsxText?: boolean): SyntaxKind;
+    /** Extends an identifier or keyword with `-` and further parts, as JSX names allow. */
+    scanJsxIdentifier(): SyntaxKind;
+    /** Scans a JSX attribute value after `=`: a string, or any other token. */
+    scanJsxAttributeValue(): SyntaxKind;
+    reScanJsxAttributeValue(): SyntaxKind;
+    /** Scans JSDoc comment text up to a line break, backtick, `{` or tag; falls back to `scanJSDocToken`. */
+    scanJSDocCommentTextToken(inBackticks: boolean): SyntaxKind;
+    /** After `@`: whether a tag name (or an incomplete tag) can follow. */
+    canFollowJSDocAt(): boolean;
+    scanJSDocToken(): SyntaxKind;
+}
+/** Whether `text` has a `<<<<<<<`, `|||||||`, `=======` or `>>>>>>>` marker at `pos`. */
+export declare function isConflictMarkerTrivia(text: string, pos: number): boolean;
+/** The `#!` line at the start of `text`, or `''`. */
+export declare function getShebang(text: string): string;
+/** Whether trivia could start at `pos`; a fast pre-check for `skipTrivia`. */
+export declare function couldStartTrivia(text: string, pos: number): boolean;
+/** Returns the position after whitespace, comments, conflict markers and a leading shebang. */
+export declare function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean, stopAtComments?: boolean, inJSDoc?: boolean): number;
+/** Comments before the next token at `pos`; those on the first line are skipped unless `pos` is 0. */
+export declare function getLeadingCommentRanges(text: string, pos: number): CommentRange[] | undefined;
+/** Comments after `pos` up to the next line break. */
+export declare function getTrailingCommentRanges(text: string, pos: number): CommentRange[] | undefined;
+/** Start positions of each line, split at CR, LF, CRLF, LS and PS. */
+export declare function computeLineStarts(text: string): number[];
+/** The zero-based line containing `pos`. */
+export declare function computeLineOfPosition(lineStarts: readonly number[], pos: number): number;