tsc-ts 0.0.4 → 0.0.6

package/README.md

@@ -33,7 +33,7 @@ npx tsc-ts --noEmit src/index.ts
 
 `tsc-ts --api` serves the TypeScript API over stdin and stdout, like `tsc --api`.
 
-`--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker.
+`--checkers N` checks the program on N threads. Unless `--checkers` or `--singleThreaded` is given, the native executable uses one checker per CPU it may run on (up to 16), and at least tsgo's four; it uses fewer than the CPUs, but never fewer than four, when the estimated peak memory of more checkers would not fit 85% of the machine's memory (`TSC_TS_CHECKERS=fixed` keeps tsgo's four), and checkers beyond the fourth stop taking files, one at a time, when the process's memory reaches that share; it shares one program between its threads and also parses and binds the program's files on them. Unless `--singleThreaded` is given, the program's files are parsed and bound on threads also with `--checkers 1`, as tsgo does. Files that share costly declarations, such as a large generated schema and the few files importing it, are checked together on one checker. Under Node.js, where every thread builds its own copy of the program, tsc-ts checks on one thread unless `--checkers` is given. `--incremental`, `--watch` and `--build` always check on one thread. The diagnostics are the same as with one checker.
 
 The native executable never frees syntax trees, types, signatures or symbols: it keeps them until it exits, which saves the cost of tracking them during a build. A one-shot build is unaffected, but a long-running process grows with each rebuild or project update. Native `--watch` (also with `--build`) runs in a child process, and when a change arrives while that process holds more than 2.5 times the memory it held after its first build, a new process replaces it and builds the change, reporting what the old process would have. `TSC_TS_WATCH_MEMORY` sets that limit in megabytes, and `TSC_TS_WATCH_MEMORY=0` turns the replacement off. A `--api` process grows with each project update; restart it to reclaim the memory.
 
@@ -51,4 +51,36 @@ const isIdentifier = (node: Node): boolean => node.kind === SyntaxKind.Identifie
 
 Lists of child nodes are `NodeList` objects: `node.arguments.nodes` holds the nodes, and `pos` and `end` the list's range. `symbolName(symbol)` gives a symbol's name as TypeScript 7's API does (`__call`, `export=`).
 
-The package has a JavaScript build with declaration files for Node.js, and the TypeScript sources of the API (the `source` export condition) for compilers that build it from source.
+### Programs and checkers
+
+`createProgram({ rootNames, options, host })` creates a program of root files with compiler options, and `createProgramFromConfigFile(configFileName, host)` the program of a `tsconfig.json`. `parseConfigFile(configFileName, host)` returns a config file's options, root files and diagnostics. A program loads its files as `tsc-ts` loads a project's, on the calling thread.
+
+```ts
+import { createProgramFromConfigFile, SyntaxKind, walkPreorder } from 'tsc-ts/api';
+
+const program = createProgramFromConfigFile('tsconfig.json', {
+  getCurrentDirectory: () => process.cwd(),
+  useCaseSensitiveFileNames: () => process.platform === 'linux',
+  getDefaultLibraryDirectory: () => '/path/to/lib',
+});
+const checker = program.getTypeChecker();
+for (const file of program.getSourceFiles()) {
+  if (program.isSourceFileDefaultLibrary(file)) continue;
+  walkPreorder(file, (node) => {
+    if (node.kind === SyntaxKind.Identifier) console.log(checker.typeToString(checker.getTypeAtLocation(node)!));
+  });
+}
+program.dispose();
+```
+
+The host's `getDefaultLibraryDirectory()` names the directory with TypeScript 7's `lib.*.d.ts` files; the platform packages carry them in their `lib` directory. The host's `readFile`, `fileExists`, `directoryExists`, `realpath` and `getAccessibleEntries` are optional: where one is missing or answers undefined, the program reads the disk.
+
+The program's diagnostics, with their text and positions, are those `tsc --api` returns for the same project. `getTypeChecker()` returns a checker for queries, separate from the checker that reports the program's diagnostics, so queries don't change them. Its methods answer as the `tsc --api` requests of the same names. Nodes, symbols, types and signatures are tsc-ts's own objects, one per node, symbol, type and signature in a program, so they can be compared with `===` and used as Map keys.
+
+`parseSourceFile(fileName, text, options)` parses one file without a program, as a program with `options.compilerOptions` parses it. The node functions `forEachChild`, `walkPreorder`, `tokenStartOfNode`, `getJSDoc`, `getModifiers`, `canHaveModifiers`, `getCombinedModifierFlags`, `getCombinedNodeFlags`, `getLineStarts`, `getLineAndCharacterOfPosition`, `getPositionOfLineAndCharacter` and `tokenToString`, and `flattenDiagnosticMessageText`, behave as TypeScript 7's. `getSourceFileOfNode(node)` returns the source file a node is in, and `getTextOfNode(node)` its text from the start of its first token, as TypeScript's `node.getSourceFile()` and `node.getText()` do.
+
+`getPreEmitDiagnostics(program, sourceFile?)` returns a program's config file parsing, program, syntactic, global and semantic diagnostics, sorted and without duplicates, as TypeScript's function of that name does.
+
+An exception the compiler throws while answering a call reaches the caller as an `InternalCompilerError`, with the exception as its `cause`; the program's checker may be inconsistent after one, so dispose of the program. `program.dispose()` frees the program's checkers; calls on the program or its checker after it throw a `DisposedProgramError`.
+
+The package has a JavaScript build with declaration files for Node.js, and the TypeScript sources of the API and the compiler (the `source` export condition) for compilers that build it from source. The sources compile with scriptc: a test builds a program on `tsc-ts/api` natively and checks that it answers as the Node build.

package/dist/api/compiler/ast-utilities.d.ts

@@ -0,0 +1,82 @@
+import { ModifierFlags, type Node } from './ast.js';
+import { SyntaxKind } from './syntax-kind.js';
+export declare const enum OperatorPrecedence {
+    Invalid = -1,
+    Comma = 0,
+    Spread = 1,
+    Yield = 2,
+    Assignment = 3,
+    Conditional = 4,
+    LogicalOR = 5,
+    LogicalAND = 6,
+    BitwiseOR = 7,
+    BitwiseXOR = 8,
+    BitwiseAND = 9,
+    Equality = 10,
+    Relational = 11,
+    Shift = 12,
+    Additive = 13,
+    Multiplicative = 14,
+    Exponentiation = 15,
+    Unary = 16,
+    Update = 17,
+    LeftHandSide = 18,
+    OptionalChain = 19,
+    Member = 20,
+    Primary = 21,
+    Parentheses = 22,
+    Lowest = 0,
+    Highest = 22,
+    DisallowComma = 2,
+    Coalesce = 5
+}
+export declare function getBinaryOperatorPrecedence(kind: SyntaxKind): OperatorPrecedence;
+export declare function isKeyword(token: SyntaxKind): boolean;
+export declare function isPunctuation(token: SyntaxKind): boolean;
+export declare function isKeywordOrPunctuation(token: SyntaxKind): boolean;
+export declare function isReservedWord(token: SyntaxKind): boolean;
+export declare function tokenIsIdentifierOrKeyword(token: SyntaxKind): boolean;
+export declare function tokenIsIdentifierOrKeywordOrGreaterThan(token: SyntaxKind): boolean;
+export declare function isModifierKind(kind: SyntaxKind): boolean;
+export declare function modifierToFlag(kind: SyntaxKind): ModifierFlags;
+export declare function modifiersToFlags(modifiers: readonly Node[]): ModifierFlags;
+export declare function isParameterPropertyModifier(kind: SyntaxKind): boolean;
+export declare function isClassMemberModifier(token: SyntaxKind): boolean;
+export declare function isAssignmentOperator(kind: SyntaxKind): boolean;
+/** Whether the node has an empty, non-synthesized range (and isn't the end of file token). */
+export declare function nodeIsMissing(node: Node | undefined): boolean;
+export declare function nodeIsPresent(node: Node | undefined): boolean;
+export declare function isInJSFile(node: Node | undefined): boolean;
+export declare function compareNodePositions(a: Node, b: Node): number;
+/** Partially emitted expressions, created by transforms, are skipped. */
+export declare function isLeftHandSideExpression(node: Node): boolean;
+export declare function isFunctionLikeDeclarationKind(kind: SyntaxKind): boolean;
+export declare function isFunctionLikeKind(kind: SyntaxKind): boolean;
+export declare function isFunctionLike(node: Node | undefined): boolean;
+export declare function canHaveIllegalDecorators(node: Node): boolean;
+export declare function canHaveDecorators(node: Node): boolean;
+export declare function isStringLiteralLike(node: Node): boolean;
+/** Whether two JSX tag names (identifiers, `this`, namespaced names or property accesses) are the same. */
+export declare function tagNamesAreEquivalent(lhs: Node, rhs: Node): boolean;
+/** The source text of a node, without leading trivia. */
+export declare function getTextOfNodeFromSourceText(sourceText: string, node: Node): string;
+export declare function isImportMeta(node: Node): boolean;
+/** `import(…)` or `import.defer(…)`. */
+export declare function isImportCall(node: Node): boolean;
+/** `require(x)` with one argument, a string literal if `requireStringLiteralLikeArgument`. */
+export declare function isRequireCall(node: Node, requireStringLiteralLikeArgument: boolean): boolean;
+/** The string literal of `import("x")` types. */
+export declare function getImportTypeNodeLiteral(node: Node): Node | undefined;
+export declare function isLiteralImportTypeNode(node: Node): boolean;
+export declare function isAnyImportOrReExport(node: Node): boolean;
+export declare function getExternalModuleName(node: Node): Node | undefined;
+export declare function isGlobalScopeAugmentation(node: Node): boolean;
+/** Whether a node is written type-only: an `import type` clause, or a `type` specifier, import or export. */
+export declare function isTypeOnly(node: Node): boolean;
+/** Whether a declaration declares only a type. */
+export declare function isTypeDeclaration(node: Node): boolean;
+export declare function isAmbientModule(node: Node): boolean;
+/** Whether `node` is a JavaScript `/** @type {T} *\/ (x)` cast, reparsed as a parenthesized `as` expression. */
+export declare function isJSDocTypeAssertion(node: Node): boolean;
+/** The expression a check applies to: parentheses and `satisfies` are skipped, but not JavaScript casts. */
+export declare function getEffectiveCheckNode(argument: Node): Node;

package/dist/api/compiler/ast-utilities.js

@@ -0,0 +1,462 @@
+// Predicates and helpers over syntax kinds and nodes, as in tsgo's ast/utilities.go.
+//
+// Fields of `instanceof`-narrowed nodes are read through `as` casts: scriptc reads them
+// statically, but reads fields of a narrowed value dynamically.
+import { CallExpression, ExternalModuleReference, Identifier, ImportEqualsDeclaration, ImportTypeNode, JsxNamespacedName, LiteralTypeNode, MetaProperty, ModuleDeclaration, PropertyAccessExpression, StringLiteral, getExpression, getIsTypeOnly, getModuleSpecifier, getText, getType, } from './ast.js';
+import { skipTrivia } from './scanner.js';
+export function getBinaryOperatorPrecedence(kind) {
+    switch (kind) {
+        case 60 /* SyntaxKind.QuestionQuestionToken */:
+            return 5 /* OperatorPrecedence.Coalesce */;
+        case 56 /* SyntaxKind.BarBarToken */:
+            return 5 /* OperatorPrecedence.LogicalOR */;
+        case 55 /* SyntaxKind.AmpersandAmpersandToken */:
+            return 6 /* OperatorPrecedence.LogicalAND */;
+        case 51 /* SyntaxKind.BarToken */:
+            return 7 /* OperatorPrecedence.BitwiseOR */;
+        case 52 /* SyntaxKind.CaretToken */:
+            return 8 /* OperatorPrecedence.BitwiseXOR */;
+        case 50 /* SyntaxKind.AmpersandToken */:
+            return 9 /* OperatorPrecedence.BitwiseAND */;
+        case 34 /* SyntaxKind.EqualsEqualsToken */:
+        case 35 /* SyntaxKind.ExclamationEqualsToken */:
+        case 36 /* SyntaxKind.EqualsEqualsEqualsToken */:
+        case 37 /* SyntaxKind.ExclamationEqualsEqualsToken */:
+            return 10 /* OperatorPrecedence.Equality */;
+        case 29 /* SyntaxKind.LessThanToken */:
+        case 31 /* SyntaxKind.GreaterThanToken */:
+        case 32 /* SyntaxKind.LessThanEqualsToken */:
+        case 33 /* SyntaxKind.GreaterThanEqualsToken */:
+        case 103 /* SyntaxKind.InstanceOfKeyword */:
+        case 102 /* SyntaxKind.InKeyword */:
+        case 129 /* SyntaxKind.AsKeyword */:
+        case 152 /* SyntaxKind.SatisfiesKeyword */:
+            return 11 /* OperatorPrecedence.Relational */;
+        case 47 /* SyntaxKind.LessThanLessThanToken */:
+        case 48 /* SyntaxKind.GreaterThanGreaterThanToken */:
+        case 49 /* SyntaxKind.GreaterThanGreaterThanGreaterThanToken */:
+            return 12 /* OperatorPrecedence.Shift */;
+        case 39 /* SyntaxKind.PlusToken */:
+        case 40 /* SyntaxKind.MinusToken */:
+            return 13 /* OperatorPrecedence.Additive */;
+        case 41 /* SyntaxKind.AsteriskToken */:
+        case 43 /* SyntaxKind.SlashToken */:
+        case 44 /* SyntaxKind.PercentToken */:
+            return 14 /* OperatorPrecedence.Multiplicative */;
+        case 42 /* SyntaxKind.AsteriskAsteriskToken */:
+            return 15 /* OperatorPrecedence.Exponentiation */;
+    }
+    // Lower than every precedence, so binary expression parsing stops.
+    return -1 /* OperatorPrecedence.Invalid */;
+}
+// Tokens
+export function isKeyword(token) {
+    return token >= 82 /* SyntaxKind.FirstKeyword */ && token <= 166 /* SyntaxKind.LastKeyword */;
+}
+export function isPunctuation(token) {
+    return token >= 18 /* SyntaxKind.FirstPunctuation */ && token <= 78 /* SyntaxKind.LastPunctuation */;
+}
+export function isKeywordOrPunctuation(token) {
+    return isKeyword(token) || isPunctuation(token);
+}
+export function isReservedWord(token) {
+    return token >= 82 /* SyntaxKind.FirstReservedWord */ && token <= 117 /* SyntaxKind.LastReservedWord */;
+}
+export function tokenIsIdentifierOrKeyword(token) {
+    return token >= 79 /* SyntaxKind.Identifier */;
+}
+export function tokenIsIdentifierOrKeywordOrGreaterThan(token) {
+    return token === 31 /* SyntaxKind.GreaterThanToken */ || tokenIsIdentifierOrKeyword(token);
+}
+export function isModifierKind(kind) {
+    switch (kind) {
+        case 127 /* SyntaxKind.AbstractKeyword */:
+        case 128 /* SyntaxKind.AccessorKeyword */:
+        case 133 /* SyntaxKind.AsyncKeyword */:
+        case 86 /* SyntaxKind.ConstKeyword */:
+        case 137 /* SyntaxKind.DeclareKeyword */:
+        case 89 /* SyntaxKind.DefaultKeyword */:
+        case 94 /* SyntaxKind.ExportKeyword */:
+        case 102 /* SyntaxKind.InKeyword */:
+        case 122 /* SyntaxKind.PrivateKeyword */:
+        case 123 /* SyntaxKind.ProtectedKeyword */:
+        case 124 /* SyntaxKind.PublicKeyword */:
+        case 148 /* SyntaxKind.ReadonlyKeyword */:
+        case 147 /* SyntaxKind.OutKeyword */:
+        case 164 /* SyntaxKind.OverrideKeyword */:
+        case 125 /* SyntaxKind.StaticKeyword */:
+            return true;
+    }
+    return false;
+}
+export function modifierToFlag(kind) {
+    switch (kind) {
+        case 125 /* SyntaxKind.StaticKeyword */:
+            return 256 /* ModifierFlags.Static */;
+        case 124 /* SyntaxKind.PublicKeyword */:
+            return 1 /* ModifierFlags.Public */;
+        case 123 /* SyntaxKind.ProtectedKeyword */:
+            return 4 /* ModifierFlags.Protected */;
+        case 122 /* SyntaxKind.PrivateKeyword */:
+            return 2 /* ModifierFlags.Private */;
+        case 127 /* SyntaxKind.AbstractKeyword */:
+            return 64 /* ModifierFlags.Abstract */;
+        case 128 /* SyntaxKind.AccessorKeyword */:
+            return 512 /* ModifierFlags.Accessor */;
+        case 94 /* SyntaxKind.ExportKeyword */:
+            return 32 /* ModifierFlags.Export */;
+        case 137 /* SyntaxKind.DeclareKeyword */:
+            return 128 /* ModifierFlags.Ambient */;
+        case 86 /* SyntaxKind.ConstKeyword */:
+            return 4096 /* ModifierFlags.Const */;
+        case 89 /* SyntaxKind.DefaultKeyword */:
+            return 2048 /* ModifierFlags.Default */;
+        case 133 /* SyntaxKind.AsyncKeyword */:
+            return 1024 /* ModifierFlags.Async */;
+        case 148 /* SyntaxKind.ReadonlyKeyword */:
+            return 8 /* ModifierFlags.Readonly */;
+        case 164 /* SyntaxKind.OverrideKeyword */:
+            return 16 /* ModifierFlags.Override */;
+        case 102 /* SyntaxKind.InKeyword */:
+            return 8192 /* ModifierFlags.In */;
+        case 147 /* SyntaxKind.OutKeyword */:
+            return 16384 /* ModifierFlags.Out */;
+        case 171 /* SyntaxKind.Decorator */:
+            return 32768 /* ModifierFlags.Decorator */;
+    }
+    return 0 /* ModifierFlags.None */;
+}
+export function modifiersToFlags(modifiers) {
+    let flags = 0 /* ModifierFlags.None */;
+    for (let i = 0; i < modifiers.length; i++)
+        flags |= modifierToFlag(modifiers[i].kind);
+    return flags;
+}
+export function isParameterPropertyModifier(kind) {
+    return (modifierToFlag(kind) & 31 /* ModifierFlags.ParameterPropertyModifier */) !== 0;
+}
+export function isClassMemberModifier(token) {
+    return (isParameterPropertyModifier(token) ||
+        token === 125 /* SyntaxKind.StaticKeyword */ ||
+        token === 164 /* SyntaxKind.OverrideKeyword */ ||
+        token === 128 /* SyntaxKind.AccessorKeyword */);
+}
+export function isAssignmentOperator(kind) {
+    switch (kind) {
+        case 63 /* SyntaxKind.EqualsToken */:
+        case 64 /* SyntaxKind.PlusEqualsToken */:
+        case 65 /* SyntaxKind.MinusEqualsToken */:
+        case 67 /* SyntaxKind.AsteriskAsteriskEqualsToken */:
+        case 66 /* SyntaxKind.AsteriskEqualsToken */:
+        case 68 /* SyntaxKind.SlashEqualsToken */:
+        case 69 /* SyntaxKind.PercentEqualsToken */:
+        case 73 /* SyntaxKind.AmpersandEqualsToken */:
+        case 74 /* SyntaxKind.BarEqualsToken */:
+        case 78 /* SyntaxKind.CaretEqualsToken */:
+        case 70 /* SyntaxKind.LessThanLessThanEqualsToken */:
+        case 72 /* SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken */:
+        case 71 /* SyntaxKind.GreaterThanGreaterThanEqualsToken */:
+        case 75 /* SyntaxKind.BarBarEqualsToken */:
+        case 76 /* SyntaxKind.AmpersandAmpersandEqualsToken */:
+        case 77 /* SyntaxKind.QuestionQuestionEqualsToken */:
+            return true;
+    }
+    return false;
+}
+// Nodes
+/** Whether the node has an empty, non-synthesized range (and isn't the end of file token). */
+export function nodeIsMissing(node) {
+    return node === undefined || (node.pos === node.end && node.pos >= 0 && node.kind !== 1 /* SyntaxKind.EndOfFile */);
+}
+export function nodeIsPresent(node) {
+    return !nodeIsMissing(node);
+}
+export function isInJSFile(node) {
+    return node !== undefined && (node.flags & 65536 /* NodeFlags.JavaScriptFile */) !== 0;
+}
+export function compareNodePositions(a, b) {
+    const c = a.pos - b.pos;
+    return c !== 0 ? c : a.end - b.end;
+}
+function isLeftHandSideExpressionKind(kind) {
+    switch (kind) {
+        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 215 /* SyntaxKind.NewExpression */:
+        case 214 /* SyntaxKind.CallExpression */:
+        case 285 /* SyntaxKind.JsxElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */:
+        case 289 /* SyntaxKind.JsxFragment */:
+        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 79 /* SyntaxKind.Identifier */:
+        case 80 /* SyntaxKind.PrivateIdentifier */:
+        case 13 /* SyntaxKind.RegularExpressionLiteral */:
+        case 8 /* SyntaxKind.NumericLiteral */:
+        case 9 /* SyntaxKind.BigIntLiteral */:
+        case 10 /* SyntaxKind.StringLiteral */:
+        case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
+        case 229 /* SyntaxKind.TemplateExpression */:
+        case 96 /* SyntaxKind.FalseKeyword */:
+        case 105 /* SyntaxKind.NullKeyword */:
+        case 109 /* SyntaxKind.ThisKeyword */:
+        case 111 /* SyntaxKind.TrueKeyword */:
+        case 107 /* SyntaxKind.SuperKeyword */:
+        case 236 /* SyntaxKind.NonNullExpression */:
+        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 237 /* SyntaxKind.MetaProperty */:
+        case 101 /* SyntaxKind.ImportKeyword */:
+        case 283 /* SyntaxKind.MissingDeclaration */:
+            return true;
+    }
+    return false;
+}
+/** Partially emitted expressions, created by transforms, are skipped. */
+export function isLeftHandSideExpression(node) {
+    let expression = node;
+    while (expression.kind === 348 /* SyntaxKind.PartiallyEmittedExpression */)
+        expression = expression.expression;
+    return isLeftHandSideExpressionKind(expression.kind);
+}
+export function isFunctionLikeDeclarationKind(kind) {
+    switch (kind) {
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 177 /* SyntaxKind.Constructor */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 219 /* SyntaxKind.FunctionExpression */:
+        case 220 /* SyntaxKind.ArrowFunction */:
+            return true;
+    }
+    return false;
+}
+export function isFunctionLikeKind(kind) {
+    switch (kind) {
+        case 174 /* SyntaxKind.MethodSignature */:
+        case 180 /* SyntaxKind.CallSignature */:
+        case 318 /* SyntaxKind.JSDocSignature */:
+        case 181 /* SyntaxKind.ConstructSignature */:
+        case 182 /* SyntaxKind.IndexSignature */:
+        case 185 /* SyntaxKind.FunctionType */:
+        case 186 /* SyntaxKind.ConstructorType */:
+            return true;
+    }
+    return isFunctionLikeDeclarationKind(kind);
+}
+export function isFunctionLike(node) {
+    return node !== undefined && isFunctionLikeKind(node.kind);
+}
+export function canHaveIllegalDecorators(node) {
+    switch (node.kind) {
+        case 303 /* SyntaxKind.PropertyAssignment */:
+        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 263 /* SyntaxKind.FunctionDeclaration */:
+        case 177 /* SyntaxKind.Constructor */:
+        case 182 /* SyntaxKind.IndexSignature */:
+        case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+        case 283 /* SyntaxKind.MissingDeclaration */:
+        case 244 /* SyntaxKind.VariableStatement */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 346 /* SyntaxKind.JSImportDeclaration */:
+        case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+        case 279 /* SyntaxKind.ExportDeclaration */:
+        case 278 /* SyntaxKind.ExportAssignment */:
+            return true;
+    }
+    return false;
+}
+export function canHaveDecorators(node) {
+    switch (node.kind) {
+        case 170 /* SyntaxKind.Parameter */:
+        case 173 /* SyntaxKind.PropertyDeclaration */:
+        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 178 /* SyntaxKind.GetAccessor */:
+        case 179 /* SyntaxKind.SetAccessor */:
+        case 232 /* SyntaxKind.ClassExpression */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+            return true;
+    }
+    return false;
+}
+export function isStringLiteralLike(node) {
+    return node.kind === 10 /* SyntaxKind.StringLiteral */ || node.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */;
+}
+/** Whether two JSX tag names (identifiers, `this`, namespaced names or property accesses) are the same. */
+export function tagNamesAreEquivalent(lhs, rhs) {
+    if (lhs.kind !== rhs.kind)
+        return false;
+    if (lhs instanceof Identifier && rhs instanceof Identifier)
+        return lhs.text === rhs.text;
+    if (lhs.kind === 109 /* SyntaxKind.ThisKeyword */)
+        return true;
+    if (lhs instanceof JsxNamespacedName && rhs instanceof JsxNamespacedName)
+        return (lhs.namespace.text === rhs.namespace.text &&
+            lhs.name.text === rhs.name.text);
+    if (lhs instanceof PropertyAccessExpression && rhs instanceof PropertyAccessExpression)
+        return (getText(lhs.name) === getText(rhs.name) &&
+            tagNamesAreEquivalent(lhs.expression, rhs.expression));
+    throw new Error('Unhandled case in tagNamesAreEquivalent');
+}
+/** The source text of a node, without leading trivia. */
+export function getTextOfNodeFromSourceText(sourceText, node) {
+    if (nodeIsMissing(node))
+        return '';
+    const text = sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
+    if ((node.flags & 268435456 /* NodeFlags.ReparserTransformedLiteral */) !== 0) {
+        if (node instanceof StringLiteral)
+            return (node.tokenFlags & 65536 /* TokenFlags.SingleQuote */) !== 0 ? "'" + text + "'" : '"' + text + '"';
+        if (node instanceof Identifier)
+            return node.text;
+        throw new Error('Unexpected reparser-transformed node kind');
+    }
+    return text;
+}
+export function isImportMeta(node) {
+    return (node instanceof MetaProperty &&
+        node.keywordToken === 101 /* SyntaxKind.ImportKeyword */ &&
+        node.name.text === 'meta');
+}
+/** `import(…)` or `import.defer(…)`. */
+export function isImportCall(node) {
+    if (!(node instanceof CallExpression))
+        return false;
+    const e = node.expression;
+    if (e.kind === 101 /* SyntaxKind.ImportKeyword */)
+        return true;
+    if (!(e instanceof MetaProperty))
+        return false;
+    const meta = e;
+    return meta.keywordToken === 101 /* SyntaxKind.ImportKeyword */ && meta.name.text === 'defer';
+}
+/** `require(x)` with one argument, a string literal if `requireStringLiteralLikeArgument`. */
+export function isRequireCall(node, requireStringLiteralLikeArgument) {
+    if (!(node instanceof CallExpression))
+        return false;
+    const call = node;
+    const callee = call.expression;
+    if (!(callee instanceof Identifier) || callee.text !== 'require')
+        return false;
+    const args = call.arguments.nodes;
+    if (args.length !== 1)
+        return false;
+    return !requireStringLiteralLikeArgument || isStringLiteralLike(args[0]);
+}
+/** The string literal of `import("x")` types. */
+export function getImportTypeNodeLiteral(node) {
+    if (node instanceof ImportTypeNode) {
+        const argument = node.argument;
+        if (argument instanceof LiteralTypeNode && argument.literal.kind === 10 /* SyntaxKind.StringLiteral */)
+            return argument.literal;
+    }
+    return undefined;
+}
+export function isLiteralImportTypeNode(node) {
+    return getImportTypeNodeLiteral(node) !== undefined;
+}
+export function isAnyImportOrReExport(node) {
+    switch (node.kind) {
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 346 /* SyntaxKind.JSImportDeclaration */:
+        case 279 /* SyntaxKind.ExportDeclaration */:
+            return true;
+    }
+    return false;
+}
+export function getExternalModuleName(node) {
+    switch (node.kind) {
+        case 273 /* SyntaxKind.ImportDeclaration */:
+        case 346 /* SyntaxKind.JSImportDeclaration */:
+        case 279 /* SyntaxKind.ExportDeclaration */:
+            return getModuleSpecifier(node);
+        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            if (node instanceof ImportEqualsDeclaration) {
+                const reference = node.moduleReference;
+                if (reference instanceof ExternalModuleReference)
+                    return reference.expression;
+            }
+            return undefined;
+        case 206 /* SyntaxKind.ImportType */:
+            return getImportTypeNodeLiteral(node);
+        case 214 /* SyntaxKind.CallExpression */:
+            if (node instanceof CallExpression) {
+                const args = node.arguments.nodes;
+                return args.length > 0 ? args[0] : undefined;
+            }
+            return undefined;
+        case 268 /* SyntaxKind.ModuleDeclaration */:
+            if (node instanceof ModuleDeclaration) {
+                const name = node.name;
+                if (name.kind === 10 /* SyntaxKind.StringLiteral */)
+                    return name;
+            }
+            return undefined;
+    }
+    throw new Error('Unhandled case in getExternalModuleName');
+}
+export function isGlobalScopeAugmentation(node) {
+    return node instanceof ModuleDeclaration && node.keyword === 162 /* SyntaxKind.GlobalKeyword */;
+}
+/** Whether a node is written type-only: an `import type` clause, or a `type` specifier, import or export. */
+export function isTypeOnly(node) {
+    if (node.kind === 274 /* SyntaxKind.ImportClause */)
+        return node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */;
+    return getIsTypeOnly(node);
+}
+/** Whether a declaration declares only a type. */
+export function isTypeDeclaration(node) {
+    switch (node.kind) {
+        case 169 /* SyntaxKind.TypeParameter */:
+        case 264 /* SyntaxKind.ClassDeclaration */:
+        case 265 /* SyntaxKind.InterfaceDeclaration */:
+        case 266 /* SyntaxKind.TypeAliasDeclaration */:
+        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 267 /* SyntaxKind.EnumDeclaration */:
+            return true;
+        case 274 /* SyntaxKind.ImportClause */:
+            return isTypeOnly(node);
+        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 282 /* SyntaxKind.ExportSpecifier */:
+            return isTypeOnly(node.parent.parent);
+    }
+    return false;
+}
+export function isAmbientModule(node) {
+    if (!(node instanceof ModuleDeclaration))
+        return false;
+    const declaration = node;
+    return declaration.name.kind === 10 /* SyntaxKind.StringLiteral */ || declaration.keyword === 162 /* SyntaxKind.GlobalKeyword */;
+}
+/** Whether `node` is a JavaScript `/** @type {T} *\/ (x)` cast, reparsed as a parenthesized `as` expression. */
+export function isJSDocTypeAssertion(node) {
+    if (node.kind !== 218 /* SyntaxKind.ParenthesizedExpression */ || !isInJSFile(node))
+        return false;
+    const expression = getExpression(node);
+    if (expression === undefined || expression.kind !== 235 /* SyntaxKind.AsExpression */)
+        return false;
+    const type = getType(expression);
+    return type !== undefined && (type.flags & 8 /* NodeFlags.Reparsed */) !== 0;
+}
+/** The expression a check applies to: parentheses and `satisfies` are skipped, but not JavaScript casts. */
+export function getEffectiveCheckNode(argument) {
+    const inJS = isInJSFile(argument);
+    let node = argument;
+    for (;;) {
+        if (node.kind === 218 /* SyntaxKind.ParenthesizedExpression */ && !(inJS && isJSDocTypeAssertion(node)))
+            node = getExpression(node);
+        else if (node.kind === 239 /* SyntaxKind.SatisfiesExpression */)
+            node = getExpression(node);
+        else
+            return node;
+    }
+}