/* @internal */

namespace ts {

export const resolvingEmptyArray: never[] = [];

export const externalHelpersModuleNameText = "tslib";

export const defaultMaximumTruncationLength = 160;

export const noTruncationMaximumTruncationLength = 1_000_000;

export function getDeclarationOfKind<T extends Declaration>(symbol: Symbol, kind: T["kind"]): T | undefined {

const declarations = symbol.declarations;

if (declarations) {

for (const declaration of declarations) {

if (declaration.kind === kind) {

return declaration as T;

}

}

}

return undefined;

}

export function getDeclarationsOfKind<T extends Declaration>(symbol: Symbol, kind: T["kind"]): T[] {

return filter(symbol.declarations || emptyArray, d => d.kind === kind) as T[];

}

export function createSymbolTable(symbols?: readonly Symbol[]): SymbolTable {

const result = new Map<__String, Symbol>();

if (symbols) {

for (const symbol of symbols) {

result.set(symbol.escapedName, symbol);

}

}

return result;

}

export function isTransientSymbol(symbol: Symbol): symbol is TransientSymbol {

return (symbol.flags & SymbolFlags.Transient) !== 0;

}

const stringWriter = createSingleLineStringWriter();

function createSingleLineStringWriter(): EmitTextWriter {

let str = "";

const writeText: (text: string) => void = text => str += text;

return {

getText: () => str,

write: writeText,

rawWrite: writeText,

writeKeyword: writeText,

writeOperator: writeText,

writePunctuation: writeText,

writeSpace: writeText,

writeStringLiteral: writeText,

writeLiteral: writeText,

writeParameter: writeText,

writeProperty: writeText,

writeSymbol: (s, _) => writeText(s),

writeTrailingSemicolon: writeText,

writeComment: writeText,

getTextPos: () => str.length,

getLine: () => 0,

getColumn: () => 0,

getIndent: () => 0,

isAtStartOfLine: () => false,

hasTrailingComment: () => false,

hasTrailingWhitespace: () => !!str.length && isWhiteSpaceLike(str.charCodeAt(str.length - 1)),

// Completely ignore indentation for string writers. And map newlines to

// a single space.

writeLine: () => str += " ",

increaseIndent: noop,

decreaseIndent: noop,

clear: () => str = "",

trackSymbol: () => false,

reportInaccessibleThisError: noop,

reportInaccessibleUniqueSymbolError: noop,

reportPrivateInBaseOfClassExpression: noop,

};

}

export function changesAffectModuleResolution(oldOptions: CompilerOptions, newOptions: CompilerOptions): boolean {

return oldOptions.configFilePath !== newOptions.configFilePath ||

optionsHaveModuleResolutionChanges(oldOptions, newOptions);

}

export function optionsHaveModuleResolutionChanges(oldOptions: CompilerOptions, newOptions: CompilerOptions) {

return optionsHaveChanges(oldOptions, newOptions, moduleResolutionOptionDeclarations);

}

export function changesAffectingProgramStructure(oldOptions: CompilerOptions, newOptions: CompilerOptions) {

return optionsHaveChanges(oldOptions, newOptions, optionsAffectingProgramStructure);

}

export function optionsHaveChanges(oldOptions: CompilerOptions, newOptions: CompilerOptions, optionDeclarations: readonly CommandLineOption[]) {

return oldOptions !== newOptions && optionDeclarations.some(o =>

!isJsonEqual(getCompilerOptionValue(oldOptions, o), getCompilerOptionValue(newOptions, o)));

}

export function forEachAncestor<T>(node: Node, callback: (n: Node) => T | undefined | "quit"): T | undefined {

while (true) {

const res = callback(node);

if (res === "quit") return undefined;

if (res !== undefined) return res;

if (isSourceFile(node)) return undefined;

node = node.parent;

}

}

/**

* Calls `callback` for each entry in the map, returning the first truthy result.

* Use `map.forEach` instead for normal iteration.

*/

export function forEachEntry<K, V, U>(map: ReadonlyESMap<K, V>, callback: (value: V, key: K) => U | undefined): U | undefined {

const iterator = map.entries();

for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {

const [key, value] = iterResult.value;

const result = callback(value, key);

if (result) {

return result;

}

}

return undefined;

}

/** `forEachEntry` for just keys. */

export function forEachKey<K, T>(map: ReadonlyCollection<K>, callback: (key: K) => T | undefined): T | undefined {

const iterator = map.keys();

for (let iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) {

const result = callback(iterResult.value);

if (result) {

return result;

}

}

return undefined;

}

/** Copy entries from `source` to `target`. */

export function copyEntries<K, V>(source: ReadonlyESMap<K, V>, target: ESMap<K, V>): void {

source.forEach((value, key) => {

target.set(key, value);

});

}

export function usingSingleLineStringWriter(action: (writer: EmitTextWriter) => void): string {

const oldString = stringWriter.getText();

try {

action(stringWriter);

return stringWriter.getText();

}

finally {

stringWriter.clear();

stringWriter.writeKeyword(oldString);

}

}

export function getFullWidth(node: Node) {

return node.end - node.pos;

}

export function getResolvedModule(sourceFile: SourceFile | undefined, moduleNameText: string, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): ResolvedModuleFull | undefined {

return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText, mode);

}

export function setResolvedModule(sourceFile: SourceFile, moduleNameText: string, resolvedModule: ResolvedModuleFull, mode: ModuleKind.CommonJS | ModuleKind.ESNext | undefined): void {

if (!sourceFile.resolvedModules) {

sourceFile.resolvedModules = createModeAwareCache();

}

sourceFile.resolvedModules.set(moduleNameText, mode, resolvedModule);

}

export function setResolvedTypeReferenceDirective(sourceFile: SourceFile, typeReferenceDirectiveName: string, resolvedTypeReferenceDirective?: ResolvedTypeReferenceDirective): void {

if (!sourceFile.resolvedTypeReferenceDirectiveNames) {

sourceFile.resolvedTypeReferenceDirectiveNames = createModeAwareCache();

}

sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, /*mode*/ undefined, resolvedTypeReferenceDirective);

}

export function projectReferenceIsEqualTo(oldRef: ProjectReference, newRef: ProjectReference) {

return oldRef.path === newRef.path &&

!oldRef.prepend === !newRef.prepend &&

!oldRef.circular === !newRef.circular;

}

export function moduleResolutionIsEqualTo(oldResolution: ResolvedModuleFull, newResolution: ResolvedModuleFull): boolean {

return oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport &&

oldResolution.extension === newResolution.extension &&

oldResolution.resolvedFileName === newResolution.resolvedFileName &&

oldResolution.originalPath === newResolution.originalPath &&

packageIdIsEqual(oldResolution.packageId, newResolution.packageId);

}

function packageIdIsEqual(a: PackageId | undefined, b: PackageId | undefined): boolean {

return a === b || !!a && !!b && a.name === b.name && a.subModuleName === b.subModuleName && a.version === b.version;

}

export function packageIdToPackageName({ name, subModuleName }: PackageId): string {

return subModuleName ? `${name}/${subModuleName}` : name;

}

export function packageIdToString(packageId: PackageId): string {

return `${packageIdToPackageName(packageId)}@${packageId.version}`;

}

export function typeDirectiveIsEqualTo(oldResolution: ResolvedTypeReferenceDirective, newResolution: ResolvedTypeReferenceDirective): boolean {

return oldResolution.resolvedFileName === newResolution.resolvedFileName

&& oldResolution.primary === newResolution.primary

&& oldResolution.originalPath === newResolution.originalPath;

}

export function hasChangesInResolutions<T>(

names: readonly string[] | readonly FileReference[],

newResolutions: readonly T[],

oldResolutions: ModeAwareCache<T> | undefined,

oldSourceFile: SourceFile | undefined,

comparer: (oldResolution: T, newResolution: T) => boolean): boolean {

Debug.assert(names.length === newResolutions.length);

for (let i = 0; i < names.length; i++) {

const newResolution = newResolutions[i];

const entry = names[i];

// We lower-case all type references because npm automatically lowercases all packages. See GH#9824.

const name = !isString(entry) ? entry.fileName.toLowerCase() : entry;

const mode = !isString(entry) ? getModeForFileReference(entry, oldSourceFile?.impliedNodeFormat) : oldSourceFile && getModeForResolutionAtIndex(oldSourceFile, i);

const oldResolution = oldResolutions && oldResolutions.get(name, mode);

const changed =

oldResolution

? !newResolution || !comparer(oldResolution, newResolution)

: newResolution;

if (changed) {

return true;

}

}

return false;

}

// Returns true if this node contains a parse error anywhere underneath it.

export function containsParseError(node: Node): boolean {

aggregateChildData(node);

return (node.flags & NodeFlags.ThisNodeOrAnySubNodesHasError) !== 0;

}

function aggregateChildData(node: Node): void {

if (!(node.flags & NodeFlags.HasAggregatedChildData)) {

// A node is considered to contain a parse error if:

// a) the parser explicitly marked that it had an error

// b) any of it's children reported that it had an error.

const thisNodeOrAnySubNodesHasError = ((node.flags & NodeFlags.ThisNodeHasError) !== 0) ||

forEachChild(node, containsParseError);

// If so, mark ourselves accordingly.

if (thisNodeOrAnySubNodesHasError) {

(node as Mutable<Node>).flags |= NodeFlags.ThisNodeOrAnySubNodesHasError;

}

// Also mark that we've propagated the child information to this node. This way we can

// always consult the bit directly on this node without needing to check its children

// again.

(node as Mutable<Node>).flags |= NodeFlags.HasAggregatedChildData;

}

}

export function getSourceFileOfNode(node: Node): SourceFile;

export function getSourceFileOfNode(node: Node | undefined): SourceFile | undefined;

export function getSourceFileOfNode(node: Node): SourceFile {

while (node && node.kind !== SyntaxKind.SourceFile) {

node = node.parent;

}

return node as SourceFile;

}

export function getSourceFileOfModule(module: Symbol) {

return getSourceFileOfNode(module.valueDeclaration || getNonAugmentationDeclaration(module));

}

export function isPlainJsFile(file: SourceFile | undefined, checkJs: boolean | undefined): boolean {

return !!file && (file.scriptKind === ScriptKind.JS || file.scriptKind === ScriptKind.JSX) && !file.checkJsDirective && checkJs === undefined;

}

export function isStatementWithLocals(node: Node) {

switch (node.kind) {

case SyntaxKind.Block:

case SyntaxKind.CaseBlock:

case SyntaxKind.ForStatement:

case SyntaxKind.ForInStatement:

case SyntaxKind.ForOfStatement:

return true;

}

return false;

}

export function getStartPositionOfLine(line: number, sourceFile: SourceFileLike): number {

Debug.assert(line >= 0);

return getLineStarts(sourceFile)[line];

}

// This is a useful function for debugging purposes.

export function nodePosToString(node: Node): string {

const file = getSourceFileOfNode(node);

const loc = getLineAndCharacterOfPosition(file, node.pos);

return `${file.fileName}(${loc.line + 1},${loc.character + 1})`;

}

export function getEndLinePosition(line: number, sourceFile: SourceFileLike): number {

Debug.assert(line >= 0);

const lineStarts = getLineStarts(sourceFile);

const lineIndex = line;

const sourceText = sourceFile.text;

if (lineIndex + 1 === lineStarts.length) {

// last line - return EOF

return sourceText.length - 1;

}

else {

// current line start

const start = lineStarts[lineIndex];

// take the start position of the next line - 1 = it should be some line break

let pos = lineStarts[lineIndex + 1] - 1;

Debug.assert(isLineBreak(sourceText.charCodeAt(pos)));

// walk backwards skipping line breaks, stop the the beginning of current line.

// i.e:

// <some text>

// $ <- end of line for this position should match the start position

while (start <= pos && isLineBreak(sourceText.charCodeAt(pos))) {

pos--;

}

return pos;

}

}

/**

* Returns a value indicating whether a name is unique globally or within the current file.

* Note: This does not consider whether a name appears as a free identifier or not, so at the expression `x.y` this includes both `x` and `y`.

*/

export function isFileLevelUniqueName(sourceFile: SourceFile, name: string, hasGlobalName?: PrintHandlers["hasGlobalName"]): boolean {

return !(hasGlobalName && hasGlobalName(name)) && !sourceFile.identifiers.has(name);

}

// Returns true if this node is missing from the actual source code. A 'missing' node is different

// from 'undefined/defined'. When a node is undefined (which can happen for optional nodes

// in the tree), it is definitely missing. However, a node may be defined, but still be

// missing. This happens whenever the parser knows it needs to parse something, but can't

// get anything in the source code that it expects at that location. For example:

//

// let a: ;

//

// Here, the Type in the Type-Annotation is not-optional (as there is a colon in the source

// code). So the parser will attempt to parse out a type, and will create an actual node.

// However, this node will be 'missing' in the sense that no actual source-code/tokens are

// contained within it.

export function nodeIsMissing(node: Node | undefined): boolean {

if (node === undefined) {

return true;

}

return node.pos === node.end && node.pos >= 0 && node.kind !== SyntaxKind.EndOfFileToken;

}

export function nodeIsPresent(node: Node | undefined): boolean {

return !nodeIsMissing(node);

}

function insertStatementsAfterPrologue<T extends Statement>(to: T[], from: readonly T[] | undefined, isPrologueDirective: (node: Node) => boolean): T[] {

if (from === undefined || from.length === 0) return to;

let statementIndex = 0;

// skip all prologue directives to insert at the correct position

for (; statementIndex < to.length; ++statementIndex) {

if (!isPrologueDirective(to[statementIndex])) {

break;

}

}

to.splice(statementIndex, 0, ...from);

return to;

}

function insertStatementAfterPrologue<T extends Statement>(to: T[], statement: T | undefined, isPrologueDirective: (node: Node) => boolean): T[] {

if (statement === undefined) return to;

let statementIndex = 0;

// skip all prologue directives to insert at the correct position

for (; statementIndex < to.length; ++statementIndex) {

if (!isPrologueDirective(to[statementIndex])) {

break;

}

}

to.splice(statementIndex, 0, statement);

return to;

}

function isAnyPrologueDirective(node: Node) {

return isPrologueDirective(node) || !!(getEmitFlags(node) & EmitFlags.CustomPrologue);

}

/**

* Prepends statements to an array while taking care of prologue directives.

*/

export function insertStatementsAfterStandardPrologue<T extends Statement>(to: T[], from: readonly T[] | undefined): T[] {

return insertStatementsAfterPrologue(to, from, isPrologueDirective);

}

export function insertStatementsAfterCustomPrologue<T extends Statement>(to: T[], from: readonly T[] | undefined): T[] {

return insertStatementsAfterPrologue(to, from, isAnyPrologueDirective);

}

/**

* Prepends statements to an array while taking care of prologue directives.

*/

export function insertStatementAfterStandardPrologue<T extends Statement>(to: T[], statement: T | undefined): T[] {

return insertStatementAfterPrologue(to, statement, isPrologueDirective);

}

export function insertStatementAfterCustomPrologue<T extends Statement>(to: T[], statement: T | undefined): T[] {

return insertStatementAfterPrologue(to, statement, isAnyPrologueDirective);

}

/**

* Determine if the given comment is a triple-slash

*

* @return true if the comment is a triple-slash comment else false

*/

export function isRecognizedTripleSlashComment(text: string, commentPos: number, commentEnd: number) {

// Verify this is /// comment, but do the regexp match only when we first can find /// in the comment text

// so that we don't end up computing comment string and doing match for all // comments

if (text.charCodeAt(commentPos + 1) === CharacterCodes.slash &&

commentPos + 2 < commentEnd &&

text.charCodeAt(commentPos + 2) === CharacterCodes.slash) {

const textSubStr = text.substring(commentPos, commentEnd);

return fullTripleSlashReferencePathRegEx.test(textSubStr) ||

fullTripleSlashAMDReferencePathRegEx.test(textSubStr) ||

fullTripleSlashReferenceTypeReferenceDirectiveRegEx.test(textSubStr) ||

defaultLibReferenceRegEx.test(textSubStr) ?

true : false;

}

return false;

}

export function isPinnedComment(text: string, start: number) {

return text.charCodeAt(start + 1) === CharacterCodes.asterisk &&

text.charCodeAt(start + 2) === CharacterCodes.exclamation;

}

export function createCommentDirectivesMap(sourceFile: SourceFile, commentDirectives: CommentDirective[]): CommentDirectivesMap {

const directivesByLine = new Map(

commentDirectives.map(commentDirective => ([

`${getLineAndCharacterOfPosition(sourceFile, commentDirective.range.end).line}`,

commentDirective,

]))

);

const usedLines = new Map<string, boolean>();

return { getUnusedExpectations, markUsed };

function getUnusedExpectations() {

return arrayFrom(directivesByLine.entries())

.filter(([line, directive]) => directive.type === CommentDirectiveType.ExpectError && !usedLines.get(line))

.map(([_, directive]) => directive);

}

function markUsed(line: number) {

if (!directivesByLine.has(`${line}`)) {

return false;

}

usedLines.set(`${line}`, true);

return true;

}

}

export function getTokenPosOfNode(node: Node, sourceFile?: SourceFileLike, includeJsDoc?: boolean): number {

// With nodes that have no width (i.e. 'Missing' nodes), we actually *don't*

// want to skip trivia because this will launch us forward to the next token.

if (nodeIsMissing(node)) {

return node.pos;

}

if (isJSDocNode(node) || node.kind === SyntaxKind.JsxText) {

// JsxText cannot actually contain comments, even though the scanner will think it sees comments

return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos, /*stopAfterLineBreak*/ false, /*stopAtComments*/ true);

}

if (includeJsDoc && hasJSDocNodes(node)) {

return getTokenPosOfNode(node.jsDoc![0], sourceFile);

}

// For a syntax list, it is possible that one of its children has JSDocComment nodes, while

// the syntax list itself considers them as normal trivia. Therefore if we simply skip

// trivia for the list, we may have skipped the JSDocComment as well. So we should process its

// first child to determine the actual position of its first token.

if (node.kind === SyntaxKind.SyntaxList && (node as SyntaxList)._children.length > 0) {

return getTokenPosOfNode((node as SyntaxList)._children[0], sourceFile, includeJsDoc);

}

return skipTrivia(

(sourceFile || getSourceFileOfNode(node)).text,

node.pos,

/*stopAfterLineBreak*/ false,

/*stopAtComments*/ false,

isInJSDoc(node));

}

export function getNonDecoratorTokenPosOfNode(node: Node, sourceFile?: SourceFileLike): number {

if (nodeIsMissing(node) || !node.decorators) {

return getTokenPosOfNode(node, sourceFile);

}

return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.decorators.end);

}

export function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node, includeTrivia = false): string {

return getTextOfNodeFromSourceText(sourceFile.text, node, includeTrivia);

}

function isJSDocTypeExpressionOrChild(node: Node): boolean {

return !!findAncestor(node, isJSDocTypeExpression);

}

export function isExportNamespaceAsDefaultDeclaration(node: Node): boolean {

return !!(isExportDeclaration(node) && node.exportClause && isNamespaceExport(node.exportClause) && node.exportClause.name.escapedText === "default");

}

export function getTextOfNodeFromSourceText(sourceText: string, node: Node, includeTrivia = false): string {

if (nodeIsMissing(node)) {

return "";

}

let text = sourceText.substring(includeTrivia ? node.pos : skipTrivia(sourceText, node.pos), node.end);

if (isJSDocTypeExpressionOrChild(node)) {

// strip space + asterisk at line start

text = text.split(/\r\n|\n|\r/).map(line => trimStringStart(line.replace(/^\s*\*/, ""))).join("\n");

}

return text;

}

export function getTextOfNode(node: Node, includeTrivia = false): string {

return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia);

}

function getPos(range: Node) {

return range.pos;

}

/**

* Note: it is expected that the `nodeArray` and the `node` are within the same file.

* For example, searching for a `SourceFile` in a `SourceFile[]` wouldn't work.

*/

export function indexOfNode(nodeArray: readonly Node[], node: Node) {

return binarySearch(nodeArray, node, getPos, compareValues);

}

/**

* Gets flags that control emit behavior of a node.

*/

export function getEmitFlags(node: Node): EmitFlags {

const emitNode = node.emitNode;

return emitNode && emitNode.flags || 0;

}

interface ScriptTargetFeatures {

[key: string]: { [key: string]: string[] | undefined };

};

export function getScriptTargetFeatures(): ScriptTargetFeatures {

return {

es2015: {

Array: ["find", "findIndex", "fill", "copyWithin", "entries", "keys", "values"],

RegExp: ["flags", "sticky", "unicode"],

Reflect: ["apply", "construct", "defineProperty", "deleteProperty", "get"," getOwnPropertyDescriptor", "getPrototypeOf", "has", "isExtensible", "ownKeys", "preventExtensions", "set", "setPrototypeOf"],

ArrayConstructor: ["from", "of"],

ObjectConstructor: ["assign", "getOwnPropertySymbols", "keys", "is", "setPrototypeOf"],

NumberConstructor: ["isFinite", "isInteger", "isNaN", "isSafeInteger", "parseFloat", "parseInt"],

Math: ["clz32", "imul", "sign", "log10", "log2", "log1p", "expm1", "cosh", "sinh", "tanh", "acosh", "asinh", "atanh", "hypot", "trunc", "fround", "cbrt"],

Map: ["entries", "keys", "values"],

Set: ["entries", "keys", "values"],

Promise: emptyArray,

PromiseConstructor: ["all", "race", "reject", "resolve"],

Symbol: ["for", "keyFor"],

WeakMap: ["entries", "keys", "values"],

WeakSet: ["entries", "keys", "values"],

Iterator: emptyArray,

AsyncIterator: emptyArray,

String: ["codePointAt", "includes", "endsWith", "normalize", "repeat", "startsWith", "anchor", "big", "blink", "bold", "fixed", "fontcolor", "fontsize", "italics", "link", "small", "strike", "sub", "sup"],

StringConstructor: ["fromCodePoint", "raw"]

},

es2016: {

Array: ["includes"]

},

es2017: {

Atomics: emptyArray,

SharedArrayBuffer: emptyArray,

String: ["padStart", "padEnd"],

ObjectConstructor: ["values", "entries", "getOwnPropertyDescriptors"],

DateTimeFormat: ["formatToParts"]

},

es2018: {

Promise: ["finally"],

RegExpMatchArray: ["groups"],

RegExpExecArray: ["groups"],

RegExp: ["dotAll"],

Intl: ["PluralRules"],

AsyncIterable: emptyArray,

AsyncIterableIterator: emptyArray,

AsyncGenerator: emptyArray,

AsyncGeneratorFunction: emptyArray,

NumberFormat: ["formatToParts"]

},

es2019: {

Array: ["flat", "flatMap"],

ObjectConstructor: ["fromEntries"],

String: ["trimStart", "trimEnd", "trimLeft", "trimRight"],

Symbol: ["description"]

},

es2020: {

BigInt: emptyArray,

BigInt64Array: emptyArray,

BigUint64Array: emptyArray,

PromiseConstructor: ["allSettled"],

SymbolConstructor: ["matchAll"],

String: ["matchAll"],

DataView: ["setBigInt64", "setBigUint64", "getBigInt64", "getBigUint64"],

RelativeTimeFormat: ["format", "formatToParts", "resolvedOptions"]

},

es2021: {

PromiseConstructor: ["any"],

String: ["replaceAll"]

},

es2022: {

Array: ["at"],

String: ["at"],

Int8Array: ["at"],

Uint8Array: ["at"],

Uint8ClampedArray: ["at"],

Int16Array: ["at"],

Uint16Array: ["at"],

Int32Array: ["at"],

Uint32Array: ["at"],

Float32Array: ["at"],

Float64Array: ["at"],

BigInt64Array: ["at"],

BigUint64Array: ["at"],

ObjectConstructor: ["hasOwn"],

Error: ["cause"]

}

};

}

export const enum GetLiteralTextFlags {

None = 0,

NeverAsciiEscape = 1 << 0,

JsxAttributeEscape = 1 << 1,

TerminateUnterminatedLiterals = 1 << 2,

AllowNumericSeparator = 1 << 3

}

export function getLiteralText(node: LiteralLikeNode, sourceFile: SourceFile | undefined, flags: GetLiteralTextFlags) {

// If we don't need to downlevel and we can reach the original source text using

// the node's parent reference, then simply get the text as it was originally written.

if (sourceFile && canUseOriginalText(node, flags)) {

return getSourceTextOfNodeFromSourceFile(sourceFile, node);

}

// If we can't reach the original source text, use the canonical form if it's a number,

// or a (possibly escaped) quoted form of the original text if it's string-like.

switch (node.kind) {

case SyntaxKind.StringLiteral: {

const escapeText = flags & GetLiteralTextFlags.JsxAttributeEscape ? escapeJsxAttributeString :

flags & GetLiteralTextFlags.NeverAsciiEscape || (getEmitFlags(node) & EmitFlags.NoAsciiEscaping) ? escapeString :

escapeNonAsciiString;

if ((node as StringLiteral).singleQuote) {

return "'" + escapeText(node.text, CharacterCodes.singleQuote) + "'";

}

else {

return '"' + escapeText(node.text, CharacterCodes.doubleQuote) + '"';

}

}

case SyntaxKind.NoSubstitutionTemplateLiteral:

case SyntaxKind.TemplateHead:

case SyntaxKind.TemplateMiddle:

case SyntaxKind.TemplateTail: {

// If a NoSubstitutionTemplateLiteral appears to have a substitution in it, the original text

// had to include a backslash: `not \${a} substitution`.

const escapeText = flags & GetLiteralTextFlags.NeverAsciiEscape || (getEmitFlags(node) & EmitFlags.NoAsciiEscaping) ? escapeString :

escapeNonAsciiString;

const rawText = (node as TemplateLiteralLikeNode).rawText ?? escapeTemplateSubstitution(escapeText(node.text, CharacterCodes.backtick));

switch (node.kind) {

case SyntaxKind.NoSubstitutionTemplateLiteral:

return "`" + rawText + "`";

case SyntaxKind.TemplateHead:

return "`" + rawText + "${";

case SyntaxKind.TemplateMiddle:

return "}" + rawText + "${";

case SyntaxKind.TemplateTail:

return "}" + rawText + "`";

}

break;

}

case SyntaxKind.NumericLiteral:

case SyntaxKind.BigIntLiteral:

return node.text;

case SyntaxKind.RegularExpressionLiteral:

if (flags & GetLiteralTextFlags.TerminateUnterminatedLiterals && node.isUnterminated) {

return node.text + (node.text.charCodeAt(node.text.length - 1) === CharacterCodes.backslash ? " /" : "/");

}

return node.text;

}

return Debug.fail(`Literal kind '${node.kind}' not accounted for.`);

}

function canUseOriginalText(node: LiteralLikeNode, flags: GetLiteralTextFlags): boolean {

if (nodeIsSynthesized(node) || !node.parent || (flags & GetLiteralTextFlags.TerminateUnterminatedLiterals && node.isUnterminated)) {

return false;

}

if (isNumericLiteral(node) && node.numericLiteralFlags & TokenFlags.ContainsSeparator) {

return !!(flags & GetLiteralTextFlags.AllowNumericSeparator);

}

return !isBigIntLiteral(node);

}

export function getTextOfConstantValue(value: string | number) {

return isString(value) ? '"' + escapeNonAsciiString(value) + '"' : "" + value;

}

// Make an identifier from an external module name by extracting the string after the last "/" and replacing

// all non-alphanumeric characters with underscores

export function makeIdentifierFromModuleName(moduleName: string): string {

return getBaseFileName(moduleName).replace(/^(\d)/, "_$1").replace(/\W/g, "_");

}

export function isBlockOrCatchScoped(declaration: Declaration) {

return (getCombinedNodeFlags(declaration) & NodeFlags.BlockScoped) !== 0 ||

isCatchClauseVariableDeclarationOrBindingElement(declaration);

}

export function isCatchClauseVariableDeclarationOrBindingElement(declaration: Declaration) {

const node = getRootDeclaration(declaration);

return node.kind === SyntaxKind.VariableDeclaration && node.parent.kind === SyntaxKind.CatchClause;

}

export function isAmbientModule(node: Node): node is AmbientModuleDeclaration {

return isModuleDeclaration(node) && (node.name.kind === SyntaxKind.StringLiteral || isGlobalScopeAugmentation(node));

}

export function isModuleWithStringLiteralName(node: Node): node is ModuleDeclaration {

return isModuleDeclaration(node) && node.name.kind === SyntaxKind.StringLiteral;

}

export function isNonGlobalAmbientModule(node: Node): node is ModuleDeclaration & { name: StringLiteral } {

return isModuleDeclaration(node) && isStringLiteral(node.name);

}

/**

* An effective module (namespace) declaration is either

* 1. An actual declaration: namespace X { ... }

* 2. A Javascript declaration, which is:

* An identifier in a nested property access expression: Y in `X.Y.Z = { ... }`

*/

export function isEffectiveModuleDeclaration(node: Node) {

return isModuleDeclaration(node) || isIdentifier(node);

}

/** Given a symbol for a module, checks that it is a shorthand ambient module. */

export function isShorthandAmbientModuleSymbol(moduleSymbol: Symbol): boolean {

return isShorthandAmbientModule(moduleSymbol.valueDeclaration);

}

function isShorthandAmbientModule(node: Node | undefined): boolean {

// The only kind of module that can be missing a body is a shorthand ambient module.

return !!node && node.kind === SyntaxKind.ModuleDeclaration && (!(node as ModuleDeclaration).body);

}

export function isBlockScopedContainerTopLevel(node: Node): boolean {

return node.kind === SyntaxKind.SourceFile ||

node.kind === SyntaxKind.ModuleDeclaration ||

isFunctionLikeOrClassStaticBlockDeclaration(node);

}

export function isGlobalScopeAugmentation(module: ModuleDeclaration): boolean {

return !!(module.flags & NodeFlags.GlobalAugmentation);

}

export function isExternalModuleAugmentation(node: Node): node is AmbientModuleDeclaration {

return isAmbientModule(node) && isModuleAugmentationExternal(node);

}

export function isModuleAugmentationExternal(node: AmbientModuleDeclaration) {

// external module augmentation is a ambient module declaration that is either:

// - defined in the top level scope and source file is an external module

// - defined inside ambient module declaration located in the top level scope and source file not an external module

switch (node.parent.kind) {

case SyntaxKind.SourceFile:

return isExternalModule(node.parent);

case SyntaxKind.ModuleBlock:

return isAmbientModule(node.parent.parent) && isSourceFile(node.parent.parent.parent) && !isExternalModule(node.parent.parent.parent);

}

return false;

}

export function getNonAugmentationDeclaration(symbol: Symbol) {

return symbol.declarations?.find(d => !isExternalModuleAugmentation(d) && !(isModuleDeclaration(d) && isGlobalScopeAugmentation(d)));

}

function isCommonJSContainingModuleKind(kind: ModuleKind) {

return kind === ModuleKind.CommonJS || kind === ModuleKind.Node16 || kind === ModuleKind.NodeNext;

}

export function isEffectiveExternalModule(node: SourceFile, compilerOptions: CompilerOptions) {

return isExternalModule(node) || compilerOptions.isolatedModules || (isCommonJSContainingModuleKind(getEmitModuleKind(compilerOptions)) && !!node.commonJsModuleIndicator);

}

/**

* Returns whether the source file will be treated as if it were in strict mode at runtime.

*/

export function isEffectiveStrictModeSourceFile(node: SourceFile, compilerOptions: CompilerOptions) {

// We can only verify strict mode for JS/TS files

switch (node.scriptKind) {

case ScriptKind.JS:

case ScriptKind.TS:

case ScriptKind.JSX:

case ScriptKind.TSX:

break;

default:

return false;

}

// Strict mode does not matter for declaration files.

if (node.isDeclarationFile) {

return false;

}

// If `alwaysStrict` is set, then treat the file as strict.

if (getStrictOptionValue(compilerOptions, "alwaysStrict")) {

return true;

}

// Starting with a "use strict" directive indicates the file is strict.

if (startsWithUseStrict(node.statements)) {

return true;

}

if (isExternalModule(node) || compilerOptions.isolatedModules) {

// ECMAScript Modules are always strict.

if (getEmitModuleKind(compilerOptions) >= ModuleKind.ES2015) {

return true;

}

// Other modules are strict unless otherwise specified.

return !compilerOptions.noImplicitUseStrict;

}

return false;

}

export function isBlockScope(node: Node, parentNode: Node | undefined): boolean {

switch (node.kind) {

case SyntaxKind.SourceFile:

case SyntaxKind.CaseBlock:

case SyntaxKind.CatchClause:

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.ForStatement:

case SyntaxKind.ForInStatement:

case SyntaxKind.ForOfStatement:

case SyntaxKind.Constructor:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.FunctionExpression:

case SyntaxKind.ArrowFunction:

case SyntaxKind.PropertyDeclaration:

case SyntaxKind.ClassStaticBlockDeclaration:

return true;

case SyntaxKind.Block:

// function block is not considered block-scope container

// see comment in binder.ts: bind(...), case for SyntaxKind.Block

return !isFunctionLikeOrClassStaticBlockDeclaration(parentNode);

}

return false;

}

export function isDeclarationWithTypeParameters(node: Node): node is DeclarationWithTypeParameters;

export function isDeclarationWithTypeParameters(node: DeclarationWithTypeParameters): node is DeclarationWithTypeParameters {

switch (node.kind) {

case SyntaxKind.JSDocCallbackTag:

case SyntaxKind.JSDocTypedefTag:

case SyntaxKind.JSDocSignature:

return true;

default:

assertType<DeclarationWithTypeParameterChildren>(node);

return isDeclarationWithTypeParameterChildren(node);

}

}

export function isDeclarationWithTypeParameterChildren(node: Node): node is DeclarationWithTypeParameterChildren;

export function isDeclarationWithTypeParameterChildren(node: DeclarationWithTypeParameterChildren): node is DeclarationWithTypeParameterChildren {

switch (node.kind) {

case SyntaxKind.CallSignature:

case SyntaxKind.ConstructSignature:

case SyntaxKind.MethodSignature:

case SyntaxKind.IndexSignature:

case SyntaxKind.FunctionType:

case SyntaxKind.ConstructorType:

case SyntaxKind.JSDocFunctionType:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.ClassExpression:

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.TypeAliasDeclaration:

case SyntaxKind.JSDocTemplateTag:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.MethodDeclaration:

case SyntaxKind.Constructor:

case SyntaxKind.GetAccessor:

case SyntaxKind.SetAccessor:

case SyntaxKind.FunctionExpression:

case SyntaxKind.ArrowFunction:

return true;

default:

assertType<never>(node);

return false;

}

}

export function isAnyImportSyntax(node: Node): node is AnyImportSyntax {

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ImportEqualsDeclaration:

return true;

default:

return false;

}

}

export function isAnyImportOrBareOrAccessedRequire(node: Node): node is AnyImportOrBareOrAccessedRequire {

return isAnyImportSyntax(node) || isVariableDeclarationInitializedToBareOrAccessedRequire(node);

}

export function isLateVisibilityPaintedStatement(node: Node): node is LateVisibilityPaintedStatement {

switch (node.kind) {

case SyntaxKind.ImportDeclaration:

case SyntaxKind.ImportEqualsDeclaration:

case SyntaxKind.VariableStatement:

case SyntaxKind.ClassDeclaration:

case SyntaxKind.FunctionDeclaration:

case SyntaxKind.ModuleDeclaration:

case SyntaxKind.TypeAliasDeclaration:

case SyntaxKind.InterfaceDeclaration:

case SyntaxKind.EnumDeclaration:

return true;

default:

return false;

}

}

export function hasPossibleExternalModuleReference(node: Node): node is AnyImportOrReExport | ModuleDeclaration | ImportTypeNode | ImportCall {

return isAnyImportOrReExport(node) || isModuleDeclaration(node) || isImportTypeNode(node) || isImportCall(node);

}

export function isAnyImportOrReExport(node: Node): node is AnyImportOrReExport {

return isAnyImportSyntax(node) || isExportDeclaration(node);

}

// Gets the nearest enclosing block scope container that has the provided node

// as a descendant, that is not the provided node.

export function getEnclosingBlockScopeContainer(node: Node): Node {

return findAncestor(node.parent, current => isBlockScope(current, current.parent))!;

}

export function forEachEnclosingBlockScopeContainer(node: Node, cb: (container: Node) => void): void {

let container = getEnclosingBlockScopeContainer(node);

while (container) {

cb(container);

container = getEnclosingBlockScopeContainer(container);

}

}

// Return display name of an identifier

// Computed property names will just be emitted as "[<expr>]", where <expr> is the source

// text of the expression in the computed property.

export function declarationNameToString(name: DeclarationName | QualifiedName | undefined) {

return !name || getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name);

}

export function getNameFromIndexInfo(info: IndexInfo): string | undefined {

return info.declaration ? declarationNameToString(info.declaration.parameters[0].name) : undefined;

}

export function isComputedNonLiteralName(name: PropertyName): boolean {

return name.kind === SyntaxKind.ComputedPropertyName && !isStringOrNumericLiteralLike(name.expression);

}

export function tryGetTextOfPropertyName(name: PropertyName | NoSubstitutionTemplateLiteral): __String | undefined {

switch (name.kind) {

case SyntaxKind.Identifier:

case SyntaxKind.PrivateIdentifier:

return name.escapedText;

case SyntaxKind.StringLiteral:

case SyntaxKind.NumericLiteral: