/*! ***************************************************************************** Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT. See the Apache Version 2.0 License for specific language governing permissions and limitations under the License. ***************************************************************************** */ declare namespace ts { /** * Type of objects whose values are all of the same type. * The `in` and `for-in` operators can *not* be safely used, * since `Object.prototype` may be modified by outside code. */ interface MapLike { [index: string]: T; } /** ES6 Map interface. */ interface Map { get(key: string): T | undefined; has(key: string): boolean; set(key: string, value: T): this; delete(key: string): boolean; clear(): void; forEach(action: (value: T, key: string) => void): void; readonly size: number; keys(): Iterator; values(): Iterator; entries(): Iterator<[string, T]>; } /** ES6 Iterator type. */ interface Iterator { next(): { value: T; done: false; } | { value: never; done: true; }; } type Path = string & { __pathBrand: any; }; interface TextRange { pos: number; end: number; } const enum SyntaxKind { Unknown = 0, /** 文件结束令牌 */ EndOfFileToken = 1, /** 单行注释琐事 */ SingleLineCommentTrivia = 2, /** 多行注释琐事 */ MultiLineCommentTrivia = 3, /** 新行琐事 */ NewLineTrivia = 4, /** 空白琐事 */ WhitespaceTrivia = 5, /** 工作琐事 我们发现和保存#！在第一行 */ ShebangTrivia = 6, /**冲突标记的琐事 我们发现，并提供更好的错误恢复时，我们遇到一个Git合并标记。这使我们能够以更为愉悦的方式编辑带有Git冲突标记的文件。 */ ConflictMarkerTrivia = 7, /** 数组字面量 */ NumericLiteral = 8, /** 文本字面量 */ StringLiteral = 9, /** jsx文本 */ JsxText = 10, JsxTextAllWhiteSpaces = 11, /** 正则表达式的文字 */ RegularExpressionLiteral = 12, /** 无替换模板文字 */ NoSubstitutionTemplateLiteral = 13, /** 伪文字 模板的头 */ TemplateHead = 14, /** 伪文字 模板中间 */ TemplateMiddle = 15, /** 伪文字 模板的尾 */ TemplateTail = 16, /** { */ OpenBraceToken = 17, /** } */ CloseBraceToken = 18, /** ( */ OpenParenToken = 19, /** ) */ CloseParenToken = 20, /** [ */ OpenBracketToken = 21, /** ] */ CloseBracketToken = 22, /** . 点 */ DotToken = 23, /** ... */ DotDotDotToken = 24, /** ; 分号标记 */ SemicolonToken = 25, /** , 逗号令牌 */ CommaToken = 26, /** < 小于令牌 */ LessThanToken = 27, /** 大于令牌 */ GreaterThanToken = 29, /** <=小于等于令牌 */ LessThanEqualsToken = 30, /** >= */ GreaterThanEqualsToken = 31, /** == */ EqualsEqualsToken = 32, /** != */ ExclamationEqualsToken = 33, /** === */ EqualsEqualsEqualsToken = 34, /** !== */ ExclamationEqualsEqualsToken = 35, /** => */ EqualsGreaterThanToken = 36, /*** + */ PlusToken = 37, /** -减 */ MinusToken = 38, /** *星 */ AsteriskToken = 39, /** ** 星星 */ AsteriskAsteriskToken = 40, /** / 斜杠 */ SlashToken = 41, /** % */ PercentToken = 42, /** ++ */ PlusPlusToken = 43, /** -- */ MinusMinusToken = 44, /** << */ LessThanLessThanToken = 45, /** >> */ GreaterThanGreaterThanToken = 46, /** >>> */ GreaterThanGreaterThanGreaterThanToken = 47, /** & */ AmpersandToken = 48, /** | */ BarToken = 49, /** ^ */ CaretToken = 50, /** ! */ ExclamationToken = 51, /** ~ */ TildeToken = 52, /** && */ AmpersandAmpersandToken = 53, /** || */ BarBarToken = 54, /** ? */ QuestionToken = 55, /** : */ ColonToken = 56, /** @ */ AtToken = 57, /** = */ EqualsToken = 58, /** += */ PlusEqualsToken = 59, /** -= */ MinusEqualsToken = 60, /** *= */ AsteriskEqualsToken = 61, /** **= */ AsteriskAsteriskEqualsToken = 62, /** /= */ SlashEqualsToken = 63, /** %= */ PercentEqualsToken = 64, /** <<= */ LessThanLessThanEqualsToken = 65, /** >>= */ GreaterThanGreaterThanEqualsToken = 66, /** >>>= */ GreaterThanGreaterThanGreaterThanEqualsToken = 67, /** &= */ AmpersandEqualsToken = 68, /** |= */ BarEqualsToken = 69, /** ^= */ CaretEqualsToken = 70, /** 标识符 */ Identifier = 71, /** 跳出 */ BreakKeyword = 72, /** 为 */ CaseKeyword = 73, /** 捕获 */ CatchKeyword = 74, /** 类 */ ClassKeyword = 75, /** 常量 */ ConstKeyword = 76, /** 继续 */ ContinueKeyword = 77, /** 调试 */ DebuggerKeyword = 78, /** 默认 */ DefaultKeyword = 79, /** 删除 */ DeleteKeyword = 80, /** 做do */ DoKeyword = 81, /** 否则 */ ElseKeyword = 82, /** 枚举 */ EnumKeyword = 83, /** 导出 */ ExportKeyword = 84, /** 扩展 */ ExtendsKeyword = 85, /** 假 */ FalseKeyword = 86, /** 最后 */ FinallyKeyword = 87, /** 循环 */ ForKeyword = 88, /** 函数 */ FunctionKeyword = 89, /** 如果 */ IfKeyword = 90, /** 引入 */ ImportKeyword = 91, /** 在 */ InKeyword = 92, /** 类为 */ InstanceOfKeyword = 93, /** 新建 */ NewKeyword = 94, /** 空 */ NullKeyword = 95, /** 返回 */ ReturnKeyword = 96, /** 父构造器 */ SuperKeyword = 97, /** 静态 */ SwitchKeyword = 98, /** 本对象 */ ThisKeyword = 99, /** 抛出 */ ThrowKeyword = 100, /** 真 */ TrueKeyword = 101, /** 尝试 */ TryKeyword = 102, /** 类型为 */ TypeOfKeyword = 103, /** 自由变量 */ VarKeyword = 104, /** 无值 */ VoidKeyword = 105, /** 判断循环 */ WhileKeyword = 106, /** 外扩 */ WithKeyword = 107, /** 实现 */ ImplementsKeyword = 108, /** 接口 */ InterfaceKeyword = 109, /** 变量 */ LetKeyword = 110, /** 包 */ PackageKeyword = 111, /** 私有 */ PrivateKeyword = 112, /** 保护 */ ProtectedKeyword = 113, /** 公开 */ PublicKeyword = 114, /** 静态 */ StaticKeyword = 115, /** 获取 */ YieldKeyword = 116, /**抽象 */ AbstractKeyword = 117, /** 转为 */ AsKeyword = 118, /** 任何 */ AnyKeyword = 119, /** 异步 */ AsyncKeyword = 120, /** 等待 */ AwaitKeyword = 121, /** 布尔 */ BooleanKeyword = 122, /** 构造器 */ ConstructorKeyword = 123, /** 声明 */ DeclareKeyword = 124, /** 取 */ GetKeyword = 125, /** 是 */ IsKeyword = 126, /** 键为 */ KeyOfKeyword = 127, /** 模块 */ ModuleKeyword = 128, /** 名称空间 */ NamespaceKeyword = 129, /** 不可及 */ NeverKeyword = 130, /** 只读 */ ReadonlyKeyword = 131, /** 需求 */ RequireKeyword = 132, /** 数字 */ NumberKeyword = 133, /** 基对象 */ ObjectKeyword = 134, /** 置 */ SetKeyword = 135, /** 文本 */ StringKeyword = 136, /** 符号 */ SymbolKeyword = 137, /** 类型 */ TypeKeyword = 138, /** 未定义 */ UndefinedKeyword = 139, /** 从 */ FromKeyword = 140, /** 全局 */ GlobalKeyword = 141, /** 属于 */ OfKeyword = 142, /** 限定名 */ QualifiedName = 143, /** 计算属性名 */ ComputedPropertyName = 144, /** 类型参数 */ TypeParameter = 145, /** 参数 */ Parameter = 146, /** 装饰 */ Decorator = 147, /** 属性签名 */ PropertySignature = 148, /** 属性声明 */ PropertyDeclaration = 149, /** 成员签名 */ MethodSignature = 150, /** 成员声明 */ MethodDeclaration = 151, /** 构造函数 */ Constructor = 152, /** get */ GetAccessor = 153, /** 置 */ SetAccessor = 154, /** call */ CallSignature = 155, /**构造签名*/ ConstructSignature = 156, /** 索引签名 */ IndexSignature = 157, /** 类型谓词 */ TypePredicate = 158, /** 类型引用 */ TypeReference = 159, /** 函数类型 */ FunctionType = 160, /** 构造器类型 */ ConstructorType = 161, /** 类型查询 */ TypeQuery = 162, /** 类型字面量 */ TypeLiteral = 163, /** 数组类型 */ ArrayType = 164, /** 元组类型 */ TupleType = 165, /** 联合类型 */ UnionType = 166, /** 交叉类型 */ IntersectionType = 167, /** 括号类型 */ ParenthesizedType = 168, /** 本对象类型 */ ThisType = 169, /** 类型运算符 */ TypeOperator = 170, /** 索引访问类型 */ IndexedAccessType = 171, /** 映射类型 */ MappedType = 172, /** 字面量类型 */ LiteralType = 173, /** 基对象绑定类型 */ ObjectBindingPattern = 174, /** 数组绑定类型 */ ArrayBindingPattern = 175, /** 绑定元素 */ BindingElement = 176, /** 数组字面量表达式 */ ArrayLiteralExpression = 177, /** 对象字面量表达式 */ ObjectLiteralExpression = 178, /** 属性访问表达式 */ PropertyAccessExpression = 179, /** 元数据访问表达式 */ ElementAccessExpression = 180, /** call表达式 */ CallExpression = 181, /** 新建表达式 */ NewExpression = 182, /** 标签模板表达式 */ TaggedTemplateExpression = 183, /** 类型声明表达式 */ TypeAssertionExpression = 184, /** 括号表达式 */ ParenthesizedExpression = 185, /** 函数表达式 */ FunctionExpression = 186, /** 箭头函数 */ ArrowFunction = 187, /** 删除表达式 */ DeleteExpression = 188, /** 类型为 表达式 */ TypeOfExpression = 189, /** 无值 表达式 */ VoidExpression = 190, /** 等待 表达式 */ AwaitExpression = 191, /** 前缀一元表达式 */ PrefixUnaryExpression = 192, /** 后缀一元表达式， */ PostfixUnaryExpression = 193, /** 二元表达式 */ BinaryExpression = 194, /** 条件表达式 */ ConditionalExpression = 195, /** 模板的表达 `${}` */ TemplateExpression = 196, /** 获取 表达式 */ YieldExpression = 197, /** 传播表达式 */ SpreadElement = 198, /** 类表达式 */ ClassExpression = 199, /** 略的表达 ... */ OmittedExpression = 200, /** 类型参数表达式， */ ExpressionWithTypeArguments = 201, /** 转为表达式 */ AsExpression = 202, /** 非空表达式 */ NonNullExpression = 203, /** 元属性表达式 */ MetaProperty = 204, /** 模板跨度 */ TemplateSpan = 205, /** 分号类元素 */ SemicolonClassElement = 206, /** 块 */ Block = 207, /** 变量语句 */ VariableStatement = 208, /** 空语句 */ EmptyStatement = 209, /** 表达式语句 */ ExpressionStatement = 210, /** 如果 语句 */ IfStatement = 211, /** 点语句 */ DoStatement = 212, /** 判断循环语句 */ WhileStatement = 213, /** 循环语句 */ ForStatement = 214, /** 循环在语句 */ ForInStatement = 215, /** 循环属于 语句 */ ForOfStatement = 216, /** 继续语句 */ ContinueStatement = 217, /** 跳出语句 */ BreakStatement = 218, /** 返回语句 */ ReturnStatement = 219, /** 外扩语句 */ WithStatement = 220, /** 假如语句 */ SwitchStatement = 221, /** 标签语句 */ LabeledStatement = 222, /** 抛出语句 */ ThrowStatement = 223, /** 尝试语句 */ TryStatement = 224, /** 调试语句 */ DebuggerStatement = 225, /** 变量的声明 */ VariableDeclaration = 226, /** 变量列表声明 */ VariableDeclarationList = 227, /** 函数声明 */ FunctionDeclaration = 228, /** 类声明 */ ClassDeclaration = 229, /** 接口声明 */ InterfaceDeclaration = 230, /** 类型别名声明 */ TypeAliasDeclaration = 231, /** 枚举声明 */ EnumDeclaration = 232, /** 模块声明 */ ModuleDeclaration = 233, /** 模块块 */ ModuleBlock = 234, /** 为 块 */ CaseBlock = 235, /** 名称空间导出声明 */ NamespaceExportDeclaration = 236, /** 引入等于声明 */ ImportEqualsDeclaration = 237, /** 引入声明 */ ImportDeclaration = 238, /** 引入规范 */ ImportClause = 239, /** 名称空间引入 */ NamespaceImport = 240, /** 名子引入 */ NamedImports = 241, /** 引入说明符 */ ImportSpecifier = 242, /** 出口赋值 */ ExportAssignment = 243, /** 出口声明 */ ExportDeclaration = 244, /** 名子导出 */ NamedExports = 245, /** 出口符号 */ ExportSpecifier = 246, /** 失踪声明 */ MissingDeclaration = 247, /** 外部模块的参考 */ ExternalModuleReference = 248, /** jsx元素 */ JsxElement = 249, /** jsx自关闭元素 */ JsxSelfClosingElement = 250, /** jsx打开元素 */ JsxOpeningElement = 251, /** jsx关闭元素 */ JsxClosingElement = 252, /** jsx特性 */ JsxAttribute = 253, /** jsx特性集 */ JsxAttributes = 254, /** jsx传播特性 */ JsxSpreadAttribute = 255, /** jsx表达式 */ JsxExpression = 256, /** 为 子句 */ CaseClause = 257, /** 默认子句 */ DefaultClause = 258, /** 遗产子句 */ HeritageClause = 259, /** 捕获子句 */ CatchClause = 260, /** 属性赋值 */ PropertyAssignment = 261, /** 速记属性赋值 */ ShorthandPropertyAssignment = 262, /** 传播赋值 */ SpreadAssignment = 263, /** 枚举成员 */ EnumMember = 264, /** 源码文件 */ SourceFile = 265, /** 程序集 */ Bundle = 266, /** JSD类型表达式 */ JSDocTypeExpression = 267, /** JSD * 类型 */ JSDocAllType = 268, /** JSD ?类型 */ JSDocUnknownType = 269, /** JSD空标签类型 */ JSDocNullableType = 270, /** JSD非空标签类型 */ JSDocNonNullableType = 271, /** JSD可选类型 */ JSDocOptionalType = 272, /** JSD函数类型 */ JSDocFunctionType = 273, /** JSD变量 */ JSDocVariadicType = 274, /** JSD注释类型 */ JSDocComment = 275, /** JSD标签 */ JSDocTag = 276, /** JSD增强标签 */ JSDocAugmentsTag = 277, /** JSD类标签 */ JSDocClassTag = 278, /** JSD参数标签 */ JSDocParameterTag = 279, /** JSD返回值标签 */ JSDocReturnTag = 280, /** JSD类型标签 */ JSDocTypeTag = 281, /** JSD模板标签 */ JSDocTemplateTag = 282, /** JSD定义标签 */ JSDocTypedefTag = 283, /** JSD属性标签 */ JSDocPropertyTag = 284, /** JSD类型字面量 */ JSDocTypeLiteral = 285, 全局词典语句 = 286, 局部词典语句 = 287, 词典键 = 288, 词典值 = 289, 词典表达式 = 290, /** 语法表 */ SyntaxList = 291, /** 不发射语句 */ NotEmittedStatement = 292, /** 部分发出表达式 */ PartiallyEmittedExpression = 293, /**逗号表达式列表 */ CommaListExpression = 294, /** 合并申报的标记 */ MergeDeclarationMarker = 295, /** 声明结束标记 */ EndOfDeclarationMarker = 296, /** 常量 */ Count = 297, /**第一个赋值 = 等于令牌 */ FirstAssignment = 58, /**最后一个赋值 = ^=令牌 */ LastAssignment = 70, /**第一个复合赋值 = +=令牌 */ FirstCompoundAssignment = 59, /**最后一个复合赋值= ^=令牌 */ LastCompoundAssignment = 70, /**第一个保留关键字 = 跳出令牌 */ FirstReservedWord = 72, /**最后一个保留关键字 = 外扩令牌 */ LastReservedWord = 107, /**第一个关键字 = 跳出令牌 */ FirstKeyword = 72, /**最后一个关键字 = 属于令牌 */ LastKeyword = 142, /**第一个未来保证字 = 实现令牌 */ FirstFutureReservedWord = 108, /**最后一个未来保留字 = 获取令牌 */ LastFutureReservedWord = 116, /**第一个类型节点 = 类型谓词 */ FirstTypeNode = 158, /**最后一个类型接 = 字面量类型 */ LastTypeNode = 173, /**第一个标点符号 = { 开大括号令牌 */ FirstPunctuation = 17, /**最后一个标点符号 = ^=令牌 */ LastPunctuation = 70, /**第一个令牌 = 未知 */ FirstToken = 0, /**最后一个令牌 = 最后一个关键字 */ LastToken = 142, /**第一个杂项令牌 = //单行注释 */ FirstTriviaToken = 2, /**最后一个杂项令牌 =git冲突标记 */ LastTriviaToken = 7, /**第一个字面量令牌 = 数字字面量 */ FirstLiteralToken = 8, /**最后一个字面量令牌 =无替换模板字面量 */ LastLiteralToken = 13, /**第一个模板标记 = 无替换模板文字 */ FirstTemplateToken = 13, /**最后一个模板标记 = 伪文字 模板的尾*/ LastTemplateToken = 16, /**第一个二元运算符 = < 令牌 */ FirstBinaryOperator = 27, /**最后一个二元运算符 = ^=令牌 */ LastBinaryOperator = 70, /**第一个节点 = 限定名 */ FirstNode = 143, /**第一个JSD节点 = JSD类型表达式 */ FirstJSDocNode = 267, /**最后一个JSD节点 = JSD类型字面量 */ LastJSDocNode = 285, /**第一个JSD标签节点 = JSD标签 */ FirstJSDocTagNode = 276, /**最后一个JSD标签节点 = JSD字类型面量 */ LastJSDocTagNode = 285, } const enum NodeFlags { None = 0, Let = 1, Const = 2, NestedNamespace = 4, Synthesized = 8, Namespace = 16, ExportContext = 32, ContainsThis = 64, HasImplicitReturn = 128, HasExplicitReturn = 256, GlobalAugmentation = 512, HasAsyncFunctions = 1024, DisallowInContext = 2048, YieldContext = 4096, DecoratorContext = 8192, AwaitContext = 16384, ThisNodeHasError = 32768, JavaScriptFile = 65536, ThisNodeOrAnySubNodesHasError = 131072, HasAggregatedChildData = 262144, JSDoc = 1048576, 词典标签 = 2097152, BlockScoped = 3, ReachabilityCheckFlags = 384, ReachabilityAndEmitFlags = 1408, ContextFlags = 96256, TypeExcludesFlags = 20480, } const enum ModifierFlags { None = 0, Export = 1, Ambient = 2, Public = 4, Private = 8, Protected = 16, Static = 32, Readonly = 64, Abstract = 128, Async = 256, Default = 512, Const = 2048, HasComputedFlags = 536870912, AccessibilityModifier = 28, ParameterPropertyModifier = 92, NonPublicAccessibilityModifier = 24, TypeScriptModifier = 2270, ExportDefault = 513, } const enum JsxFlags { None = 0, /** An element from a named property of the JSX.IntrinsicElements interface */ IntrinsicNamedElement = 1, /** An element inferred from the string index signature of the JSX.IntrinsicElements interface */ IntrinsicIndexedElement = 2, IntrinsicElement = 3, } interface Node extends TextRange { kind: SyntaxKind; flags: NodeFlags; 别名?: 别名; 别名id?: number; 局部词典语句?: 局部词典语句[]; decorators?: NodeArray; modifiers?: ModifiersArray; parent?: Node; } interface 词典键 extends Node { kind: SyntaxKind.词典键 | SyntaxKind.词典值; name: Identifier | StringLiteral; } interface 词典值 extends Node { kind: SyntaxKind.词典值 | SyntaxKind.词典键; name: Identifier | StringLiteral; } interface 词典 extends Expression { kind: SyntaxKind.词典表达式; 键: 词典键; 值: 词典值; 是局部词典?: 别名旗帜; 是单向词典?: 别名旗帜; 是内置词典?: 别名旗帜; 是文本字面量词典?: 别名旗帜; 词典类别?: 别名旗帜; 引用节点?: Map; } const enum 别名旗帜 { 空 = 0, 英汉 = 1, 汉英 = 2, 字面量 = 4, 局部词典 = 8, 单向词典 = 16, 内置词典 = 32, 是全局导出 = 64, } interface 别名 { 旗帜: 别名旗帜; 名称: __String; } type 别名组 = UnderscoreEscapedMap<别名[]>; interface 全局词典语句 extends Statement { kind: SyntaxKind.全局词典语句; 表达式: NodeArray<词典>; } interface 局部词典语句 extends Statement { kind: SyntaxKind.局部词典语句; 表达式: NodeArray<词典>; } interface NodeArray extends Array, TextRange { hasTrailingComma?: boolean; } interface Token extends Node { kind: TKind; } type DotDotDotToken = Token; type QuestionToken = Token; type ColonToken = Token; type EqualsToken = Token; type AsteriskToken = Token; type EqualsGreaterThanToken = Token; type EndOfFileToken = Token; type AtToken = Token; type ReadonlyToken = Token; type AwaitKeywordToken = Token; type Modifier = Token | Token | Token | Token | Token | Token | Token | Token | Token | Token | Token; type ModifiersArray = NodeArray; interface Identifier extends PrimaryExpression { kind: SyntaxKind.Identifier; /** * Text of identifier (with escapes converted to characters). * If the identifier begins with two underscores, this will begin with three. */ text: __String; originalKeywordKind?: SyntaxKind; isInJSDocNamespace?: boolean; } interface TransientIdentifier extends Identifier { resolvedSymbol: Symbol; } interface QualifiedName extends Node { kind: SyntaxKind.QualifiedName; left: EntityName; right: Identifier; } type EntityName = Identifier | QualifiedName; type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName; type DeclarationName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | BindingPattern; interface Declaration extends Node { _declarationBrand: any; } interface NamedDeclaration extends Declaration { name?: DeclarationName; } interface DeclarationStatement extends NamedDeclaration, Statement { name?: Identifier | StringLiteral | NumericLiteral; } interface ComputedPropertyName extends Node { kind: SyntaxKind.ComputedPropertyName; expression: Expression; } interface Decorator extends Node { kind: SyntaxKind.Decorator; expression: LeftHandSideExpression; } interface TypeParameterDeclaration extends NamedDeclaration { kind: SyntaxKind.TypeParameter; parent?: DeclarationWithTypeParameters; name: Identifier; constraint?: TypeNode; default?: TypeNode; expression?: Expression; } interface SignatureDeclaration extends NamedDeclaration { name?: PropertyName; typeParameters?: NodeArray; parameters: NodeArray; type?: TypeNode; } interface CallSignatureDeclaration extends SignatureDeclaration, TypeElement { kind: SyntaxKind.CallSignature; } interface ConstructSignatureDeclaration extends SignatureDeclaration, TypeElement { kind: SyntaxKind.ConstructSignature; } type BindingName = Identifier | BindingPattern; interface VariableDeclaration extends NamedDeclaration { kind: SyntaxKind.VariableDeclaration; parent?: VariableDeclarationList | CatchClause; name: BindingName; type?: TypeNode; initializer?: Expression; } interface VariableDeclarationList extends Node { kind: SyntaxKind.VariableDeclarationList; parent?: VariableStatement | ForStatement | ForOfStatement | ForInStatement; declarations: NodeArray; } interface ParameterDeclaration extends NamedDeclaration { kind: SyntaxKind.Parameter; parent?: SignatureDeclaration; dotDotDotToken?: DotDotDotToken; name: BindingName; questionToken?: QuestionToken; type?: TypeNode; initializer?: Expression; } interface BindingElement extends NamedDeclaration { kind: SyntaxKind.BindingElement; parent?: BindingPattern; propertyName?: PropertyName; dotDotDotToken?: DotDotDotToken; name: BindingName; initializer?: Expression; } interface PropertySignature extends TypeElement { kind: SyntaxKind.PropertySignature; name: PropertyName; questionToken?: QuestionToken; type?: TypeNode; initializer?: Expression; } interface PropertyDeclaration extends ClassElement { kind: SyntaxKind.PropertyDeclaration; questionToken?: QuestionToken; name: PropertyName; type?: TypeNode; initializer?: Expression; } interface ObjectLiteralElement extends NamedDeclaration { _objectLiteralBrandBrand: any; name?: PropertyName; } type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | MethodDeclaration | AccessorDeclaration; interface PropertyAssignment extends ObjectLiteralElement { kind: SyntaxKind.PropertyAssignment; name: PropertyName; questionToken?: QuestionToken; initializer: Expression; } interface ShorthandPropertyAssignment extends ObjectLiteralElement { kind: SyntaxKind.ShorthandPropertyAssignment; name: Identifier; questionToken?: QuestionToken; equalsToken?: Token; objectAssignmentInitializer?: Expression; } interface SpreadAssignment extends ObjectLiteralElement { kind: SyntaxKind.SpreadAssignment; expression: Expression; } interface VariableLikeDeclaration extends NamedDeclaration { propertyName?: PropertyName; dotDotDotToken?: DotDotDotToken; name: DeclarationName; questionToken?: QuestionToken; type?: TypeNode; initializer?: Expression; } interface PropertyLikeDeclaration extends NamedDeclaration { name: PropertyName; } interface ObjectBindingPattern extends Node { kind: SyntaxKind.ObjectBindingPattern; parent?: VariableDeclaration | ParameterDeclaration | BindingElement; elements: NodeArray; } interface ArrayBindingPattern extends Node { kind: SyntaxKind.ArrayBindingPattern; parent?: VariableDeclaration | ParameterDeclaration | BindingElement; elements: NodeArray; } type BindingPattern = ObjectBindingPattern | ArrayBindingPattern; type ArrayBindingElement = BindingElement | OmittedExpression; /** * Several node kinds share function-like features such as a signature, * a name, and a body. These nodes should extend FunctionLikeDeclarationBase. * Examples: * - FunctionDeclaration * - MethodDeclaration * - AccessorDeclaration */ interface FunctionLikeDeclarationBase extends SignatureDeclaration { _functionLikeDeclarationBrand: any; asteriskToken?: AsteriskToken; questionToken?: QuestionToken; body?: Block | Expression; } type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | FunctionExpression | ArrowFunction; type FunctionLike = FunctionLikeDeclaration | FunctionTypeNode | ConstructorTypeNode | IndexSignatureDeclaration | MethodSignature | ConstructSignatureDeclaration | CallSignatureDeclaration; interface FunctionDeclaration extends FunctionLikeDeclarationBase, DeclarationStatement { kind: SyntaxKind.FunctionDeclaration; name?: Identifier; body?: FunctionBody; } interface MethodSignature extends SignatureDeclaration, TypeElement { kind: SyntaxKind.MethodSignature; name: PropertyName; } interface MethodDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement { kind: SyntaxKind.MethodDeclaration; name: PropertyName; body?: FunctionBody; } interface ConstructorDeclaration extends FunctionLikeDeclarationBase, ClassElement { kind: SyntaxKind.Constructor; parent?: ClassDeclaration | ClassExpression; body?: FunctionBody; } /** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */ interface SemicolonClassElement extends ClassElement { kind: SyntaxKind.SemicolonClassElement; parent?: ClassDeclaration | ClassExpression; } interface GetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement { kind: SyntaxKind.GetAccessor; parent?: ClassDeclaration | ClassExpression | ObjectLiteralExpression; name: PropertyName; body: FunctionBody; } interface SetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement { kind: SyntaxKind.SetAccessor; parent?: ClassDeclaration | ClassExpression | ObjectLiteralExpression; name: PropertyName; body: FunctionBody; } type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration; interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement, TypeElement { kind: SyntaxKind.IndexSignature; parent?: ClassDeclaration | ClassExpression | InterfaceDeclaration | TypeLiteralNode; } interface TypeNode extends Node { _typeNodeBrand: any; } interface KeywordTypeNode extends TypeNode { kind: SyntaxKind.AnyKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.VoidKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.NullKeyword | SyntaxKind.NeverKeyword; } interface ThisTypeNode extends TypeNode { kind: SyntaxKind.ThisType; } type FunctionOrConstructorTypeNode = FunctionTypeNode | ConstructorTypeNode; interface FunctionTypeNode extends TypeNode, SignatureDeclaration { kind: SyntaxKind.FunctionType; } interface ConstructorTypeNode extends TypeNode, SignatureDeclaration { kind: SyntaxKind.ConstructorType; } type TypeReferenceType = TypeReferenceNode | ExpressionWithTypeArguments; interface TypeReferenceNode extends TypeNode { kind: SyntaxKind.TypeReference; typeName: EntityName; typeArguments?: NodeArray; } interface TypePredicateNode extends TypeNode { kind: SyntaxKind.TypePredicate; parameterName: Identifier | ThisTypeNode; type: TypeNode; } interface TypeQueryNode extends TypeNode { kind: SyntaxKind.TypeQuery; exprName: EntityName; } interface TypeLiteralNode extends TypeNode, Declaration { kind: SyntaxKind.TypeLiteral; members: NodeArray; } interface ArrayTypeNode extends TypeNode { kind: SyntaxKind.ArrayType; elementType: TypeNode; } interface TupleTypeNode extends TypeNode { kind: SyntaxKind.TupleType; elementTypes: NodeArray; } type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode; interface UnionTypeNode extends TypeNode { kind: SyntaxKind.UnionType; types: NodeArray; } interface IntersectionTypeNode extends TypeNode { kind: SyntaxKind.IntersectionType; types: NodeArray; } interface ParenthesizedTypeNode extends TypeNode { kind: SyntaxKind.ParenthesizedType; type: TypeNode; } interface TypeOperatorNode extends TypeNode { kind: SyntaxKind.TypeOperator; operator: SyntaxKind.KeyOfKeyword; type: TypeNode; } interface IndexedAccessTypeNode extends TypeNode { kind: SyntaxKind.IndexedAccessType; objectType: TypeNode; indexType: TypeNode; } interface MappedTypeNode extends TypeNode, Declaration { kind: SyntaxKind.MappedType; parent?: TypeAliasDeclaration; readonlyToken?: ReadonlyToken; typeParameter: TypeParameterDeclaration; questionToken?: QuestionToken; type?: TypeNode; } interface LiteralTypeNode extends TypeNode { kind: SyntaxKind.LiteralType; literal: Expression; } interface StringLiteral extends LiteralExpression { kind: SyntaxKind.StringLiteral; } interface Expression extends Node { _expressionBrand: any; } interface OmittedExpression extends Expression { kind: SyntaxKind.OmittedExpression; } interface PartiallyEmittedExpression extends LeftHandSideExpression { kind: SyntaxKind.PartiallyEmittedExpression; expression: Expression; } interface UnaryExpression extends Expression { _unaryExpressionBrand: any; } /** Deprecated, please use UpdateExpression */ type IncrementExpression = UpdateExpression; interface UpdateExpression extends UnaryExpression { _updateExpressionBrand: any; } type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken; interface PrefixUnaryExpression extends UpdateExpression { kind: SyntaxKind.PrefixUnaryExpression; operator: PrefixUnaryOperator; operand: UnaryExpression; } type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken; interface PostfixUnaryExpression extends UpdateExpression { kind: SyntaxKind.PostfixUnaryExpression; operand: LeftHandSideExpression; operator: PostfixUnaryOperator; } interface LeftHandSideExpression extends UpdateExpression { _leftHandSideExpressionBrand: any; } interface MemberExpression extends LeftHandSideExpression { _memberExpressionBrand: any; } interface PrimaryExpression extends MemberExpression { _primaryExpressionBrand: any; } interface NullLiteral extends PrimaryExpression, TypeNode { kind: SyntaxKind.NullKeyword; } interface BooleanLiteral extends PrimaryExpression, TypeNode { kind: SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword; } interface ThisExpression extends PrimaryExpression, KeywordTypeNode { kind: SyntaxKind.ThisKeyword; } interface SuperExpression extends PrimaryExpression { kind: SyntaxKind.SuperKeyword; } interface ImportExpression extends PrimaryExpression { kind: SyntaxKind.ImportKeyword; } interface DeleteExpression extends UnaryExpression { kind: SyntaxKind.DeleteExpression; expression: UnaryExpression; } interface TypeOfExpression extends UnaryExpression { kind: SyntaxKind.TypeOfExpression; expression: UnaryExpression; } interface VoidExpression extends UnaryExpression { kind: SyntaxKind.VoidExpression; expression: UnaryExpression; } interface AwaitExpression extends UnaryExpression { kind: SyntaxKind.AwaitExpression; expression: UnaryExpression; } interface YieldExpression extends Expression { kind: SyntaxKind.YieldExpression; asteriskToken?: AsteriskToken; expression?: Expression; } type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken; type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken; type MultiplicativeOperatorOrHigher = ExponentiationOperator | MultiplicativeOperator; type AdditiveOperator = SyntaxKind.PlusToken | SyntaxKind.MinusToken; type AdditiveOperatorOrHigher = MultiplicativeOperatorOrHigher | AdditiveOperator; type ShiftOperator = SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken; type ShiftOperatorOrHigher = AdditiveOperatorOrHigher | ShiftOperator; type RelationalOperator = SyntaxKind.LessThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.InstanceOfKeyword | SyntaxKind.InKeyword; type RelationalOperatorOrHigher = ShiftOperatorOrHigher | RelationalOperator; type EqualityOperator = SyntaxKind.EqualsEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.ExclamationEqualsToken; type EqualityOperatorOrHigher = RelationalOperatorOrHigher | EqualityOperator; type BitwiseOperator = SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken; type BitwiseOperatorOrHigher = EqualityOperatorOrHigher | BitwiseOperator; type LogicalOperator = SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken; type LogicalOperatorOrHigher = BitwiseOperatorOrHigher | LogicalOperator; type CompoundAssignmentOperator = SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken; type AssignmentOperator = SyntaxKind.EqualsToken | CompoundAssignmentOperator; type AssignmentOperatorOrHigher = LogicalOperatorOrHigher | AssignmentOperator; type BinaryOperator = AssignmentOperatorOrHigher | SyntaxKind.CommaToken; type BinaryOperatorToken = Token; interface BinaryExpression extends Expression, Declaration { kind: SyntaxKind.BinaryExpression; left: Expression; operatorToken: BinaryOperatorToken; right: Expression; } type AssignmentOperatorToken = Token; interface AssignmentExpression extends BinaryExpression { left: LeftHandSideExpression; operatorToken: TOperator; } interface ObjectDestructuringAssignment extends AssignmentExpression { left: ObjectLiteralExpression; } interface ArrayDestructuringAssignment extends AssignmentExpression { left: ArrayLiteralExpression; } type DestructuringAssignment = ObjectDestructuringAssignment | ArrayDestructuringAssignment; type BindingOrAssignmentElement = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | OmittedExpression | SpreadElement | ArrayLiteralExpression | ObjectLiteralExpression | AssignmentExpression | Identifier | PropertyAccessExpression | ElementAccessExpression; type BindingOrAssignmentElementRestIndicator = DotDotDotToken | SpreadElement | SpreadAssignment; type BindingOrAssignmentElementTarget = BindingOrAssignmentPattern | Expression; type ObjectBindingOrAssignmentPattern = ObjectBindingPattern | ObjectLiteralExpression; type ArrayBindingOrAssignmentPattern = ArrayBindingPattern | ArrayLiteralExpression; type AssignmentPattern = ObjectLiteralExpression | ArrayLiteralExpression; type BindingOrAssignmentPattern = ObjectBindingOrAssignmentPattern | ArrayBindingOrAssignmentPattern; interface ConditionalExpression extends Expression { kind: SyntaxKind.ConditionalExpression; condition: Expression; questionToken: QuestionToken; whenTrue: Expression; colonToken: ColonToken; whenFalse: Expression; } type FunctionBody = Block; type ConciseBody = FunctionBody | Expression; interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclarationBase { kind: SyntaxKind.FunctionExpression; name?: Identifier; body: FunctionBody; } interface ArrowFunction extends Expression, FunctionLikeDeclarationBase { kind: SyntaxKind.ArrowFunction; equalsGreaterThanToken: EqualsGreaterThanToken; body: ConciseBody; } interface LiteralLikeNode extends Node { text: string; isUnterminated?: boolean; hasExtendedUnicodeEscape?: boolean; } interface LiteralExpression extends LiteralLikeNode, PrimaryExpression { _literalExpressionBrand: any; } interface RegularExpressionLiteral extends LiteralExpression { kind: SyntaxKind.RegularExpressionLiteral; } interface NoSubstitutionTemplateLiteral extends LiteralExpression { kind: SyntaxKind.NoSubstitutionTemplateLiteral; } interface NumericLiteral extends LiteralExpression { kind: SyntaxKind.NumericLiteral; } interface TemplateHead extends LiteralLikeNode { kind: SyntaxKind.TemplateHead; parent?: TemplateExpression; } interface TemplateMiddle extends LiteralLikeNode { kind: SyntaxKind.TemplateMiddle; parent?: TemplateSpan; } interface TemplateTail extends LiteralLikeNode { kind: SyntaxKind.TemplateTail; parent?: TemplateSpan; } type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral; interface TemplateExpression extends PrimaryExpression { kind: SyntaxKind.TemplateExpression; head: TemplateHead; templateSpans: NodeArray; } interface TemplateSpan extends Node { kind: SyntaxKind.TemplateSpan; parent?: TemplateExpression; expression: Expression; literal: TemplateMiddle | TemplateTail; } interface ParenthesizedExpression extends PrimaryExpression { kind: SyntaxKind.ParenthesizedExpression; expression: Expression; } interface ArrayLiteralExpression extends PrimaryExpression { kind: SyntaxKind.ArrayLiteralExpression; elements: NodeArray; } interface SpreadElement extends Expression { kind: SyntaxKind.SpreadElement; expression: Expression; } /** * This interface is a base interface for ObjectLiteralExpression and JSXAttributes to extend from. JSXAttributes is similar to * ObjectLiteralExpression in that it contains array of properties; however, JSXAttributes' properties can only be * JSXAttribute or JSXSpreadAttribute. ObjectLiteralExpression, on the other hand, can only have properties of type * ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.) */ interface ObjectLiteralExpressionBase extends PrimaryExpression, Declaration { properties: NodeArray; } interface ObjectLiteralExpression extends ObjectLiteralExpressionBase { kind: SyntaxKind.ObjectLiteralExpression; } type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression | ParenthesizedExpression; type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression; interface PropertyAccessExpression extends MemberExpression, NamedDeclaration { kind: SyntaxKind.PropertyAccessExpression; expression: LeftHandSideExpression; name: Identifier; } interface SuperPropertyAccessExpression extends PropertyAccessExpression { expression: SuperExpression; } /** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */ interface PropertyAccessEntityNameExpression extends PropertyAccessExpression { _propertyAccessExpressionLikeQualifiedNameBrand?: any; expression: EntityNameExpression; } interface ElementAccessExpression extends MemberExpression { kind: SyntaxKind.ElementAccessExpression; expression: LeftHandSideExpression; argumentExpression?: Expression; } interface SuperElementAccessExpression extends ElementAccessExpression { expression: SuperExpression; } type SuperProperty = SuperPropertyAccessExpression | SuperElementAccessExpression; interface CallExpression extends LeftHandSideExpression, Declaration { kind: SyntaxKind.CallExpression; expression: LeftHandSideExpression; typeArguments?: NodeArray; arguments: NodeArray; } interface SuperCall extends CallExpression { expression: SuperExpression; } interface ImportCall extends CallExpression { expression: ImportExpression; } interface ExpressionWithTypeArguments extends TypeNode { kind: SyntaxKind.ExpressionWithTypeArguments; parent?: HeritageClause; expression: LeftHandSideExpression; typeArguments?: NodeArray; } interface NewExpression extends PrimaryExpression, Declaration { kind: SyntaxKind.NewExpression; expression: LeftHandSideExpression; typeArguments?: NodeArray; arguments?: NodeArray; } interface TaggedTemplateExpression extends MemberExpression { kind: SyntaxKind.TaggedTemplateExpression; tag: LeftHandSideExpression; template: TemplateLiteral; } type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator | JsxOpeningLikeElement; interface AsExpression extends Expression { kind: SyntaxKind.AsExpression; expression: Expression; type: TypeNode; } interface TypeAssertion extends UnaryExpression { kind: SyntaxKind.TypeAssertionExpression; type: TypeNode; expression: UnaryExpression; } type AssertionExpression = TypeAssertion | AsExpression; interface NonNullExpression extends LeftHandSideExpression { kind: SyntaxKind.NonNullExpression; expression: Expression; } interface MetaProperty extends PrimaryExpression { kind: SyntaxKind.MetaProperty; keywordToken: SyntaxKind.NewKeyword; name: Identifier; } interface JsxElement extends PrimaryExpression { kind: SyntaxKind.JsxElement; openingElement: JsxOpeningElement; children: NodeArray; closingElement: JsxClosingElement; } type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement; type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute; type JsxTagNameExpression = PrimaryExpression | PropertyAccessExpression; interface JsxAttributes extends ObjectLiteralExpressionBase { parent?: JsxOpeningLikeElement; } interface JsxOpeningElement extends Expression { kind: SyntaxKind.JsxOpeningElement; parent?: JsxElement; tagName: JsxTagNameExpression; attributes: JsxAttributes; } interface JsxSelfClosingElement extends PrimaryExpression { kind: SyntaxKind.JsxSelfClosingElement; tagName: JsxTagNameExpression; attributes: JsxAttributes; } interface JsxAttribute extends ObjectLiteralElement { kind: SyntaxKind.JsxAttribute; parent?: JsxAttributes; name: Identifier; initializer?: StringLiteral | JsxExpression; } interface JsxSpreadAttribute extends ObjectLiteralElement { kind: SyntaxKind.JsxSpreadAttribute; parent?: JsxAttributes; expression: Expression; } interface JsxClosingElement extends Node { kind: SyntaxKind.JsxClosingElement; parent?: JsxElement; tagName: JsxTagNameExpression; } interface JsxExpression extends Expression { kind: SyntaxKind.JsxExpression; parent?: JsxElement | JsxAttributeLike; dotDotDotToken?: Token; expression?: Expression; } interface JsxText extends Node { kind: SyntaxKind.JsxText; containsOnlyWhiteSpaces: boolean; parent?: JsxElement; } type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement; interface Statement extends Node { _statementBrand: any; } interface NotEmittedStatement extends Statement { kind: SyntaxKind.NotEmittedStatement; } /** * A list of comma-seperated expressions. This node is only created by transformations. */ interface CommaListExpression extends Expression { kind: SyntaxKind.CommaListExpression; elements: NodeArray; } interface EmptyStatement extends Statement { kind: SyntaxKind.EmptyStatement; } interface DebuggerStatement extends Statement { kind: SyntaxKind.DebuggerStatement; } interface MissingDeclaration extends DeclarationStatement, ClassElement, ObjectLiteralElement, TypeElement { kind: SyntaxKind.MissingDeclaration; name?: Identifier; } type BlockLike = SourceFile | Block | ModuleBlock | CaseOrDefaultClause; interface Block extends Statement { kind: SyntaxKind.Block; statements: NodeArray; } interface VariableStatement extends Statement { kind: SyntaxKind.VariableStatement; declarationList: VariableDeclarationList; } interface ExpressionStatement extends Statement { kind: SyntaxKind.ExpressionStatement; expression: Expression; } interface IfStatement extends Statement { kind: SyntaxKind.IfStatement; expression: Expression; thenStatement: Statement; elseStatement?: Statement; } interface IterationStatement extends Statement { statement: Statement; } interface DoStatement extends IterationStatement { kind: SyntaxKind.DoStatement; expression: Expression; } interface WhileStatement extends IterationStatement { kind: SyntaxKind.WhileStatement; expression: Expression; } type ForInitializer = VariableDeclarationList | Expression; interface ForStatement extends IterationStatement { kind: SyntaxKind.ForStatement; initializer?: ForInitializer; condition?: Expression; incrementor?: Expression; } type ForInOrOfStatement = ForInStatement | ForOfStatement; interface ForInStatement extends IterationStatement { kind: SyntaxKind.ForInStatement; initializer: ForInitializer; expression: Expression; } interface ForOfStatement extends IterationStatement { kind: SyntaxKind.ForOfStatement; awaitModifier?: AwaitKeywordToken; initializer: ForInitializer; expression: Expression; } interface BreakStatement extends Statement { kind: SyntaxKind.BreakStatement; label?: Identifier; } interface ContinueStatement extends Statement { kind: SyntaxKind.ContinueStatement; label?: Identifier; } type BreakOrContinueStatement = BreakStatement | ContinueStatement; interface ReturnStatement extends Statement { kind: SyntaxKind.ReturnStatement; expression?: Expression; } interface WithStatement extends Statement { kind: SyntaxKind.WithStatement; expression: Expression; statement: Statement; } interface SwitchStatement extends Statement { kind: SyntaxKind.SwitchStatement; expression: Expression; caseBlock: CaseBlock; possiblyExhaustive?: boolean; } interface CaseBlock extends Node { kind: SyntaxKind.CaseBlock; parent?: SwitchStatement; clauses: NodeArray; } interface CaseClause extends Node { kind: SyntaxKind.CaseClause; parent?: CaseBlock; expression: Expression; statements: NodeArray; } interface DefaultClause extends Node { kind: SyntaxKind.DefaultClause; parent?: CaseBlock; statements: NodeArray; } type CaseOrDefaultClause = CaseClause | DefaultClause; interface LabeledStatement extends Statement { kind: SyntaxKind.LabeledStatement; label: Identifier; statement: Statement; } interface ThrowStatement extends Statement { kind: SyntaxKind.ThrowStatement; expression: Expression; } interface TryStatement extends Statement { kind: SyntaxKind.TryStatement; tryBlock: Block; catchClause?: CatchClause; finallyBlock?: Block; } interface CatchClause extends Node { kind: SyntaxKind.CatchClause; parent?: TryStatement; variableDeclaration: VariableDeclaration; block: Block; } type DeclarationWithTypeParameters = SignatureDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | JSDocTemplateTag; interface ClassLikeDeclaration extends NamedDeclaration { name?: Identifier; typeParameters?: NodeArray; heritageClauses?: NodeArray; members: NodeArray; } interface ClassDeclaration extends ClassLikeDeclaration, DeclarationStatement { kind: SyntaxKind.ClassDeclaration; name?: Identifier; } interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression { kind: SyntaxKind.ClassExpression; } interface ClassElement extends NamedDeclaration { _classElementBrand: any; name?: PropertyName; } interface TypeElement extends NamedDeclaration { _typeElementBrand: any; name?: PropertyName; questionToken?: QuestionToken; } interface InterfaceDeclaration extends DeclarationStatement { kind: SyntaxKind.InterfaceDeclaration; name: Identifier; typeParameters?: NodeArray; heritageClauses?: NodeArray; members: NodeArray; } interface HeritageClause extends Node { kind: SyntaxKind.HeritageClause; parent?: InterfaceDeclaration | ClassDeclaration | ClassExpression; token: SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword; types: NodeArray; } interface TypeAliasDeclaration extends DeclarationStatement { kind: SyntaxKind.TypeAliasDeclaration; name: Identifier; typeParameters?: NodeArray; type: TypeNode; } interface EnumMember extends NamedDeclaration { kind: SyntaxKind.EnumMember; parent?: EnumDeclaration; name: PropertyName; initializer?: Expression; } interface EnumDeclaration extends DeclarationStatement { kind: SyntaxKind.EnumDeclaration; name: Identifier; members: NodeArray; } type ModuleName = Identifier | StringLiteral; type ModuleBody = NamespaceBody | JSDocNamespaceBody; interface ModuleDeclaration extends DeclarationStatement { kind: SyntaxKind.ModuleDeclaration; parent?: ModuleBody | SourceFile; name: ModuleName; body?: ModuleBody | JSDocNamespaceDeclaration; } type NamespaceBody = ModuleBlock | NamespaceDeclaration; interface NamespaceDeclaration extends ModuleDeclaration { name: Identifier; body: NamespaceBody; } type JSDocNamespaceBody = Identifier | JSDocNamespaceDeclaration; interface JSDocNamespaceDeclaration extends ModuleDeclaration { name: Identifier; body: JSDocNamespaceBody; } interface ModuleBlock extends Node, Statement { kind: SyntaxKind.ModuleBlock; parent?: ModuleDeclaration; statements: NodeArray; } type ModuleReference = EntityName | ExternalModuleReference; /** * One of: * - import x = require("mod"); * - import x = M.x; */ interface ImportEqualsDeclaration extends DeclarationStatement { kind: SyntaxKind.ImportEqualsDeclaration; parent?: SourceFile | ModuleBlock; name: Identifier; moduleReference: ModuleReference; } interface ExternalModuleReference extends Node { kind: SyntaxKind.ExternalModuleReference; parent?: ImportEqualsDeclaration; expression?: Expression; } interface ImportDeclaration extends Statement { kind: SyntaxKind.ImportDeclaration; parent?: SourceFile | ModuleBlock; importClause?: ImportClause; /** If this is not a StringLiteral it will be a grammar error. */ moduleSpecifier: Expression; } type NamedImportBindings = NamespaceImport | NamedImports; interface ImportClause extends NamedDeclaration { kind: SyntaxKind.ImportClause; parent?: ImportDeclaration; name?: Identifier; namedBindings?: NamedImportBindings; } interface NamespaceImport extends NamedDeclaration { kind: SyntaxKind.NamespaceImport; parent?: ImportClause; name: Identifier; } interface NamespaceExportDeclaration extends DeclarationStatement { kind: SyntaxKind.NamespaceExportDeclaration; name: Identifier; } interface ExportDeclaration extends DeclarationStatement { kind: SyntaxKind.ExportDeclaration; parent?: SourceFile | ModuleBlock; exportClause?: NamedExports; /** If this is not a StringLiteral it will be a grammar error. */ moduleSpecifier?: Expression; } interface NamedImports extends Node { kind: SyntaxKind.NamedImports; parent?: ImportClause; elements: NodeArray; } interface NamedExports extends Node { kind: SyntaxKind.NamedExports; parent?: ExportDeclaration; elements: NodeArray; } type NamedImportsOrExports = NamedImports | NamedExports; interface ImportSpecifier extends NamedDeclaration { kind: SyntaxKind.ImportSpecifier; parent?: NamedImports; propertyName?: Identifier; name: Identifier; } interface ExportSpecifier extends NamedDeclaration { kind: SyntaxKind.ExportSpecifier; parent?: NamedExports; propertyName?: Identifier; name: Identifier; } type ImportOrExportSpecifier = ImportSpecifier | ExportSpecifier; interface ExportAssignment extends DeclarationStatement { kind: SyntaxKind.ExportAssignment; parent?: SourceFile; isExportEquals?: boolean; expression: Expression; } interface FileReference extends TextRange { fileName: string; } interface CheckJsDirective extends TextRange { enabled: boolean; } type CommentKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia; interface CommentRange extends TextRange { hasTrailingNewLine?: boolean; kind: CommentKind; } interface SynthesizedComment extends CommentRange { text: string; pos: -1; end: -1; } interface JSDocTypeExpression extends Node { kind: SyntaxKind.JSDocTypeExpression; type: TypeNode; } interface JSDocType extends TypeNode { _jsDocTypeBrand: any; } interface JSDocAllType extends JSDocType { kind: SyntaxKind.JSDocAllType; } interface JSDocUnknownType extends JSDocType { kind: SyntaxKind.JSDocUnknownType; } interface JSDocNonNullableType extends JSDocType { kind: SyntaxKind.JSDocNonNullableType; type: TypeNode; } interface JSDocNullableType extends JSDocType { kind: SyntaxKind.JSDocNullableType; type: TypeNode; } interface JSDocOptionalType extends JSDocType { kind: SyntaxKind.JSDocOptionalType; type: TypeNode; } interface JSDocFunctionType extends JSDocType, SignatureDeclaration { kind: SyntaxKind.JSDocFunctionType; } interface JSDocVariadicType extends JSDocType { kind: SyntaxKind.JSDocVariadicType; type: TypeNode; } type JSDocTypeReferencingNode = JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType; interface JSDoc extends Node { kind: SyntaxKind.JSDocComment; tags: NodeArray | undefined; comment: string | undefined; } interface JSDocTag extends Node { parent: JSDoc; atToken: AtToken; tagName: Identifier; comment: string | undefined; } interface JSDocUnknownTag extends JSDocTag { kind: SyntaxKind.JSDocTag; } interface JSDocAugmentsTag extends JSDocTag { kind: SyntaxKind.JSDocAugmentsTag; typeExpression: JSDocTypeExpression; } interface JSDocClassTag extends JSDocTag { kind: SyntaxKind.JSDocClassTag; } interface JSDocTemplateTag extends JSDocTag { kind: SyntaxKind.JSDocTemplateTag; typeParameters: NodeArray; } interface JSDocReturnTag extends JSDocTag { kind: SyntaxKind.JSDocReturnTag; typeExpression: JSDocTypeExpression; } interface JSDocTypeTag extends JSDocTag { kind: SyntaxKind.JSDocTypeTag; typeExpression: JSDocTypeExpression; } interface JSDocTypedefTag extends JSDocTag, NamedDeclaration { parent: JSDoc; kind: SyntaxKind.JSDocTypedefTag; fullName?: JSDocNamespaceDeclaration | Identifier; name?: Identifier; typeExpression?: JSDocTypeExpression; jsDocTypeLiteral?: JSDocTypeLiteral; } interface JSDocPropertyTag extends JSDocTag, TypeElement { parent: JSDoc; kind: SyntaxKind.JSDocPropertyTag; name: Identifier; /** the parameter name, if provided *before* the type (TypeScript-style) */ preParameterName?: Identifier; /** the parameter name, if provided *after* the type (JSDoc-standard) */ postParameterName?: Identifier; typeExpression: JSDocTypeExpression; isBracketed: boolean; } interface JSDocTypeLiteral extends JSDocType { kind: SyntaxKind.JSDocTypeLiteral; jsDocPropertyTags?: NodeArray; jsDocTypeTag?: JSDocTypeTag; } interface JSDocParameterTag extends JSDocTag { kind: SyntaxKind.JSDocParameterTag; /** the parameter name, if provided *before* the type (TypeScript-style) */ preParameterName?: Identifier; typeExpression?: JSDocTypeExpression; /** the parameter name, if provided *after* the type (JSDoc-standard) */ postParameterName?: Identifier; /** the parameter name, regardless of the location it was provided */ name: Identifier; isBracketed: boolean; } const enum FlowFlags { Unreachable = 1, Start = 2, BranchLabel = 4, LoopLabel = 8, Assignment = 16, TrueCondition = 32, FalseCondition = 64, SwitchClause = 128, ArrayMutation = 256, Referenced = 512, Shared = 1024, PreFinally = 2048, AfterFinally = 4096, Label = 12, Condition = 96, } interface FlowLock { locked?: boolean; } interface AfterFinallyFlow extends FlowNode, FlowLock { antecedent: FlowNode; } interface PreFinallyFlow extends FlowNode { antecedent: FlowNode; lock: FlowLock; } interface FlowNode { flags: FlowFlags; id?: number; } interface FlowStart extends FlowNode { container?: FunctionExpression | ArrowFunction | MethodDeclaration; } interface FlowLabel extends FlowNode { antecedents: FlowNode[]; } interface FlowAssignment extends FlowNode { node: Expression | VariableDeclaration | BindingElement; antecedent: FlowNode; } interface FlowCondition extends FlowNode { expression: Expression; antecedent: FlowNode; } interface FlowSwitchClause extends FlowNode { switchStatement: SwitchStatement; clauseStart: number; clauseEnd: number; antecedent: FlowNode; } interface FlowArrayMutation extends FlowNode { node: CallExpression | BinaryExpression; antecedent: FlowNode; } type FlowType = Type | IncompleteType; interface IncompleteType { flags: TypeFlags; type: Type; } interface AmdDependency { path: string; name: string; } interface SourceFile extends Declaration { kind: SyntaxKind.SourceFile; statements: NodeArray; endOfFileToken: Token; fileName: string; text: string; 词典语句?: UnderscoreEscapedMap<全局词典语句>; amdDependencies: AmdDependency[]; moduleName: string; referencedFiles: FileReference[]; typeReferenceDirectives: FileReference[]; languageVariant: LanguageVariant; isDeclarationFile: boolean; /** * lib.d.ts should have a reference comment like * * /// * * If any other file has this comment, it signals not to include lib.d.ts * because this containing file is intended to act as a default library. */ hasNoDefaultLib: boolean; languageVersion: ScriptTarget; 文件种类?: 文件种类; } interface Bundle extends Node { kind: SyntaxKind.Bundle; sourceFiles: SourceFile[]; } interface JsonSourceFile extends SourceFile { jsonObject?: ObjectLiteralExpression; extendedSourceFiles?: string[]; } interface ScriptReferenceHost { getCompilerOptions(): CompilerOptions; getSourceFile(fileName: string): SourceFile; getSourceFileByPath(path: Path): SourceFile; getCurrentDirectory(): string; } interface ParseConfigHost { useCaseSensitiveFileNames: boolean; readDirectory(rootDir: string, extensions: ReadonlyArray, excludes: ReadonlyArray, includes: ReadonlyArray, depth: number): string[]; /** * Gets a value indicating whether the specified path exists and is a file. * @param path The path to test. */ fileExists(path: string): boolean; readFile(path: string): string | undefined; } interface WriteFileCallback { (fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void, sourceFiles?: SourceFile[]): void; } class OperationCanceledException { } interface CancellationToken { isCancellationRequested(): boolean; /** @throws OperationCanceledException if isCancellationRequested is true */ throwIfCancellationRequested(): void; } interface Program extends ScriptReferenceHost { /** * Get a list of root file names that were passed to a 'createProgram' */ getRootFileNames(): string[]; /** * Get a list of files in the program */ getSourceFiles(): SourceFile[]; /** * Emits the JavaScript and declaration files. If targetSourceFile is not specified, then * the JavaScript and declaration files will be produced for all the files in this program. * If targetSourceFile is specified, then only the JavaScript and declaration for that * specific file will be generated. * * If writeFile is not specified then the writeFile callback from the compiler host will be * used for writing the JavaScript and declaration files. Otherwise, the writeFile parameter * will be invoked when writing the JavaScript and declaration files. */ emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean, customTransformers?: CustomTransformers): EmitResult; getOptionsDiagnostics(cancellationToken?: CancellationToken): Diagnostic[]; getGlobalDiagnostics(cancellationToken?: CancellationToken): Diagnostic[]; getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[]; getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[]; getDeclarationDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[]; /** * Gets a type checker that can be used to semantically analyze source fils in the program. */ getTypeChecker(): TypeChecker; } interface CustomTransformers { /** Custom transformers to evaluate before built-in transformations. */ before?: TransformerFactory[]; /** Custom transformers to evaluate after built-in transformations. */ after?: TransformerFactory[]; } interface SourceMapSpan { /** Line number in the .js file. */ emittedLine: number; /** Column number in the .js file. */ emittedColumn: number; /** Line number in the .ts file. */ sourceLine: number; /** Column number in the .ts file. */ sourceColumn: number; /** Optional name (index into names array) associated with this span. */ nameIndex?: number; /** .ts file (index into sources array) associated with this span */ sourceIndex: number; } interface SourceMapData { sourceMapFilePath: string; jsSourceMappingURL: string; sourceMapFile: string; sourceMapSourceRoot: string; sourceMapSources: string[]; sourceMapSourcesContent?: string[]; inputSourceFileNames: string[]; sourceMapNames?: string[]; sourceMapMappings: string; sourceMapDecodedMappings: SourceMapSpan[]; } /** Return code used by getEmitOutput function to indicate status of the function */ enum ExitStatus { Success = 0, DiagnosticsPresent_OutputsSkipped = 1, DiagnosticsPresent_OutputsGenerated = 2, } interface EmitResult { emitSkipped: boolean; /** Contains declaration emit diagnostics */ diagnostics: Diagnostic[]; emittedFiles: string[]; } interface TypeChecker { /**取类型按符号位置 */ getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type; /**取声明类型从符号 */ getDeclaredTypeOfSymbol(symbol: Symbol): Type; /**取类型的属性集 */ getPropertiesOfType(type: Type): Symbol[]; /**取类型的属性 */ getPropertyOfType(type: Type, propertyName: string): Symbol | undefined; /**取类型的索引信息 */ getIndexInfoOfType(type: Type, kind: IndexKind): IndexInfo | undefined; /**取类型的签名 */ getSignaturesOfType(type: Type, kind: SignatureKind): Signature[]; /**取类型的索引类型 */ getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined; /**取基类型 */ getBaseTypes(type: InterfaceType): BaseType[]; /**取字面量类型的基类型 */ getBaseTypeOfLiteralType(type: Type): Type; /**取加宽类型 */ getWidenedType(type: Type): Type; /**取签名的返回类型 */ getReturnTypeOfSignature(signature: Signature): Type; /**取非可空类型 */ getNonNullableType(type: Type): Type; /** 请注意，导致节点不能被检查。 */ /**类型转为类型节点 */ typeToTypeNode(type: Type, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): TypeNode; /** 请注意，导致节点不能被检查。 */ /**签名转为签名声明 */ signatureToSignatureDeclaration(signature: Signature, kind: SyntaxKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): SignatureDeclaration; /** 请注意，导致节点不能被检查。 */ /**索引信息转为索引签名声明 */ indexInfoToIndexSignatureDeclaration(indexInfo: IndexInfo, kind: IndexKind, enclosingDeclaration?: Node, flags?: NodeBuilderFlags): IndexSignatureDeclaration; /**取范围内的符号 */ getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]; /**取符号按位置 */ getSymbolAtLocation(node: Node): Symbol | undefined; /**取参数属性声明的符号 */ getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): Symbol[]; /**取速记值赋值符号 */ getShorthandAssignmentValueSymbol(location: Node): Symbol | undefined; /**取出口说明符局部目标符号 */ getExportSpecifierLocalTargetSymbol(location: ExportSpecifier): Symbol | undefined; /**取解构分配财产的特征 */ getPropertySymbolOfDestructuringAssignment(location: Identifier): Symbol | undefined; /**取位置按位置 */ getTypeAtLocation(node: Node): Type; /**取类型从类型节点 */ getTypeFromTypeNode(node: TypeNode): Type; /**签名转为文字 */ signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string; /**类型转为文字 */ typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string; /**符号转为文字 */ symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string; /**取符号显示构建 */ getSymbolDisplayBuilder(): SymbolDisplayBuilder; /**取完全限定名 */ getFullyQualifiedName(symbol: Symbol): string; /**取类型的增强属性类型 */ getAugmentedPropertiesOfType(type: Type): Symbol[]; /**取根符号集 */ getRootSymbols(symbol: Symbol): Symbol[]; /**取语境类型 */ getContextualType(node: Expression): Type | undefined; /** * returns unknownSignature in the case of an error. Don't know when it returns undefined. * @param argumentCount Apparent number of arguments, passed in case of a possibly incomplete call. This should come from an ArgumentListInfo. See `signatureHelp.ts`. */ /**取解决的签名 */ getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined; /**取签名从声明 */ getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature | undefined; /**是重载的实现 */ isImplementationOfOverload(node: FunctionLike): boolean | undefined; /**是未定义符号 */ isUndefinedSymbol(symbol: Symbol): boolean; /**是增强参数符号 */ isArgumentsSymbol(symbol: Symbol): boolean; /**是未知符号 */ isUnknownSymbol(symbol: Symbol): boolean; /**取常量值 */ getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): string | number | undefined; /**是有效的属性访问 */ isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean; /** Follow all aliases to get the original symbol. */ /**取别名符号 */ getAliasedSymbol(symbol: Symbol): Symbol; /**取模块的出口 */ getExportsOfModule(moduleSymbol: Symbol): Symbol[]; /**取所有的属性类型从JSX开放像元素 */ getAllAttributesTypeFromJsxOpeningLikeElement(elementNode: JsxOpeningLikeElement): Type | undefined; /**取JSX内在标签名称 */ getJsxIntrinsicTagNames(): Symbol[]; /**是可选参数 */ isOptionalParameter(node: ParameterDeclaration): boolean; /**取AMB模块集 */ getAmbientModules(): Symbol[]; /**尝试取模块出口的成员 */ tryGetMemberInModuleExports(memberName: string, moduleSymbol: Symbol): Symbol | undefined; /**取明显类型 */ getApparentType(type: Type): Type; /**取不存在的属性建议 */ getSuggestionForNonexistentProperty(node: Identifier, containingType: Type): string | undefined; /**取不存在的符号建议 */ getSuggestionForNonexistentSymbol(location: Node, name: string, meaning: SymbolFlags): string | undefined; } enum NodeBuilderFlags { None = 0, NoTruncation = 1, WriteArrayAsGenericType = 2, WriteTypeArgumentsOfSignature = 32, UseFullyQualifiedType = 64, SuppressAnyReturnType = 256, WriteTypeParametersInQualifiedName = 512, AllowThisInObjectLiteral = 1024, AllowQualifedNameInPlaceOfIdentifier = 2048, AllowAnonymousIdentifier = 8192, AllowEmptyUnionOrIntersection = 16384, AllowEmptyTuple = 32768, IgnoreErrors = 60416, InObjectTypeLiteral = 1048576, InTypeAlias = 8388608, } interface SymbolDisplayBuilder { buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void; buildSignatureDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): void; buildIndexSignatureDisplay(info: IndexInfo, writer: SymbolWriter, kind: IndexKind, enclosingDeclaration?: Node, globalFlags?: TypeFormatFlags, symbolStack?: Symbol[]): void; buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildTypePredicateDisplay(predicate: TypePredicate, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildDisplayForParametersAndDelimiters(thisParameter: Symbol, parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void; } interface SymbolWriter { writeKeyword(text: string): void; writeOperator(text: string): void; writePunctuation(text: string): void; writeSpace(text: string): void; writeStringLiteral(text: string): void; writeParameter(text: string): void; writeProperty(text: string): void; writeSymbol(text: string, symbol: Symbol): void; writeLine(): void; increaseIndent(): void; decreaseIndent(): void; clear(): void; /** * 符号写入器遇到符号写入时调用。当前仅由声明发射器使用，以帮助确定它是否应该用前面看到的导入语句修补最终声明文件（但选择不发出）。 */ trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void; reportInaccessibleThisError(): void; reportPrivateInBaseOfClassExpression(propertyName: string): void; } const enum TypeFormatFlags { None = 0, WriteArrayAsGenericType = 1, UseTypeOfFunction = 4, NoTruncation = 8, WriteArrowStyleSignature = 16, WriteOwnNameForAnyLike = 32, WriteTypeArgumentsOfSignature = 64, InElementType = 128, UseFullyQualifiedType = 256, InFirstTypeArgument = 512, InTypeAlias = 1024, UseTypeAliasValue = 2048, SuppressAnyReturnType = 4096, AddUndefined = 8192, WriteClassExpressionAsTypeLiteral = 16384, } const enum SymbolFormatFlags { None = 0, WriteTypeParametersOrArguments = 1, UseOnlyExternalAliasing = 2, } const enum TypePredicateKind { This = 0, Identifier = 1, } interface TypePredicateBase { kind: TypePredicateKind; type: Type; } interface ThisTypePredicate extends TypePredicateBase { kind: TypePredicateKind.This; } interface IdentifierTypePredicate extends TypePredicateBase { kind: TypePredicateKind.Identifier; parameterName: string; parameterIndex: number; } type TypePredicate = IdentifierTypePredicate | ThisTypePredicate; const enum SymbolFlags { None = 0, FunctionScopedVariable = 1, BlockScopedVariable = 2, Property = 4, EnumMember = 8, Function = 16, Class = 32, Interface = 64, ConstEnum = 128, RegularEnum = 256, ValueModule = 512, NamespaceModule = 1024, TypeLiteral = 2048, ObjectLiteral = 4096, Method = 8192, Constructor = 16384, GetAccessor = 32768, SetAccessor = 65536, Signature = 131072, TypeParameter = 262144, TypeAlias = 524288, ExportValue = 1048576, Alias = 2097152, Prototype = 4194304, ExportStar = 8388608, Optional = 16777216, Transient = 33554432, Enum = 384, Variable = 3, Value = 107455, Type = 793064, Namespace = 1920, Module = 1536, Accessor = 98304, FunctionScopedVariableExcludes = 107454, BlockScopedVariableExcludes = 107455, ParameterExcludes = 107455, PropertyExcludes = 0, EnumMemberExcludes = 900095, FunctionExcludes = 106927, ClassExcludes = 899519, InterfaceExcludes = 792968, RegularEnumExcludes = 899327, ConstEnumExcludes = 899967, ValueModuleExcludes = 106639, NamespaceModuleExcludes = 0, MethodExcludes = 99263, GetAccessorExcludes = 41919, SetAccessorExcludes = 74687, TypeParameterExcludes = 530920, TypeAliasExcludes = 793064, AliasExcludes = 2097152, ModuleMember = 2623475, ExportHasLocal = 944, HasExports = 1952, HasMembers = 6240, BlockScoped = 418, PropertyOrAccessor = 98308, ClassMember = 106500, } interface Symbol { flags: SymbolFlags; name: __String; 别名?: 别名; 别名id?: number; declarations?: Declaration[]; valueDeclaration?: Declaration; members?: SymbolTable; exports?: SymbolTable; globalExports?: SymbolTable; } const enum InternalSymbolName { Call = "__call", Constructor = "__constructor", New = "__new", Index = "__index", ExportStar = "__export", Global = "__global", Missing = "__missing", Type = "__type", Object = "__object", JSXAttributes = "__jsxAttributes", Class = "__class", Function = "__function", Computed = "__computed", Resolving = "__resolving__", ExportEquals = "export=", Default = "default", } /** * This represents a string whose leading underscore have been escaped by adding extra leading underscores. * The shape of this brand is rather unique compared to others we've used. * Instead of just an intersection of a string and an object, it is that union-ed * with an intersection of void and an object. This makes it wholly incompatible * with a normal string (which is good, it cannot be misused on assignment or on usage), * while still being comparable with a normal string via === (also good) and castable from a string. */ type __String = (string & { __escapedIdentifier: void; }) | (void & { __escapedIdentifier: void; }) | InternalSymbolName; /** EscapedStringMap based on ES6 Map interface. */ interface UnderscoreEscapedMap { get(key: __String): T | undefined; has(key: __String): boolean; set(key: __String, value: T): this; delete(key: __String): boolean; clear(): void; forEach(action: (value: T, key: __String) => void): void; readonly size: number; keys(): Iterator<__String>; values(): Iterator; entries(): Iterator<[__String, T]>; } /** SymbolTable based on ES6 Map interface. */ type SymbolTable = UnderscoreEscapedMap; type 索引 = { 键: string; 值: string; }; type 别名索引 = { 键: __String | string; 值: 别名; }; type 索引表 = Map; const enum TypeFlags { Any = 1, String = 2, Number = 4, Boolean = 8, Enum = 16, StringLiteral = 32, NumberLiteral = 64, BooleanLiteral = 128, EnumLiteral = 256, ESSymbol = 512, Void = 1024, Undefined = 2048, Null = 4096, Never = 8192, TypeParameter = 16384, Object = 32768, Union = 65536, Intersection = 131072, Index = 262144, IndexedAccess = 524288, NonPrimitive = 16777216, Literal = 224, StringOrNumberLiteral = 96, PossiblyFalsy = 7406, StringLike = 262178, NumberLike = 84, BooleanLike = 136, EnumLike = 272, UnionOrIntersection = 196608, StructuredType = 229376, StructuredOrTypeVariable = 1032192, TypeVariable = 540672, Narrowable = 17810175, NotUnionOrUnit = 16810497, Cts类型转换 = 360738, } type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression; interface Type { flags: TypeFlags; symbol?: Symbol; 别名?: 别名; 别名id?: number; pattern?: DestructuringPattern; aliasSymbol?: Symbol; aliasTypeArguments?: Type[]; } interface LiteralType extends Type { /**值的文字 */ value: string | number; /**新版本的类型 */ freshType?: LiteralType; /**类型的常规版本 */ regularType?: LiteralType; } interface StringLiteralType extends LiteralType { value: string; } interface NumberLiteralType extends LiteralType { value: number; } interface EnumType extends Type { } const enum ObjectFlags { Class = 1, Interface = 2, Reference = 4, Tuple = 8, Anonymous = 16, Mapped = 32, Instantiated = 64, ObjectLiteral = 128, EvolvingArray = 256, ObjectLiteralPatternWithComputedProperties = 512, ClassOrInterface = 3, } interface 文本名称 { 名称: __String | string; 别名: __String | string; } interface ObjectType extends Type { objectFlags: ObjectFlags; } /** Class and interface types (ObjectFlags.Class and ObjectFlags.Interface). */ interface InterfaceType extends ObjectType { typeParameters: TypeParameter[]; outerTypeParameters: TypeParameter[]; localTypeParameters: TypeParameter[]; thisType: TypeParameter; } type BaseType = ObjectType | IntersectionType; interface InterfaceTypeWithDeclaredMembers extends InterfaceType { declaredProperties: Symbol[]; declaredCallSignatures: Signature[]; declaredConstructSignatures: Signature[]; declaredStringIndexInfo: IndexInfo; declaredNumberIndexInfo: IndexInfo; } /** * Type references (ObjectFlags.Reference). When a class or interface has type parameters or * a "this" type, references to the class or interface are made using type references. The * typeArguments property specifies the types to substitute for the type parameters of the * class or interface and optionally includes an extra element that specifies the type to * substitute for "this" in the resulting instantiation. When no extra argument is present, * the type reference itself is substituted for "this". The typeArguments property is undefined * if the class or interface has no type parameters and the reference isn't specifying an * explicit "this" argument. */ interface TypeReference extends ObjectType { target: GenericType; typeArguments?: Type[]; } interface GenericType extends InterfaceType, TypeReference { } interface UnionOrIntersectionType extends Type { types: Type[]; } interface UnionType extends UnionOrIntersectionType { } interface IntersectionType extends UnionOrIntersectionType { } type StructuredType = ObjectType | UnionType | IntersectionType; /**不断变化的阵列式 */ interface EvolvingArrayType extends ObjectType { elementType: Type; finalArrayType?: Type; } interface TypeVariable extends Type { } interface TypeParameter extends TypeVariable { constraint: Type; default?: Type; } interface IndexedAccessType extends TypeVariable { objectType: Type; indexType: Type; constraint?: Type; } interface IndexType extends Type { type: TypeVariable | UnionOrIntersectionType; } const enum SignatureKind { Call = 0, Construct = 1, } interface Signature { declaration: SignatureDeclaration; typeParameters?: TypeParameter[]; parameters: Symbol[]; } const enum IndexKind { String = 0, Number = 1, } interface IndexInfo { type: Type; isReadonly: boolean; declaration?: SignatureDeclaration; } const enum InferencePriority { NakedTypeVariable = 1, MappedType = 2, ReturnType = 4, } interface InferenceInfo { typeParameter: TypeParameter; candidates: Type[]; inferredType: Type; priority: InferencePriority; topLevel: boolean; isFixed: boolean; } const enum InferenceFlags { /**独立候选人推断联合类型（否则未知类型） */ InferUnionTypes = 1, /**没有inferences（otherwise unknowntype推断出什么样的黄金emptyobjecttype） */ NoDefault = 2, AnyDefault = 4, } interface JsFileExtensionInfo { extension: string; isMixedContent: boolean; } interface DiagnosticMessage { key: string; category: DiagnosticCategory; code: number; message: string; } /** * A linked list of formatted diagnostic messages to be used as part of a multiline message. * It is built from the bottom up, leaving the head to be the "main" diagnostic. * While it seems that DiagnosticMessageChain is structurally similar to DiagnosticMessage, * the difference is that messages are all preformatted in DMC. */ interface DiagnosticMessageChain { messageText: string; category: DiagnosticCategory; code: number; next?: DiagnosticMessageChain; } interface Diagnostic { file: SourceFile | undefined; start: number | undefined; length: number | undefined; messageText: string | DiagnosticMessageChain; category: DiagnosticCategory; code: number; source?: string; } enum DiagnosticCategory { Warning = 0, Error = 1, Message = 2, } enum ModuleResolutionKind { Classic = 1, NodeJs = 2, } interface PluginImport { name: string; } type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike | PluginImport[]; interface CompilerOptions { allowJs?: boolean; allowSyntheticDefaultImports?: boolean; allowUnreachableCode?: boolean; allowUnusedLabels?: boolean; alwaysStrict?: boolean; baseUrl?: string; charset?: string; checkJs?: boolean; declaration?: boolean; declarationDir?: string; disableSizeLimit?: boolean; downlevelIteration?: boolean; emitBOM?: boolean; emitDecoratorMetadata?: boolean; experimentalDecorators?: boolean; forceConsistentCasingInFileNames?: boolean; importHelpers?: boolean; inlineSourceMap?: boolean; inlineSources?: boolean; isolatedModules?: boolean; jsx?: JsxEmit; lib?: string[]; locale?: string; mapRoot?: string; maxNodeModuleJsDepth?: number; module?: ModuleKind; moduleResolution?: ModuleResolutionKind; newLine?: NewLineKind; noEmit?: boolean; noEmitHelpers?: boolean; noEmitOnError?: boolean; noErrorTruncation?: boolean; noFallthroughCasesInSwitch?: boolean; noImplicitAny?: boolean; noImplicitReturns?: boolean; noImplicitThis?: boolean; noStrictGenericChecks?: boolean; noUnusedLocals?: boolean; noUnusedParameters?: boolean; noImplicitUseStrict?: boolean; noLib?: boolean; noResolve?: boolean; out?: string; outDir?: string; outFile?: string; paths?: MapLike; preserveConstEnums?: boolean; project?: string; reactNamespace?: string; jsxFactory?: string; removeComments?: boolean; rootDir?: string; rootDirs?: string[]; skipLibCheck?: boolean; skipDefaultLibCheck?: boolean; sourceMap?: boolean; sourceRoot?: string; strict?: boolean; strictNullChecks?: boolean; suppressExcessPropertyErrors?: boolean; suppressImplicitAnyIndexErrors?: boolean; target?: ScriptTarget; traceResolution?: boolean; types?: string[]; /** Paths used to compute primary types search locations */ typeRoots?: string[]; 中文关键字?: boolean; 转译Ts?: boolean; 转译Cts?: boolean; 转译声明?: boolean; 输出无词典标识符?: boolean; 词典在文件尾?: boolean; 词典不重复输出?: boolean; [option: string]: CompilerOptionsValue | JsonSourceFile | undefined; } interface TypeAcquisition { enableAutoDiscovery?: boolean; enable?: boolean; include?: string[]; exclude?: string[]; [option: string]: string[] | boolean | undefined; } interface DiscoverTypingsInfo { fileNames: string[]; projectRootPath: string; safeListPath: string; packageNameToTypingLocation: Map; typeAcquisition: TypeAcquisition; compilerOptions: CompilerOptions; unresolvedImports: ReadonlyArray; } const enum 词典类别 { 汉英词典 = 1, 英汉词典 = 2, } const enum 使用场景 { 输出 = 1, 类型检查 = 2, } const enum 输出种类 { 输出源码 = 1, 输出中文 = 2, 输出英文 = 3, } const enum 文件种类 { 未知 = 0, DCTS = 1, DTS = 2, CTS = 3, TS = 4, CTSX = 5, TSX = 6, JS = 7, JSX = 8, 外部 = 9, JSON = 10, } enum ModuleKind { None = 0, CommonJS = 1, AMD = 2, UMD = 3, System = 4, ES2015 = 5, ESNext = 6, } const enum JsxEmit { None = 0, Preserve = 1, React = 2, ReactNative = 3, } const enum NewLineKind { CarriageReturnLineFeed = 0, LineFeed = 1, } interface LineAndCharacter { line: number; character: number; } const enum ScriptKind { Unknown = 0, JS = 1, JSX = 2, TS = 3, TSX = 4, CTS = 5, CTSX = 6, External = 7, JSON = 8, } const enum ScriptTarget { ES3 = 0, ES5 = 1, ES2015 = 2, ES2016 = 3, ES2017 = 4, ESNext = 5, Latest = 5, } const enum LanguageVariant { Standard = 0, JSX = 1, } /** Either a parsed command line or a parsed tsconfig.json */ interface ParsedCommandLine { options: CompilerOptions; typeAcquisition?: TypeAcquisition; fileNames: string[]; raw?: any; errors: Diagnostic[]; wildcardDirectories?: MapLike; compileOnSave?: boolean; } const enum WatchDirectoryFlags { None = 0, Recursive = 1, } interface ExpandResult { fileNames: string[]; wildcardDirectories: MapLike; } interface ModuleResolutionHost { fileExists(fileName: string): boolean; readFile(fileName: string): string | undefined; trace?(s: string): void; directoryExists?(directoryName: string): boolean; realpath?(path: string): string; getCurrentDirectory?(): string; getDirectories?(path: string): string[]; } /** * Represents the result of module resolution. * Module resolution will pick up tsx/jsx/js files even if '--jsx' and '--allowJs' are turned off. * The Program will then filter results based on these flags. * * Prefer to return a `ResolvedModuleFull` so that the file type does not have to be inferred. */ interface ResolvedModule { /** Path of the file the module was resolved to. */ resolvedFileName: string; /** * Denotes if 'resolvedFileName' is isExternalLibraryImport and thus should be a proper external module: * - be a .d.ts file * - use top level imports\exports * - don't use tripleslash references */ isExternalLibraryImport?: boolean; } /** * ResolvedModule with an explicitly provided `extension` property. * Prefer this over `ResolvedModule`. */ interface ResolvedModuleFull extends ResolvedModule { /** * Extension of resolvedFileName. This must match what's at the end of resolvedFileName. * This is optional for backwards-compatibility, but will be added if not provided. */ extension: Extension; } const enum Extension { Ts = ".ts", Tsx = ".tsx", CTs = ".cts", CTsx = ".ctsx", Dts = ".d.ts", DCts = ".d.cts", Js = ".js", Jsx = ".jsx", } interface ResolvedModuleWithFailedLookupLocations { resolvedModule: ResolvedModuleFull | undefined; } interface ResolvedTypeReferenceDirective { primary: boolean; resolvedFileName?: string; } interface ResolvedTypeReferenceDirectiveWithFailedLookupLocations { resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective; failedLookupLocations: string[]; } interface CompilerHost extends ModuleResolutionHost { getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; getSourceFileByPath?(fileName: string, path: Path, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile; getCancellationToken?(): CancellationToken; getDefaultLibFileName(options: CompilerOptions): string; getDefaultLibLocation?(): string; writeFile: WriteFileCallback; getCurrentDirectory(): string; getDirectories(path: string): string[]; getCanonicalFileName(fileName: string): string; useCaseSensitiveFileNames(): boolean; getNewLine(): string; resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[]; /** * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files */ resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[]; getEnvironmentVariable?(name: string): string; } interface SourceMapRange extends TextRange { source?: SourceMapSource; } interface SourceMapSource { fileName: string; text: string; skipTrivia?: (pos: number) => number; } const enum EmitFlags { SingleLine = 1, AdviseOnEmitNode = 2, NoSubstitution = 4, CapturesThis = 8, NoLeadingSourceMap = 16, NoTrailingSourceMap = 32, NoSourceMap = 48, NoNestedSourceMaps = 64, NoTokenLeadingSourceMaps = 128, NoTokenTrailingSourceMaps = 256, NoTokenSourceMaps = 384, NoLeadingComments = 512, NoTrailingComments = 1024, NoComments = 1536, NoNestedComments = 2048, HelperName = 4096, ExportName = 8192, LocalName = 16384, InternalName = 32768, Indented = 65536, NoIndentation = 131072, AsyncFunctionBody = 262144, ReuseTempVariableScope = 524288, CustomPrologue = 1048576, NoHoisting = 2097152, HasEndOfDeclarationMarker = 4194304, Iterator = 8388608, NoAsciiEscaping = 16777216, } interface EmitHelper { readonly name: string; readonly scoped: boolean; readonly text: string; readonly priority?: number; } const enum EmitHint { SourceFile = 0, Expression = 1, IdentifierName = 2, Unspecified = 3, } interface TransformationContext { /**取编译选项集 */ getCompilerOptions(): CompilerOptions; /**启动词汇环境. */ startLexicalEnvironment(): void; /**暂停词汇环境 */ suspendLexicalEnvironment(): void; /**复位词汇环境 */ resumeLexicalEnvironment(): void; /**结束词汇环境 */ endLexicalEnvironment(): Statement[]; /**提升函数声明包含的范围 */ hoistFunctionDeclaration(node: FunctionDeclaration): void; /**提升变量声明范围 */ hoistVariableDeclaration(node: Identifier): void; /**请求发射助手 */ requestEmitHelper(helper: EmitHelper): void; /**读发射助手 */ readEmitHelpers(): EmitHelper[] | undefined; /**启用替换 */ enableSubstitution(kind: SyntaxKind): void; /**是可以替换 */ isSubstitutionEnabled(node: Node): boolean; /** * Hook used by transformers to substitute expressions just before they * are emitted by the pretty printer. * 通过转换器代替表达式之前他们被漂亮的打印机发出的钩子。 * NOTE: Transformation hooks should only be modified during `Transformer` initialization, * before returning the `NodeTransformer` callback. * 注意: 转型挂钩只能修改转换器 `初始化期间`，回国前的` nodetransformer `回调。 */ onSubstituteNode: (hint: EmitHint, node: Node) => Node; /** * Enables before/after emit notifications in the pretty printer for the provided * SyntaxKind. * 使发出通知 */ enableEmitNotification(kind: SyntaxKind): void; /** * Determines whether before/after emit notifications should be raised in the pretty * printer when it emits a node. * 决定 前/后或通知是否应提出在漂亮的打印机时，它发射节点。 */ isEmitNotificationEnabled(node: Node): boolean; /** * Hook used to allow transformers to capture state before or after * the printer emits a node. * * NOTE: Transformation hooks should only be modified during `Transformer` initialization, * before returning the `NodeTransformer` callback. */ onEmitNode: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void; } interface TransformationResult { /** Gets the transformed source files. */ transformed: T[]; /** Gets diagnostics for the transformation. */ diagnostics?: Diagnostic[]; /** * Gets a substitute for a node, if one is available; otherwise, returns the original node. * * @param hint A hint as to the intended usage of the node. * @param node The node to substitute. */ substituteNode(hint: EmitHint, node: Node): Node; /** * Emits a node with possible notification. * * @param hint A hint as to the intended usage of the node. * @param node The node to emit. * @param emitCallback A callback used to emit the node. */ emitNodeWithNotification(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void; /** * Clean up EmitNode entries on any parse-tree nodes. */ dispose(): void; } /** * A function that is used to initialize and return a `Transformer` callback, which in turn * will be used to transform one or more nodes. */ type TransformerFactory = (context: TransformationContext) => Transformer; /** * A function that transforms a node. */ type Transformer = (node: T) => T; /** * A function that accepts and possibly transforms a node. */ type Visitor = (node: Node) => VisitResult; type VisitResult = T | T[] | undefined; interface Printer { /** * Print a node and its subtree as-is, without any emit transformations. * @param hint A value indicating the purpose of a node. This is primarily used to * distinguish between an `Identifier` used in an expression position, versus an * `Identifier` used as an `IdentifierName` as part of a declaration. For most nodes you * should just pass `Unspecified`. * @param node The node to print. The node and its subtree are printed as-is, without any * emit transformations. * @param sourceFile A source file that provides context for the node. The source text of * the file is used to emit the original source content for literals and identifiers, while * the identifiers of the source file are used when generating unique names to avoid * collisions. */ printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string; /** * Prints a source file as-is, without any emit transformations. */ printFile(sourceFile: SourceFile): string; /** * Prints a bundle of source files as-is, without any emit transformations. */ printBundle(bundle: Bundle): string; } interface PrintHandlers { /** * A hook used by the Printer when generating unique names to avoid collisions with * globally defined names that exist outside of the current source file. */ hasGlobalName?(name: string): boolean; /** * A hook used by the Printer to provide notifications prior to emitting a node. A * compatible implementation **must** invoke `emitCallback` with the provided `hint` and * `node` values. * @param hint A hint indicating the intended purpose of the node. * @param node The node to emit. * @param emitCallback A callback that, when invoked, will emit the node. * @example * ```ts * var printer = createPrinter(printerOptions, { * onEmitNode(hint, node, emitCallback) { * // set up or track state prior to emitting the node... * emitCallback(hint, node); * // restore state after emitting the node... * } * }); * ``` */ onEmitNode?(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void; /** * A hook used by the Printer to perform just-in-time substitution of a node. This is * primarily used by node transformations that need to substitute one node for another, * such as replacing `myExportedVar` with `exports.myExportedVar`. * @param hint A hint indicating the intended purpose of the node. * @param node The node to emit. * @example * ```ts * var printer = createPrinter(printerOptions, { * substituteNode(hint, node) { * // perform substitution if necessary... * return node; * } * }); * ``` */ substituteNode?(hint: EmitHint, node: Node): Node; } interface PrinterOptions { removeComments?: boolean; newLine?: NewLineKind; } interface TextSpan { start: number; length: number; } interface TextChangeRange { span: TextSpan; newLength: number; } interface SyntaxList extends Node { _children: Node[]; } } declare namespace ts { const versionMajorMinor = "2.5"; /** The version of the TypeScript compiler release */ const version: 文字; } declare function setTimeout(handler: (...args: any[]) => void, timeout: number): any; declare function clearTimeout(handle: any): void; declare namespace ts { enum FileWatcherEventKind { Created = 0, Changed = 1, Deleted = 2, } type FileWatcherCallback = (fileName: string, eventKind: FileWatcherEventKind) => void; type DirectoryWatcherCallback = (fileName: string) => void; interface WatchedFile { fileName: string; callback: FileWatcherCallback; mtime?: Date; } interface System { args: string[]; newLine: string; useCaseSensitiveFileNames: boolean; write(s: string): void; readFile(path: string, encoding?: string): string | undefined; getFileSize?(path: string): number; writeFile(path: string, data: string, writeByteOrderMark?: boolean): void; appendFile(path: string, data: string, writeByteOrderMark?: boolean): void; /** * @pollingInterval - this parameter is used in polling-based watchers and ignored in watchers that * use native OS file watching */ watchFile?(path: string, callback: FileWatcherCallback, pollingInterval?: number): FileWatcher; watchDirectory?(path: string, callback: DirectoryWatcherCallback, recursive?: boolean): FileWatcher; resolvePath(path: string): string; fileExists(path: string): boolean; directoryExists(path: string): boolean; createDirectory(path: string): void; getExecutingFilePath(): string; getCurrentDirectory(): string; getDirectories(path: string): string[]; readDirectory(path: string, extensions?: ReadonlyArray, exclude?: ReadonlyArray, include?: ReadonlyArray, depth?: number): string[]; getModifiedTime?(path: string): Date; /** * This should be cryptographically secure. * A good implementation is node.js' `crypto.createHash`. (https://nodejs.org/api/crypto.html#crypto_crypto_createhash_algorithm) */ createHash?(data: string): string; getMemoryUsage?(): number; exit(exitCode?: number): void; realpath?(path: string): string; setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any; clearTimeout?(timeoutId: any): void; 取系统临时文件目录(): string; } interface FileWatcher { close(): void; } interface DirectoryWatcher extends FileWatcher { directoryName: string; referenceCount: number; } function getNodeMajorVersion(): 数字; let sys: System; } declare namespace ts { function getEffectiveTypeRoots(options: CompilerOptions, host: { directoryExists?: (directoryName: string) => boolean; getCurrentDirectory?: () => string; }): string[] | undefined; /** * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown. * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups * is assumed to be the same as root directory of the project. */ function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string | undefined, options: CompilerOptions, host: ModuleResolutionHost): ResolvedTypeReferenceDirectiveWithFailedLookupLocations; /** * Given a set of options, returns the set of type directive names * that should be included for this program automatically. * This list could either come from the config file, * or from enumerating the types root + initial secondary types lookup location. * More type directives might appear in the program later as a result of loading actual source files; * this list is only the set of defaults that are implicitly included. */ function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[]; /** * Cached module resolutions per containing directory. * This assumes that any module id will have the same resolution for sibling files located in the same folder. */ interface ModuleResolutionCache extends NonRelativeModuleNameResolutionCache { getOrCreateCacheForDirectory(directoryName: string): Map; } /** * Stored map from non-relative module name to a table: directory -> result of module lookup in this directory * We support only non-relative module names because resolution of relative module names is usually more deterministic and thus less expensive. */ interface NonRelativeModuleNameResolutionCache { getOrCreateCacheForModuleName(nonRelativeModuleName: string): PerModuleNameCache; } interface PerModuleNameCache { get(directory: string): ResolvedModuleWithFailedLookupLocations; set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void; } function createModuleResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string): ModuleResolutionCache; function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache): ResolvedModuleWithFailedLookupLocations; function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache): ResolvedModuleWithFailedLookupLocations; function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: NonRelativeModuleNameResolutionCache): ResolvedModuleWithFailedLookupLocations; } declare namespace ts { function createPrinter(printerOptions?: PrinterOptions, handlers?: PrintHandlers): Printer; } declare namespace ts { function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName?: 文字): string; function resolveTripleslashReference(moduleName: string, containingFile: string): string; function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost; function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[]; interface FormatDiagnosticsHost { getCurrentDirectory(): string; getCanonicalFileName(fileName: string): string; getNewLine(): string; } function formatDiagnostics(diagnostics: Diagnostic[], host: FormatDiagnosticsHost): string; function formatDiagnosticsWithColorAndContext(diagnostics: Diagnostic[], host: FormatDiagnosticsHost): string; function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string; /** * Create a new 'Program' instance. A Program is an immutable collection of 'SourceFile's and a 'CompilerOptions' * that represent a compilation unit. * * Creating a program proceeds from a set of root files, expanding the set of inputs by following imports and * triple-slash-reference-path directives transitively. '@types' and triple-slash-reference-types are also pulled in. * * @param rootNames - A set of root files. * @param options - The compiler options which should be used. * @param host - The host interacts with the underlying file system. * @param oldProgram - Reuses an old program structure. * @returns A 'Program' object. */ function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program): Program; } declare namespace ts { /** * Visits a Node using the supplied visitor, possibly returning a new Node in its place. * * @param node The Node to visit. * @param visitor The callback used to visit the Node. * @param test A callback to execute to verify the Node is valid. * @param lift An optional callback to execute to lift a NodeArray into a valid Node. */ function visitNode(node: T, visitor: Visitor, test?: (node: Node) => boolean, lift?: (node: NodeArray) => T): T; /** * Visits a Node using the supplied visitor, possibly returning a new Node in its place. * * @param node The Node to visit. * @param visitor The callback used to visit the Node. * @param test A callback to execute to verify the Node is valid. * @param lift An optional callback to execute to lift a NodeArray into a valid Node. */ function visitNode(node: T | undefined, visitor: Visitor, test?: (node: Node) => boolean, lift?: (node: NodeArray) => T): T | undefined; /** * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place. * * @param nodes The NodeArray to visit. * @param visitor The callback used to visit a Node. * @param test A node test to execute for each node. * @param start An optional value indicating the starting offset at which to start visiting. * @param count An optional value indicating the maximum number of nodes to visit. */ function visitNodes(nodes: NodeArray, visitor: Visitor, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray; /** * Visits a NodeArray using the supplied visitor, possibly returning a new NodeArray in its place. * * @param nodes The NodeArray to visit. * @param visitor The callback used to visit a Node. * @param test A node test to execute for each node. * @param start An optional value indicating the starting offset at which to start visiting. * @param count An optional value indicating the maximum number of nodes to visit. */ function visitNodes(nodes: NodeArray | undefined, visitor: Visitor, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray | undefined; /** * Starts a new lexical environment and visits a statement list, ending the lexical environment * and merging hoisted declarations upon completion. */ function visitLexicalEnvironment(statements: NodeArray, visitor: Visitor, context: TransformationContext, start?: number, ensureUseStrict?: boolean): NodeArray; /** * Starts a new lexical environment and visits a parameter list, suspending the lexical * environment upon completion. */ function visitParameterList(nodes: NodeArray, visitor: Visitor, context: TransformationContext, nodesVisitor?: 类型为 visitNodes): NodeArray; /** * Resumes a suspended lexical environment and visits a function body, ending the lexical * environment and merging hoisted declarations upon completion. */ function visitFunctionBody(node: FunctionBody, visitor: Visitor, context: TransformationContext): FunctionBody; /** * Resumes a suspended lexical environment and visits a function body, ending the lexical * environment and merging hoisted declarations upon completion. */ function visitFunctionBody(node: FunctionBody | undefined, visitor: Visitor, context: TransformationContext): FunctionBody | undefined; /** * Resumes a suspended lexical environment and visits a concise body, ending the lexical * environment and merging hoisted declarations upon completion. */ function visitFunctionBody(node: ConciseBody, visitor: Visitor, context: TransformationContext): ConciseBody; /** * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place. * * @param node The Node whose children will be visited. * @param visitor The callback used to visit each child. * @param context A lexical environment context for the visitor. */ function visitEachChild(node: T, visitor: Visitor, context: TransformationContext): T; /** * Visits each child of a Node using the supplied visitor, possibly returning a new Node of the same kind in its place. * * @param node The Node whose children will be visited. * @param visitor The callback used to visit each child. * @param context A lexical environment context for the visitor. */ function visitEachChild(node: T | undefined, visitor: Visitor, context: TransformationContext, nodesVisitor?: typeof visitNodes, tokenVisitor?: Visitor): T | undefined; } declare namespace ts { /** * Make `elements` into a `NodeArray`. If `elements` is `undefined`, returns an empty `NodeArray`. */ function createNodeArray(elements?: T[], hasTrailingComma?: boolean): NodeArray; function createLiteral(value: string): StringLiteral; function createLiteral(value: number): NumericLiteral; function createLiteral(value: boolean): BooleanLiteral; /** Create a string literal whose source text is read from a source node during emit. */ function createLiteral(sourceNode: StringLiteral | NumericLiteral | Identifier): StringLiteral; function createLiteral(value: string | number | boolean): PrimaryExpression; function createNumericLiteral(value: string): NumericLiteral; function createIdentifier(text: string): Identifier; function updateIdentifier(node: Identifier, typeArguments: NodeArray | undefined): Identifier; /** Create a unique temporary variable. */ function createTempVariable(recordTempVariable: ((node: Identifier) => void) | undefined): Identifier; /** Create a unique temporary variable for use in a loop. */ function createLoopVariable(): Identifier; /** Create a unique name based on the supplied text. */ function createUniqueName(text: string): Identifier; /** Create a unique name generated for a node. */ function getGeneratedNameForNode(node: Node): Identifier; function createToken(token: TKind): Token; function createSuper(): SuperExpression; function createThis(): ThisExpression & Token; function createNull(): NullLiteral & Token; function createTrue(): BooleanLiteral & Token; function createFalse(): BooleanLiteral & Token; function createQualifiedName(left: EntityName, right: string | Identifier): QualifiedName; function updateQualifiedName(node: QualifiedName, left: EntityName, right: Identifier): QualifiedName; function createComputedPropertyName(expression: Expression): ComputedPropertyName; function updateComputedPropertyName(node: ComputedPropertyName, expression: Expression): ComputedPropertyName; function createTypeParameterDeclaration(name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration; function updateTypeParameterDeclaration(node: TypeParameterDeclaration, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration; function createParameter(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken?: QuestionToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration; function updateParameter(node: ParameterDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): ParameterDeclaration; function createDecorator(expression: Expression): Decorator; function updateDecorator(node: Decorator, expression: Expression): Decorator; function createPropertySignature(modifiers: Modifier[] | undefined, name: PropertyName | string, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertySignature; function updatePropertySignature(node: PropertySignature, modifiers: Modifier[] | undefined, name: PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertySignature; function createProperty(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration; function updateProperty(node: PropertyDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, type: TypeNode | undefined, initializer: Expression | undefined): PropertyDeclaration; function createMethodSignature(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined): MethodSignature; function updateMethodSignature(node: MethodSignature, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined, name: PropertyName, questionToken: QuestionToken | undefined): MethodSignature; function createMethod(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration; function updateMethod(node: MethodDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: PropertyName, questionToken: QuestionToken | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): MethodDeclaration; function createConstructor(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, parameters: ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration; function updateConstructor(node: ConstructorDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, parameters: ParameterDeclaration[], body: Block | undefined): ConstructorDeclaration; function createGetAccessor(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: string | PropertyName, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration; function updateGetAccessor(node: GetAccessorDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: PropertyName, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): GetAccessorDeclaration; function createSetAccessor(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: string | PropertyName, parameters: ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration; function updateSetAccessor(node: SetAccessorDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: PropertyName, parameters: ParameterDeclaration[], body: Block | undefined): SetAccessorDeclaration; function createCallSignature(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined): CallSignatureDeclaration; function updateCallSignature(node: CallSignatureDeclaration, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined): CallSignatureDeclaration; function createConstructSignature(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined): ConstructSignatureDeclaration; function updateConstructSignature(node: ConstructSignatureDeclaration, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined): ConstructSignatureDeclaration; function createIndexSignature(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, parameters: ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; function updateIndexSignature(node: IndexSignatureDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, parameters: ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; function createKeywordTypeNode(kind: KeywordTypeNode["kind"]): KeywordTypeNode; function createTypePredicateNode(parameterName: Identifier | ThisTypeNode | string, type: TypeNode): TypePredicateNode; function updateTypePredicateNode(node: TypePredicateNode, parameterName: Identifier | ThisTypeNode, type: TypeNode): TypePredicateNode; function createTypeReferenceNode(typeName: string | EntityName, typeArguments: TypeNode[] | undefined): TypeReferenceNode; function updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray | undefined): TypeReferenceNode; function createFunctionTypeNode(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined): FunctionTypeNode; function updateFunctionTypeNode(node: FunctionTypeNode, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined): FunctionTypeNode; function createConstructorTypeNode(typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined): ConstructorTypeNode; function updateConstructorTypeNode(node: ConstructorTypeNode, typeParameters: NodeArray | undefined, parameters: NodeArray, type: TypeNode | undefined): ConstructorTypeNode; function createTypeQueryNode(exprName: EntityName): TypeQueryNode; function updateTypeQueryNode(node: TypeQueryNode, exprName: EntityName): TypeQueryNode; function createTypeLiteralNode(members: TypeElement[]): TypeLiteralNode; function updateTypeLiteralNode(node: TypeLiteralNode, members: NodeArray): TypeLiteralNode; function createArrayTypeNode(elementType: TypeNode): ArrayTypeNode; function updateArrayTypeNode(node: ArrayTypeNode, elementType: TypeNode): ArrayTypeNode; function createTupleTypeNode(elementTypes: TypeNode[]): TupleTypeNode; function updateTypleTypeNode(node: TupleTypeNode, elementTypes: TypeNode[]): TupleTypeNode; function createUnionTypeNode(types: TypeNode[]): UnionTypeNode; function updateUnionTypeNode(node: UnionTypeNode, types: NodeArray): UnionTypeNode; function createIntersectionTypeNode(types: TypeNode[]): IntersectionTypeNode; function updateIntersectionTypeNode(node: IntersectionTypeNode, types: NodeArray): IntersectionTypeNode; function createUnionOrIntersectionTypeNode(kind: SyntaxKind.UnionType | SyntaxKind.IntersectionType, types: TypeNode[]): UnionOrIntersectionTypeNode; function createParenthesizedType(type: TypeNode): ParenthesizedTypeNode; function updateParenthesizedType(node: ParenthesizedTypeNode, type: TypeNode): ParenthesizedTypeNode; function createThisTypeNode(): ThisTypeNode; function createTypeOperatorNode(type: TypeNode): TypeOperatorNode; function updateTypeOperatorNode(node: TypeOperatorNode, type: TypeNode): TypeOperatorNode; function createIndexedAccessTypeNode(objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode; function updateIndexedAccessTypeNode(node: IndexedAccessTypeNode, objectType: TypeNode, indexType: TypeNode): IndexedAccessTypeNode; function createMappedTypeNode(readonlyToken: ReadonlyToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | undefined, type: TypeNode | undefined): MappedTypeNode; function updateMappedTypeNode(node: MappedTypeNode, readonlyToken: ReadonlyToken | undefined, typeParameter: TypeParameterDeclaration, questionToken: QuestionToken | undefined, type: TypeNode | undefined): MappedTypeNode; function createLiteralTypeNode(literal: Expression): LiteralTypeNode; function updateLiteralTypeNode(node: LiteralTypeNode, literal: Expression): LiteralTypeNode; function createObjectBindingPattern(elements: BindingElement[]): ObjectBindingPattern; function updateObjectBindingPattern(node: ObjectBindingPattern, elements: BindingElement[]): ObjectBindingPattern; function createArrayBindingPattern(elements: ArrayBindingElement[]): ArrayBindingPattern; function updateArrayBindingPattern(node: ArrayBindingPattern, elements: ArrayBindingElement[]): ArrayBindingPattern; function createBindingElement(dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression): BindingElement; function updateBindingElement(node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined): BindingElement; function createArrayLiteral(elements?: Expression[], multiLine?: boolean): ArrayLiteralExpression; function updateArrayLiteral(node: ArrayLiteralExpression, elements: Expression[]): ArrayLiteralExpression; function createObjectLiteral(properties?: ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression; function updateObjectLiteral(node: ObjectLiteralExpression, properties: ObjectLiteralElementLike[]): ObjectLiteralExpression; function createPropertyAccess(expression: Expression, name: string | Identifier): PropertyAccessExpression; function updatePropertyAccess(node: PropertyAccessExpression, expression: Expression, name: Identifier): PropertyAccessExpression; function createElementAccess(expression: Expression, index: number | Expression): ElementAccessExpression; function updateElementAccess(node: ElementAccessExpression, expression: Expression, argumentExpression: Expression): ElementAccessExpression; function createCall(expression: Expression, typeArguments: TypeNode[] | undefined, argumentsArray: Expression[]): CallExpression; function updateCall(node: CallExpression, expression: Expression, typeArguments: TypeNode[] | undefined, argumentsArray: Expression[]): CallExpression; function createNew(expression: Expression, typeArguments: TypeNode[] | undefined, argumentsArray: Expression[] | undefined): NewExpression; function updateNew(node: NewExpression, expression: Expression, typeArguments: TypeNode[] | undefined, argumentsArray: Expression[] | undefined): NewExpression; function createTaggedTemplate(tag: Expression, template: TemplateLiteral): TaggedTemplateExpression; function updateTaggedTemplate(node: TaggedTemplateExpression, tag: Expression, template: TemplateLiteral): TaggedTemplateExpression; function createTypeAssertion(type: TypeNode, expression: Expression): TypeAssertion; function updateTypeAssertion(node: TypeAssertion, type: TypeNode, expression: Expression): TypeAssertion; function createParen(expression: Expression): ParenthesizedExpression; function updateParen(node: ParenthesizedExpression, expression: Expression): ParenthesizedExpression; function createFunctionExpression(modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block): FunctionExpression; function updateFunctionExpression(node: FunctionExpression, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block): FunctionExpression; function createArrowFunction(modifiers: Modifier[] | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, equalsGreaterThanToken: EqualsGreaterThanToken | undefined, body: ConciseBody): ArrowFunction; function updateArrowFunction(node: ArrowFunction, modifiers: Modifier[] | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: ConciseBody): ArrowFunction; function createDelete(expression: Expression): DeleteExpression; function updateDelete(node: DeleteExpression, expression: Expression): DeleteExpression; function createTypeOf(expression: Expression): TypeOfExpression; function updateTypeOf(node: TypeOfExpression, expression: Expression): TypeOfExpression; function createVoid(expression: Expression): VoidExpression; function updateVoid(node: VoidExpression, expression: Expression): VoidExpression; function createAwait(expression: Expression): AwaitExpression; function updateAwait(node: AwaitExpression, expression: Expression): AwaitExpression; function createPrefix(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression; function updatePrefix(node: PrefixUnaryExpression, operand: Expression): PrefixUnaryExpression; function createPostfix(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression; function updatePostfix(node: PostfixUnaryExpression, operand: Expression): PostfixUnaryExpression; function createBinary(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; function updateBinary(node: BinaryExpression, left: Expression, right: Expression, operator?: BinaryOperator | BinaryOperatorToken): BinaryExpression; function createConditional(condition: Expression, whenTrue: Expression, whenFalse: Expression): ConditionalExpression; function createConditional(condition: Expression, questionToken: QuestionToken, whenTrue: Expression, colonToken: ColonToken, whenFalse: Expression): ConditionalExpression; function updateConditional(node: ConditionalExpression, condition: Expression, whenTrue: Expression, whenFalse: Expression): ConditionalExpression; function createTemplateExpression(head: TemplateHead, templateSpans: TemplateSpan[]): TemplateExpression; function updateTemplateExpression(node: TemplateExpression, head: TemplateHead, templateSpans: TemplateSpan[]): TemplateExpression; function createYield(expression?: Expression): YieldExpression; function createYield(asteriskToken: AsteriskToken, expression: Expression): YieldExpression; function updateYield(node: YieldExpression, asteriskToken: AsteriskToken | undefined, expression: Expression): YieldExpression; function createSpread(expression: Expression): SpreadElement; function updateSpread(node: SpreadElement, expression: Expression): SpreadElement; function createClassExpression(modifiers: Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: TypeParameterDeclaration[] | undefined, heritageClauses: HeritageClause[], members: ClassElement[]): ClassExpression; function updateClassExpression(node: ClassExpression, modifiers: Modifier[] | undefined, name: Identifier | undefined, typeParameters: TypeParameterDeclaration[] | undefined, heritageClauses: HeritageClause[], members: ClassElement[]): ClassExpression; function createOmittedExpression(): OmittedExpression; function createExpressionWithTypeArguments(typeArguments: TypeNode[], expression: Expression): ExpressionWithTypeArguments; function updateExpressionWithTypeArguments(node: ExpressionWithTypeArguments, typeArguments: TypeNode[], expression: Expression): ExpressionWithTypeArguments; function createAsExpression(expression: Expression, type: TypeNode): AsExpression; function updateAsExpression(node: AsExpression, expression: Expression, type: TypeNode): AsExpression; function createNonNullExpression(expression: Expression): NonNullExpression; function updateNonNullExpression(node: NonNullExpression, expression: Expression): NonNullExpression; function createMetaProperty(keywordToken: MetaProperty["keywordToken"], name: Identifier): MetaProperty; function updateMetaProperty(node: MetaProperty, name: Identifier): MetaProperty; function createTemplateSpan(expression: Expression, literal: TemplateMiddle | TemplateTail): TemplateSpan; function updateTemplateSpan(node: TemplateSpan, expression: Expression, literal: TemplateMiddle | TemplateTail): TemplateSpan; function createSemicolonClassElement(): SemicolonClassElement; function createBlock(statements: Statement[], multiLine?: boolean): Block; function updateBlock(node: Block, statements: Statement[]): Block; function createVariableStatement(modifiers: Modifier[] | undefined, declarationList: VariableDeclarationList | VariableDeclaration[]): VariableStatement; function updateVariableStatement(node: VariableStatement, modifiers: Modifier[] | undefined, declarationList: VariableDeclarationList): VariableStatement; function createEmptyStatement(): EmptyStatement; function createStatement(expression: Expression): ExpressionStatement; function updateStatement(node: ExpressionStatement, expression: Expression): ExpressionStatement; function createIf(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement; function updateIf(node: IfStatement, expression: Expression, thenStatement: Statement, elseStatement: Statement | undefined): IfStatement; function createDo(statement: Statement, expression: Expression): DoStatement; function updateDo(node: DoStatement, statement: Statement, expression: Expression): DoStatement; function createWhile(expression: Expression, statement: Statement): WhileStatement; function updateWhile(node: WhileStatement, expression: Expression, statement: Statement): WhileStatement; function createFor(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; function updateFor(node: ForStatement, initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; function createForIn(initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; function updateForIn(node: ForInStatement, initializer: ForInitializer, expression: Expression, statement: Statement): ForInStatement; function createForOf(awaitModifier: AwaitKeywordToken, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; function updateForOf(node: ForOfStatement, awaitModifier: AwaitKeywordToken, initializer: ForInitializer, expression: Expression, statement: Statement): ForOfStatement; function createContinue(label?: string | Identifier): ContinueStatement; function updateContinue(node: ContinueStatement, label: Identifier | undefined): ContinueStatement; function createBreak(label?: string | Identifier): BreakStatement; function updateBreak(node: BreakStatement, label: Identifier | undefined): BreakStatement; function createReturn(expression?: Expression): ReturnStatement; function updateReturn(node: ReturnStatement, expression: Expression | undefined): ReturnStatement; function createWith(expression: Expression, statement: Statement): WithStatement; function updateWith(node: WithStatement, expression: Expression, statement: Statement): WithStatement; function createSwitch(expression: Expression, caseBlock: CaseBlock): SwitchStatement; function updateSwitch(node: SwitchStatement, expression: Expression, caseBlock: CaseBlock): SwitchStatement; function createLabel(label: string | Identifier, statement: Statement): LabeledStatement; function updateLabel(node: LabeledStatement, label: Identifier, statement: Statement): LabeledStatement; function createThrow(expression: Expression): ThrowStatement; function updateThrow(node: ThrowStatement, expression: Expression): ThrowStatement; function createTry(tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; function updateTry(node: TryStatement, tryBlock: Block, catchClause: CatchClause | undefined, finallyBlock: Block | undefined): TryStatement; function createDebuggerStatement(): DebuggerStatement; function createVariableDeclaration(name: string | BindingName, type?: TypeNode, initializer?: Expression): VariableDeclaration; function updateVariableDeclaration(node: VariableDeclaration, name: BindingName, type: TypeNode | undefined, initializer: Expression | undefined): VariableDeclaration; function createVariableDeclarationList(declarations: VariableDeclaration[], flags?: NodeFlags): VariableDeclarationList; function updateVariableDeclarationList(node: VariableDeclarationList, declarations: VariableDeclaration[]): VariableDeclarationList; function createFunctionDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: string | Identifier | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration; function updateFunctionDeclaration(node: FunctionDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, asteriskToken: AsteriskToken | undefined, name: Identifier | undefined, typeParameters: TypeParameterDeclaration[] | undefined, parameters: ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration; function createClassDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: string | Identifier | undefined, typeParameters: TypeParameterDeclaration[] | undefined, heritageClauses: HeritageClause[], members: ClassElement[]): ClassDeclaration; function updateClassDeclaration(node: ClassDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: Identifier | undefined, typeParameters: TypeParameterDeclaration[] | undefined, heritageClauses: HeritageClause[], members: ClassElement[]): ClassDeclaration; function createInterfaceDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: string | Identifier, typeParameters: TypeParameterDeclaration[] | undefined, heritageClauses: HeritageClause[] | undefined, members: TypeElement[]): InterfaceDeclaration; function updateInterfaceDeclaration(node: InterfaceDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: Identifier, typeParameters: TypeParameterDeclaration[] | undefined, heritageClauses: HeritageClause[] | undefined, members: TypeElement[]): InterfaceDeclaration; function createTypeAliasDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: string | Identifier, typeParameters: TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; function updateTypeAliasDeclaration(node: TypeAliasDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: Identifier, typeParameters: TypeParameterDeclaration[] | undefined, type: TypeNode): TypeAliasDeclaration; function createEnumDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: string | Identifier, members: EnumMember[]): EnumDeclaration; function updateEnumDeclaration(node: EnumDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: Identifier, members: EnumMember[]): EnumDeclaration; function createModuleDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined, flags?: NodeFlags): ModuleDeclaration; function updateModuleDeclaration(node: ModuleDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: ModuleName, body: ModuleBody | undefined): ModuleDeclaration; function createModuleBlock(statements: Statement[]): ModuleBlock; function updateModuleBlock(node: ModuleBlock, statements: Statement[]): ModuleBlock; function createCaseBlock(clauses: CaseOrDefaultClause[]): CaseBlock; function updateCaseBlock(node: CaseBlock, clauses: CaseOrDefaultClause[]): CaseBlock; function createNamespaceExportDeclaration(name: string | Identifier): NamespaceExportDeclaration; function updateNamespaceExportDeclaration(node: NamespaceExportDeclaration, name: Identifier): NamespaceExportDeclaration; function createImportEqualsDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: string | Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; function updateImportEqualsDeclaration(node: ImportEqualsDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, name: Identifier, moduleReference: ModuleReference): ImportEqualsDeclaration; function createImportDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier?: Expression): ImportDeclaration; function updateImportDeclaration(node: ImportDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, importClause: ImportClause | undefined, moduleSpecifier: Expression | undefined): ImportDeclaration; function createImportClause(name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause; function updateImportClause(node: ImportClause, name: Identifier | undefined, namedBindings: NamedImportBindings | undefined): ImportClause; function createNamespaceImport(name: Identifier): NamespaceImport; function updateNamespaceImport(node: NamespaceImport, name: Identifier): NamespaceImport; function createNamedImports(elements: ImportSpecifier[]): NamedImports; function updateNamedImports(node: NamedImports, elements: ImportSpecifier[]): NamedImports; function createImportSpecifier(propertyName: Identifier | undefined, name: Identifier): ImportSpecifier; function updateImportSpecifier(node: ImportSpecifier, propertyName: Identifier | undefined, name: Identifier): ImportSpecifier; function createExportAssignment(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, isExportEquals: boolean, expression: Expression): ExportAssignment; function updateExportAssignment(node: ExportAssignment, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, expression: Expression): ExportAssignment; function createExportDeclaration(decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, exportClause: NamedExports | undefined, moduleSpecifier?: Expression): ExportDeclaration; function updateExportDeclaration(node: ExportDeclaration, decorators: Decorator[] | undefined, modifiers: Modifier[] | undefined, exportClause: NamedExports | undefined, moduleSpecifier: Expression | undefined): ExportDeclaration; function createNamedExports(elements: ExportSpecifier[]): NamedExports; function updateNamedExports(node: NamedExports, elements: ExportSpecifier[]): NamedExports; function createExportSpecifier(propertyName: string | Identifier | undefined, name: string | Identifier): ExportSpecifier; function updateExportSpecifier(node: ExportSpecifier, propertyName: Identifier | undefined, name: Identifier): ExportSpecifier; function createExternalModuleReference(expression: Expression): ExternalModuleReference; function updateExternalModuleReference(node: ExternalModuleReference, expression: Expression): ExternalModuleReference; function createJsxElement(openingElement: JsxOpeningElement, children: JsxChild[], closingElement: JsxClosingElement): JsxElement; function updateJsxElement(node: JsxElement, openingElement: JsxOpeningElement, children: JsxChild[], closingElement: JsxClosingElement): JsxElement; function createJsxSelfClosingElement(tagName: JsxTagNameExpression, attributes: JsxAttributes): JsxSelfClosingElement; function updateJsxSelfClosingElement(node: JsxSelfClosingElement, tagName: JsxTagNameExpression, attributes: JsxAttributes): JsxSelfClosingElement; function createJsxOpeningElement(tagName: JsxTagNameExpression, attributes: JsxAttributes): JsxOpeningElement; function updateJsxOpeningElement(node: JsxOpeningElement, tagName: JsxTagNameExpression, attributes: JsxAttributes): JsxOpeningElement; function createJsxClosingElement(tagName: JsxTagNameExpression): JsxClosingElement; function updateJsxClosingElement(node: JsxClosingElement, tagName: JsxTagNameExpression): JsxClosingElement; function createJsxAttribute(name: Identifier, initializer: StringLiteral | JsxExpression): JsxAttribute; function updateJsxAttribute(node: JsxAttribute, name: Identifier, initializer: StringLiteral | JsxExpression): JsxAttribute; function createJsxAttributes(properties: JsxAttributeLike[]): JsxAttributes; function updateJsxAttributes(node: JsxAttributes, properties: JsxAttributeLike[]): JsxAttributes; function createJsxSpreadAttribute(expression: Expression): JsxSpreadAttribute; function updateJsxSpreadAttribute(node: JsxSpreadAttribute, expression: Expression): JsxSpreadAttribute; function createJsxExpression(dotDotDotToken: DotDotDotToken | undefined, expression: Expression | undefined): JsxExpression; function updateJsxExpression(node: JsxExpression, expression: Expression | undefined): JsxExpression; function createCaseClause(expression: Expression, statements: Statement[]): CaseClause; function updateCaseClause(node: CaseClause, expression: Expression, statements: Statement[]): CaseClause; function createDefaultClause(statements: Statement[]): DefaultClause; function updateDefaultClause(node: DefaultClause, statements: Statement[]): DefaultClause; function createHeritageClause(token: HeritageClause["token"], types: ExpressionWithTypeArguments[]): HeritageClause; function updateHeritageClause(node: HeritageClause, types: ExpressionWithTypeArguments[]): HeritageClause; function createCatchClause(variableDeclaration: string | VariableDeclaration, block: Block): CatchClause; function updateCatchClause(node: CatchClause, variableDeclaration: VariableDeclaration, block: Block): CatchClause; function createPropertyAssignment(name: string | PropertyName, initializer: Expression): PropertyAssignment; function updatePropertyAssignment(node: PropertyAssignment, name: PropertyName, initializer: Expression): PropertyAssignment; function createShorthandPropertyAssignment(name: string | Identifier, objectAssignmentInitializer?: Expression): ShorthandPropertyAssignment; function updateShorthandPropertyAssignment(node: ShorthandPropertyAssignment, name: Identifier, objectAssignmentInitializer: Expression | undefined): ShorthandPropertyAssignment; function createSpreadAssignment(expression: Expression): SpreadAssignment; function updateSpreadAssignment(node: SpreadAssignment, expression: Expression): SpreadAssignment; function createEnumMember(name: string | PropertyName, initializer?: Expression): EnumMember; function updateEnumMember(node: EnumMember, name: PropertyName, initializer: Expression | undefined): EnumMember; function updateSourceFileNode(node: SourceFile, statements: Statement[]): SourceFile; /** * Creates a shallow, memberwise clone of a node for mutation. */ function getMutableClone(node: T): T; /** * Creates a synthetic statement to act as a placeholder for a not-emitted statement in * order to preserve comments. * * @param original The original statement. */ function createNotEmittedStatement(original: Node): NotEmittedStatement; /** * Creates a synthetic expression to act as a placeholder for a not-emitted expression in * order to preserve comments or sourcemap positions. * * @param expression The inner expression to emit. * @param original The original outer expression. * @param location The location for the expression. Defaults to the positions from "original" if provided. */ function createPartiallyEmittedExpression(expression: Expression, original?: Node): PartiallyEmittedExpression; function updatePartiallyEmittedExpression(node: PartiallyEmittedExpression, expression: Expression): PartiallyEmittedExpression; function createCommaList(elements: Expression[]): CommaListExpression; function updateCommaList(node: CommaListExpression, elements: Expression[]): CommaListExpression; function createBundle(sourceFiles: SourceFile[]): Bundle; function updateBundle(node: Bundle, sourceFiles: SourceFile[]): Bundle; function createImmediatelyInvokedFunctionExpression(statements: Statement[]): CallExpression; function createImmediatelyInvokedFunctionExpression(statements: Statement[], param: ParameterDeclaration, paramValue: Expression): CallExpression; function createComma(left: Expression, right: Expression): Expression; function createLessThan(left: Expression, right: Expression): Expression; function createAssignment(left: ObjectLiteralExpression | ArrayLiteralExpression, right: Expression): DestructuringAssignment; function createAssignment(left: Expression, right: Expression): BinaryExpression; function createStrictEquality(left: Expression, right: Expression): BinaryExpression; function createStrictInequality(left: Expression, right: Expression): BinaryExpression; function createAdd(left: Expression, right: Expression): BinaryExpression; function createSubtract(left: Expression, right: Expression): BinaryExpression; function createPostfixIncrement(operand: Expression): PostfixUnaryExpression; function createLogicalAnd(left: Expression, right: Expression): BinaryExpression; function createLogicalOr(left: Expression, right: Expression): BinaryExpression; function createLogicalNot(operand: Expression): PrefixUnaryExpression; function createVoidZero(): VoidExpression; function createExportDefault(expression: Expression): ExportAssignment; function createExternalModuleExport(exportName: Identifier): ExportDeclaration; /** * Clears any EmitNode entries from parse-tree nodes. * @param sourceFile A source file. */ function disposeEmitNodes(sourceFile: SourceFile): 无值; function setTextRange(range: T, location: TextRange | undefined): T; /** * Sets flags that control emit behavior of a node. */ function setEmitFlags(node: T, emitFlags: EmitFlags): T; /** * Gets a custom text range to use when emitting source maps. */ function getSourceMapRange(node: Node): SourceMapRange; /** * Sets a custom text range to use when emitting source maps. */ function setSourceMapRange(node: T, range: SourceMapRange | undefined): T; /** * Create an external source map source file reference */ function createSourceMapSource(fileName: string, text: string, skipTrivia?: (pos: number) => number): SourceMapSource; /** * Gets the TextRange to use for source maps for a token of a node. */ function getTokenSourceMapRange(node: Node, token: SyntaxKind): SourceMapRange | undefined; /** * Sets the TextRange to use for source maps for a token of a node. */ function setTokenSourceMapRange(node: T, token: SyntaxKind, range: SourceMapRange | undefined): T; /** * Gets a custom text range to use when emitting comments. */ function getCommentRange(node: Node): TextRange; /** * Sets a custom text range to use when emitting comments. */ function setCommentRange(node: T, range: TextRange): T; function getSyntheticLeadingComments(node: Node): SynthesizedComment[] | undefined; function setSyntheticLeadingComments(node: T, comments: SynthesizedComment[]): T; function addSyntheticLeadingComment(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean): T; function getSyntheticTrailingComments(node: Node): SynthesizedComment[] | undefined; function setSyntheticTrailingComments(node: T, comments: SynthesizedComment[]): T; function addSyntheticTrailingComment(node: T, kind: SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia, text: string, hasTrailingNewLine?: boolean): T; /** * Gets the constant value to emit for an expression. */ function getConstantValue(node: PropertyAccessExpression | ElementAccessExpression): 文字 | 数字; /** * Sets the constant value to emit for an expression. */ function setConstantValue(node: PropertyAccessExpression | ElementAccessExpression, value: string | number): PropertyAccessExpression | ElementAccessExpression; /** * Adds an EmitHelper to a node. */ function addEmitHelper(node: T, helper: EmitHelper): T; /** * Add EmitHelpers to a node. */ function addEmitHelpers(node: T, helpers: EmitHelper[] | undefined): T; /** * Removes an EmitHelper from a node. */ function removeEmitHelper(node: Node, helper: EmitHelper): boolean; /** * Gets the EmitHelpers of a node. */ function getEmitHelpers(node: Node): EmitHelper[] | undefined; /** * Moves matching emit helpers from a source node to a target node. */ function moveEmitHelpers(source: Node, target: Node, predicate: (helper: EmitHelper) => boolean): 无值; function setOriginalNode(node: T, original: Node | undefined): T; } declare namespace ts { const 内置英汉键值映射: Map; const 内置JSDoc标签名: Map<文字>; const 内置汉英词典键值映射: Map; const 编译选项别名对照表: Map<文字>; } declare namespace ts { const 内置键值映射: Map; function 创建内部键值表(键值表: Map): Map<文字>; function 合并映射表(目标: Map, 源: Map): Map<文字>; function 翻转键值(目标: Map): Map<文字>; function 创建空对象(): T; function 创建汉英词典(键: string, 值: string, 是内置词典?: boolean): 词典; function 创建英汉词典(键: string, 值: string, 是内置词典?: boolean): 词典; function 创建内置词典映射(): UnderscoreEscapedMap<词典>; function 创建内置关键词词典(): UnderscoreEscapedMap<词典>; function 对象是节点(对象: any): 对象 is Node; function 是字面量节点(node: Node): node is LiteralLikeNode; function 取词典类别(文件名: string): 别名旗帜; function 取局部字典评论范围(node: Node, text: string): CommentRange[]; function 取属性名称的名称节点(name: PropertyName): Node; function 取属性名称别名(name: PropertyName): 别名; function 取输出文本(源码文本: string, 节点: Node, 文件种类: 文件种类, 使用场景: 使用场景, 包含琐事?: 真假): string; function 输出节点编码英文(node: Node, 前部琐事?: string): 文字; function 输出节点编码中文(node: Node, 前部琐事?: string): 文字; function 交换词典键值(词典: 词典): 词典; function 取输出种类(种类: 文件种类, 场景: 使用场景): 输出种类; function 取文件种类(文件名: string): 文件种类.未知 | 文件种类.DCTS | 文件种类.DTS | 文件种类.CTS | 文件种类.TS | 文件种类.CTSX | 文件种类.TSX | 文件种类.JS | 文件种类.JSX; function 取别名旗帜(词典: 词典, 旗帜?: 别名旗帜): 数字; function 取别名名称(对象: Symbol | Node | Type): __String; function 取符号节点类型中文(符号或名称声明: Symbol | Identifier | StringLiteral): string; function 取符号节点类型英文(符号或名称声明: Symbol | Identifier | StringLiteral): string; function 对象名称是交叉相等的(左值: 文本名称, 右值: 文本名称): 真假; function 创建文本别名(名称参数: __String | string, 别名参数: 别名): { 名称: 文字 | (文字 & { __escapedIdentifier: 无值; }) | (无值 & { __escapedIdentifier: 无值; }); 别名: __String; }; function 翻转别名旗帜(旗帜: 别名旗帜): 数字; function 按名称取符号表符号(符号表: SymbolTable, 名称: __String): Symbol; const JSDoc标签正则表达式: RegExp; function 替换JSDoc标签(评论文本: string): 文字; function 处理模块引用路径(路径: string): 文字; function 处理头部三斜线指令(文本: string, 主机?: EmitHost): 文字; } declare namespace ts { function getDefaultLibFileName(options: CompilerOptions): string; function textSpanEnd(span: TextSpan): 数字; function textSpanIsEmpty(span: TextSpan): 真假; function textSpanContainsPosition(span: TextSpan, position: number): 真假; function textSpanContainsTextSpan(span: TextSpan, other: TextSpan): 真假; function textSpanOverlapsWith(span: TextSpan, other: TextSpan): 真假; function textSpanOverlap(span1: TextSpan, span2: TextSpan): TextSpan; function textSpanIntersectsWithTextSpan(span: TextSpan, other: TextSpan): 真假; function textSpanIntersectsWith(span: TextSpan, start: number, length: number): 真假; function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number): 真假; function textSpanIntersectsWithPosition(span: TextSpan, position: number): 真假; function textSpanIntersection(span1: TextSpan, span2: TextSpan): TextSpan; function createTextSpan(start: number, length: number): TextSpan; function createTextSpanFromBounds(start: number, end: number): TextSpan; function textChangeRangeNewSpan(range: TextChangeRange): TextSpan; function textChangeRangeIsUnchanged(range: TextChangeRange): 真假; function createTextChangeRange(span: TextSpan, newLength: number): TextChangeRange; let unchangedTextChangeRange: TextChangeRange; /** * Called to merge all the changes that occurred across several versions of a script snapshot * into a single change. i.e. if a user keeps making successive edits to a script we will * have a text change from V1 to V2, V2 to V3, ..., Vn. * * This function will then merge those changes into a single change range valid between V1 and * Vn. */ function collapseTextChangeRangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange; function getTypeParameterOwner(d: Declaration): Declaration; function isParameterPropertyDeclaration(node: Node): boolean; function getCombinedModifierFlags(node: Node): ModifierFlags; function getCombinedNodeFlags(node: Node): NodeFlags; /** * Checks to see if the locale is in the appropriate format, * and if it is, attempts to set the appropriate language. */ function validateLocaleAndSetLanguage(locale: string, sys: { getExecutingFilePath(): string; resolvePath(path: string): string; fileExists(fileName: string): boolean; readFile(fileName: string): string | undefined; }, errors?: Diagnostic[]): 无值; function getOriginalNode(node: Node): Node; function getOriginalNode(node: Node, nodeTest: (node: Node) => node is T): T; /** * Gets a value indicating whether a node originated in the parse tree. * * @param node The node to test. */ function isParseTreeNode(node: Node): boolean; /** * Gets the original parse tree node for a node. * * @param node The original node. * @returns The original parse tree node if found; otherwise, undefined. */ function getParseTreeNode(node: Node): Node; /** * Gets the original parse tree node for a node. * * @param node The original node. * @param nodeTest A callback used to ensure the correct type of parse tree node is returned. * @returns The original parse tree node if found; otherwise, undefined. */ function getParseTreeNode(node: Node, nodeTest?: (node: Node) => node is T): T; /** * Remove extra underscore from escaped identifier text content. * * @param identifier The escaped identifier text. * @returns The unescaped identifier text. */ function unescapeLeadingUnderscores(identifier: __String): string; /** * Remove extra underscore from escaped identifier text content. * @deprecated * @param identifier The escaped identifier text. * @returns The unescaped identifier text. */ function unescapeIdentifier(id: string): string; function getNameOfDeclaration(declaration: Declaration): DeclarationName | undefined; } declare namespace ts { function isNumericLiteral(node: Node): node is NumericLiteral; function isStringLiteral(node: Node): node is StringLiteral; function isJsxText(node: Node): node is JsxText; function isRegularExpressionLiteral(node: Node): node is RegularExpressionLiteral; function isNoSubstitutionTemplateLiteral(node: Node): node is LiteralExpression; function isTemplateHead(node: Node): node is TemplateHead; function isTemplateMiddle(node: Node): node is TemplateMiddle; function isTemplateTail(node: Node): node is TemplateTail; function isIdentifier(node: Node): node is Identifier; function isQualifiedName(node: Node): node is QualifiedName; function isComputedPropertyName(node: Node): node is ComputedPropertyName; function isTypeParameterDeclaration(node: Node): node is TypeParameterDeclaration; function isParameter(node: Node): node is ParameterDeclaration; function isDecorator(node: Node): node is Decorator; function isPropertySignature(node: Node): node is PropertySignature; function isPropertyDeclaration(node: Node): node is PropertyDeclaration; function isMethodSignature(node: Node): node is MethodSignature; function isMethodDeclaration(node: Node): node is MethodDeclaration; function isConstructorDeclaration(node: Node): node is ConstructorDeclaration; function isGetAccessorDeclaration(node: Node): node is GetAccessorDeclaration; function isSetAccessorDeclaration(node: Node): node is SetAccessorDeclaration; function isCallSignatureDeclaration(node: Node): node is CallSignatureDeclaration; function isConstructSignatureDeclaration(node: Node): node is ConstructSignatureDeclaration; function isIndexSignatureDeclaration(node: Node): node is IndexSignatureDeclaration; function isTypePredicateNode(node: Node): node is TypePredicateNode; function isTypeReferenceNode(node: Node): node is TypeReferenceNode; function isFunctionTypeNode(node: Node): node is FunctionTypeNode; function isConstructorTypeNode(node: Node): node is ConstructorTypeNode; function isTypeQueryNode(node: Node): node is TypeQueryNode; function isTypeLiteralNode(node: Node): node is TypeLiteralNode; function isArrayTypeNode(node: Node): node is ArrayTypeNode; function isTupleTypeNode(node: Node): node is TupleTypeNode; function isUnionTypeNode(node: Node): node is UnionTypeNode; function isIntersectionTypeNode(node: Node): node is IntersectionTypeNode; function isParenthesizedTypeNode(node: Node): node is ParenthesizedTypeNode; function isThisTypeNode(node: Node): node is ThisTypeNode; function isTypeOperatorNode(node: Node): node is TypeOperatorNode; function isIndexedAccessTypeNode(node: Node): node is IndexedAccessTypeNode; function isMappedTypeNode(node: Node): node is MappedTypeNode; function isLiteralTypeNode(node: Node): node is LiteralTypeNode; function isObjectBindingPattern(node: Node): node is ObjectBindingPattern; function isArrayBindingPattern(node: Node): node is ArrayBindingPattern; function isBindingElement(node: Node): node is BindingElement; function isArrayLiteralExpression(node: Node): node is ArrayLiteralExpression; function isObjectLiteralExpression(node: Node): node is ObjectLiteralExpression; function isPropertyAccessExpression(node: Node): node is PropertyAccessExpression; function isElementAccessExpression(node: Node): node is ElementAccessExpression; function isCallExpression(node: Node): node is CallExpression; function isNewExpression(node: Node): node is NewExpression; function isTaggedTemplateExpression(node: Node): node is TaggedTemplateExpression; function isTypeAssertion(node: Node): node is TypeAssertion; function isParenthesizedExpression(node: Node): node is ParenthesizedExpression; function 跳过括号表达式(node: Expression): Expression; function skipPartiallyEmittedExpressions(node: Expression): Expression; function skipPartiallyEmittedExpressions(node: Node): Node; function isFunctionExpression(node: Node): node is FunctionExpression; function isArrowFunction(node: Node): node is ArrowFunction; function isDeleteExpression(node: Node): node is DeleteExpression; function isTypeOfExpression(node: Node): node is TypeOfExpression; function isVoidExpression(node: Node): node is VoidExpression; function isAwaitExpression(node: Node): node is AwaitExpression; function isPrefixUnaryExpression(node: Node): node is PrefixUnaryExpression; function isPostfixUnaryExpression(node: Node): node is PostfixUnaryExpression; function isBinaryExpression(node: Node): node is BinaryExpression; function isConditionalExpression(node: Node): node is ConditionalExpression; function isTemplateExpression(node: Node): node is TemplateExpression; function isYieldExpression(node: Node): node is YieldExpression; function isSpreadElement(node: Node): node is SpreadElement; function isClassExpression(node: Node): node is ClassExpression; function isOmittedExpression(node: Node): node is OmittedExpression; function isExpressionWithTypeArguments(node: Node): node is ExpressionWithTypeArguments; function isAsExpression(node: Node): node is AsExpression; function isNonNullExpression(node: Node): node is NonNullExpression; function isMetaProperty(node: Node): node is MetaProperty; function isTemplateSpan(node: Node): node is TemplateSpan; function isSemicolonClassElement(node: Node): node is SemicolonClassElement; function isBlock(node: Node): node is Block; function isVariableStatement(node: Node): node is VariableStatement; function isEmptyStatement(node: Node): node is EmptyStatement; function isExpressionStatement(node: Node): node is ExpressionStatement; function isIfStatement(node: Node): node is IfStatement; function isDoStatement(node: Node): node is DoStatement; function isWhileStatement(node: Node): node is WhileStatement; function isForStatement(node: Node): node is ForStatement; function isForInStatement(node: Node): node is ForInStatement; function isForOfStatement(node: Node): node is ForOfStatement; function isContinueStatement(node: Node): node is ContinueStatement; function isBreakStatement(node: Node): node is BreakStatement; function isReturnStatement(node: Node): node is ReturnStatement; function isWithStatement(node: Node): node is WithStatement; function isSwitchStatement(node: Node): node is SwitchStatement; function isLabeledStatement(node: Node): node is LabeledStatement; function isThrowStatement(node: Node): node is ThrowStatement; function isTryStatement(node: Node): node is TryStatement; function isDebuggerStatement(node: Node): node is DebuggerStatement; function isVariableDeclaration(node: Node): node is VariableDeclaration; function isVariableDeclarationList(node: Node): node is VariableDeclarationList; function isFunctionDeclaration(node: Node): node is FunctionDeclaration; function isClassDeclaration(node: Node): node is ClassDeclaration; function isInterfaceDeclaration(node: Node): node is InterfaceDeclaration; function isTypeAliasDeclaration(node: Node): node is TypeAliasDeclaration; function isEnumDeclaration(node: Node): node is EnumDeclaration; function isModuleDeclaration(node: Node): node is ModuleDeclaration; function isModuleBlock(node: Node): node is ModuleBlock; function isCaseBlock(node: Node): node is CaseBlock; function isNamespaceExportDeclaration(node: Node): node is NamespaceExportDeclaration; function isImportEqualsDeclaration(node: Node): node is ImportEqualsDeclaration; function isImportDeclaration(node: Node): node is ImportDeclaration; function isImportClause(node: Node): node is ImportClause; function isNamespaceImport(node: Node): node is NamespaceImport; function isNamedImports(node: Node): node is NamedImports; function isImportSpecifier(node: Node): node is ImportSpecifier; function isExportAssignment(node: Node): node is ExportAssignment; function isExportDeclaration(node: Node): node is ExportDeclaration; function isNamedExports(node: Node): node is NamedExports; function isExportSpecifier(node: Node): node is ExportSpecifier; function isMissingDeclaration(node: Node): node is MissingDeclaration; function isExternalModuleReference(node: Node): node is ExternalModuleReference; function isJsxElement(node: Node): node is JsxElement; function isJsxSelfClosingElement(node: Node): node is JsxSelfClosingElement; function isJsxOpeningElement(node: Node): node is JsxOpeningElement; function isJsxClosingElement(node: Node): node is JsxClosingElement; function isJsxAttribute(node: Node): node is JsxAttribute; function isJsxAttributes(node: Node): node is JsxAttributes; function isJsxSpreadAttribute(node: Node): node is JsxSpreadAttribute; function isJsxExpression(node: Node): node is JsxExpression; function isCaseClause(node: Node): node is CaseClause; function isDefaultClause(node: Node): node is DefaultClause; function isHeritageClause(node: Node): node is HeritageClause; function isCatchClause(node: Node): node is CatchClause; function isPropertyAssignment(node: Node): node is PropertyAssignment; function isShorthandPropertyAssignment(node: Node): node is ShorthandPropertyAssignment; function isSpreadAssignment(node: Node): node is SpreadAssignment; function isEnumMember(node: Node): node is EnumMember; function isSourceFile(node: Node): node is SourceFile; function isBundle(node: Node): node is Bundle; function isJSDocTypeExpression(node: Node): node is JSDocTypeExpression; function isJSDocAllType(node: JSDocAllType): node is JSDocAllType; function isJSDocUnknownType(node: Node): node is JSDocUnknownType; function isJSDocNullableType(node: Node): node is JSDocNullableType; function isJSDocNonNullableType(node: Node): node is JSDocNonNullableType; function isJSDocOptionalType(node: Node): node is JSDocOptionalType; function isJSDocFunctionType(node: Node): node is JSDocFunctionType; function isJSDocVariadicType(node: Node): node is JSDocVariadicType; function isJSDoc(node: Node): node is JSDoc; function isJSDocAugmentsTag(node: Node): node is JSDocAugmentsTag; function isJSDocParameterTag(node: Node): node is JSDocParameterTag; function isJSDocReturnTag(node: Node): node is JSDocReturnTag; function isJSDocTypeTag(node: Node): node is JSDocTypeTag; function isJSDocTemplateTag(node: Node): node is JSDocTemplateTag; function isJSDocTypedefTag(node: Node): node is JSDocTypedefTag; function isJSDocPropertyTag(node: Node): node is JSDocPropertyTag; function isJSDocTypeLiteral(node: Node): node is JSDocTypeLiteral; } declare namespace ts { /** * True if node is of some token syntax kind. * For example, this is true for an IfKeyword but not for an IfStatement. */ function isToken(n: Node): boolean; function isLiteralExpression(node: Node): node is LiteralExpression; function isTemplateMiddleOrTemplateTail(node: Node): node is TemplateMiddle | TemplateTail; function isStringTextContainingNode(node: Node): 真假; function isModifier(node: Node): node is Modifier; function isEntityName(node: Node): node is EntityName; function isPropertyName(node: Node): node is PropertyName; function isBindingName(node: Node): node is BindingName; function isFunctionLike(node: Node): node is FunctionLike; function isClassElement(node: Node): node is ClassElement; function isClassLike(node: Node): node is ClassLikeDeclaration; function isAccessor(node: Node): node is AccessorDeclaration; function isTypeElement(node: Node): node is TypeElement; function isObjectLiteralElementLike(node: Node): node is ObjectLiteralElementLike; /** * Node test that determines whether a node is a valid type node. * This differs from the `isPartOfTypeNode` function which determines whether a node is *part* * of a TypeNode. */ function isTypeNode(node: Node): node is TypeNode; function isFunctionOrConstructorTypeNode(node: Node): node is FunctionTypeNode | ConstructorTypeNode; function isPropertyAccessOrQualifiedName(node: Node): node is PropertyAccessExpression | QualifiedName; function isCallLikeExpression(node: Node): node is CallLikeExpression; function isCallOrNewExpression(node: Node): node is CallExpression | NewExpression; function isTemplateLiteral(node: Node): node is TemplateLiteral; function isAssertionExpression(node: Node): node is AssertionExpression; function isIterationStatement(node: Node, lookInLabeledStatements: boolean): node is IterationStatement; function isJsxOpeningLikeElement(node: Node): node is JsxOpeningLikeElement; function isCaseOrDefaultClause(node: Node): node is CaseOrDefaultClause; /** True if node is of a kind that may contain comment text. */ function isJSDocCommentContainingNode(node: Node): boolean; } declare namespace ts { interface ErrorCallback { (message: DiagnosticMessage, length: number): void; } interface Scanner { getStartPos(): number; getToken(): SyntaxKind; getTextPos(): number; getTokenPos(): number; getTokenText(): string; getTokenValue(): string; hasExtendedUnicodeEscape(): boolean; hasPrecedingLineBreak(): boolean; isIdentifier(): boolean; isReservedWord(): boolean; isUnterminated(): boolean; reScanGreaterToken(): SyntaxKind; reScanSlashToken(): SyntaxKind; reScanTemplateToken(): SyntaxKind; scanJsxIdentifier(): SyntaxKind; scanJsxAttributeValue(): SyntaxKind; reScanJsxToken(): SyntaxKind; scanJsxToken(): SyntaxKind; scanJSDocToken(): SyntaxKind; scan(): SyntaxKind; 翻译词典扫描(): SyntaxKind; 扫描词典主体(): SyntaxKind; getText(): string; setText(text: string, start?: number, length?: number): void; setOnError(onError: ErrorCallback): void; setScriptTarget(scriptTarget: ScriptTarget): void; setLanguageVariant(variant: LanguageVariant): void; setTextPos(textPos: number): void; lookAhead(callback: () => T): T; scanRange(start: number, length: number, callback: () => T): T; tryScan(callback: () => T): T; } const 中文关键字头: Map<数字>; const 中文关键字映射表: Map; function tokenToString(t: SyntaxKind): string | undefined; function 令牌转为关键字(t: SyntaxKind): 文字; function 令牌转为中文关键字(t: SyntaxKind): 文字; function getPositionOfLineAndCharacter(sourceFile: SourceFile, line: number, character: number): number; function getLineAndCharacterOfPosition(sourceFile: SourceFileLike, position: number): LineAndCharacter; function isWhiteSpaceLike(ch: number): boolean; /** Does not include line breaks. For that, see isWhiteSpaceLike. */ function isWhiteSpaceSingleLine(ch: number): boolean; function isLineBreak(ch: number): boolean; function couldStartTrivia(text: string, pos: number): boolean; function forEachLeadingCommentRange(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T): U | undefined; function forEachTrailingCommentRange(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T) => U, state?: T): U | undefined; function reduceEachLeadingCommentRange(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U): U; function reduceEachTrailingCommentRange(text: string, pos: number, cb: (pos: number, end: number, kind: CommentKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U): U; function getLeadingCommentRanges(text: string, pos: number): CommentRange[] | undefined; function getTrailingCommentRanges(text: string, pos: number): CommentRange[] | undefined; /** Optionally, get the shebang */ function getShebang(text: string): string | undefined; function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean; function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean; function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, languageVariant?: LanguageVariant, text?: string, onError?: ErrorCallback, start?: number, length?: number): Scanner; } declare namespace ts { function createNode(kind: SyntaxKind, pos?: number, end?: number): Node; /** * Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes * stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise, * embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns * a truthy value, iteration stops and that value is returned. Otherwise, undefined is returned. * * @param node a given node to visit its children * @param cbNode a callback to be invoked for all child nodes * @param cbNodes a callback to be invoked for embedded array */ function forEachChild(node: Node, cbNode: (node: Node) => T | undefined, cbNodes?: (nodes: NodeArray) => T | undefined): T | undefined; function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes?: 真假, scriptKind?: ScriptKind): SourceFile; function parseIsolatedEntityName(text: string, languageVersion: ScriptTarget): EntityName; /** * Parse json text into SyntaxTree and return node and parse errors if any * @param fileName * @param sourceText */ function parseJsonText(fileName: string, sourceText: string): JsonSourceFile; function isExternalModule(file: SourceFile): boolean; function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile; } declare namespace ts { function parseCommandLine(commandLine: string[], readFile?: (path: string) => string): ParsedCommandLine; /** * Read tsconfig.json file * @param fileName The path to the config file */ function readConfigFile(fileName: string, readFile: (path: string) => string | undefined): { config?: any; error?: Diagnostic; }; /** * Parse the text of the tsconfig.json file * @param fileName The path to the config file * @param jsonText The text of the config file */ function parseConfigFileTextToJson(fileName: string, jsonText: string): { config?: any; error?: Diagnostic; }; /** * Read tsconfig.json file * @param fileName The path to the config file */ function readJsonConfigFile(fileName: string, readFile: (path: string) => string | undefined): JsonSourceFile; /** * Convert the json syntax tree into the json value */ function convertToObject(sourceFile: JsonSourceFile, errors: Diagnostic[]): any; /** * Parse the contents of a config file (tsconfig.json). * @param json The contents of the config file to parse * @param host Instance of ParseConfigHost used to enumerate files in folder. * @param basePath A root directory to resolve relative path entries in the config * file to. e.g. outDir */ function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: JsFileExtensionInfo[]): ParsedCommandLine; /** * Parse the contents of a config file (tsconfig.json). * @param jsonNode The contents of the config file to parse * @param host Instance of ParseConfigHost used to enumerate files in folder. * @param basePath A root directory to resolve relative path entries in the config * file to. e.g. outDir */ function parseJsonSourceFileConfigFileContent(sourceFile: JsonSourceFile, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: JsFileExtensionInfo[]): ParsedCommandLine; function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): { options: CompilerOptions; errors: Diagnostic[]; }; function convertTypeAcquisitionFromJson(jsonOptions: any, basePath: string, configFileName?: string): { options: TypeAcquisition; errors: Diagnostic[]; }; } declare namespace ts { interface Node { getSourceFile(): SourceFile; getChildCount(sourceFile?: SourceFile): number; getChildAt(index: number, sourceFile?: SourceFile): Node; getChildren(sourceFile?: SourceFile): Node[]; getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): number; getFullStart(): number; getEnd(): number; getWidth(sourceFile?: SourceFile): number; getFullWidth(): number; getLeadingTriviaWidth(sourceFile?: SourceFile): number; getFullText(sourceFile?: SourceFile): string; getText(sourceFile?: SourceFile): string; getFirstToken(sourceFile?: SourceFile): Node; getLastToken(sourceFile?: SourceFile): Node; forEachChild(cbNode: (node: Node) => T | undefined, cbNodeArray?: (nodes: NodeArray) => T | undefined): T | undefined; } interface Symbol { getFlags(): SymbolFlags; getName(): __String; getUnescapedName(): string; getDeclarations(): Declaration[] | undefined; getDocumentationComment(): SymbolDisplayPart[]; getJsDocTags(): JSDocTagInfo[]; } interface 别名 { 取旗帜(): 别名旗帜; 取名称(): string; } interface Type { getFlags(): TypeFlags; getSymbol(): Symbol | undefined; getProperties(): Symbol[]; getProperty(propertyName: string): Symbol | undefined; getApparentProperties(): Symbol[]; getCallSignatures(): Signature[]; getConstructSignatures(): Signature[]; getStringIndexType(): Type | undefined; getNumberIndexType(): Type | undefined; getBaseTypes(): BaseType[] | undefined; getNonNullableType(): Type; } interface Signature { getDeclaration(): SignatureDeclaration; getTypeParameters(): TypeParameter[] | undefined; getParameters(): Symbol[]; getReturnType(): Type; getDocumentationComment(): SymbolDisplayPart[]; getJsDocTags(): JSDocTagInfo[]; } interface 词典完成条目 { name: string; range: Range; isStringLiteral: boolean; rangeMap?: RangeMap; } interface Position { readonly line: number; readonly character: number; } interface RangeMap { [x: string]: RangeInfo[]; } interface Range { readonly start: Position; readonly end: Position; } interface RangeInfo { readonly start: Position; readonly end: Position; readonly parent: Position; readonly isStringLiteral: boolean; } interface SourceFile { getLineAndCharacterOfPosition(pos: number): LineAndCharacter; getLineEndOfPosition(pos: number): number; getLineStarts(): number[]; getPositionOfLineAndCharacter(line: number, character: number): number; update(newText: string, textChangeRange: TextChangeRange): SourceFile; } interface SourceFileLike { getLineAndCharacterOfPosition(pos: number): LineAndCharacter; } interface SourceMapSource { getLineAndCharacterOfPosition(pos: number): LineAndCharacter; } /** * Represents an immutable snapshot of a script at a specified time.Once acquired, the * snapshot is observably immutable. i.e. the same calls with the same parameters will return * the same values. */ interface IScriptSnapshot { /** Gets a portion of the script snapshot specified by [start, end). */ getText(start: number, end: number): string; /** Gets the length of this script snapshot. */ getLength(): number; /** * Gets the TextChangeRange that describe how the text changed between this text and * an older version. This information is used by the incremental parser to determine * what sections of the script need to be re-parsed. 'undefined' can be returned if the * change range cannot be determined. However, in that case, incremental parsing will * not happen and the entire document will be re - parsed. */ getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange | undefined; /** Releases all resources held by this script snapshot */ dispose?(): void; } namespace ScriptSnapshot { function fromString(text: string): IScriptSnapshot; } interface PreProcessedFileInfo { referencedFiles: FileReference[]; typeReferenceDirectives: FileReference[]; importedFiles: FileReference[]; ambientExternalModules: string[]; isLibFile: boolean; } interface HostCancellationToken { isCancellationRequested(): boolean; } interface LanguageServiceHost { getCompilationSettings(): CompilerOptions; getNewLine?(): string; getProjectVersion?(): string; getScriptFileNames(): string[]; getScriptKind?(fileName: string): ScriptKind; getScriptVersion(fileName: string): string; getScriptSnapshot(fileName: string): IScriptSnapshot | undefined; getLocalizedDiagnosticMessages?(): any; getCancellationToken?(): HostCancellationToken; getCurrentDirectory(): string; getDefaultLibFileName(options: CompilerOptions): string; log?(s: string): void; trace?(s: string): void; error?(s: string): void; useCaseSensitiveFileNames?(): boolean; readDirectory?(path: string, extensions?: ReadonlyArray, exclude?: ReadonlyArray, include?: ReadonlyArray, depth?: number): string[]; readFile?(path: string, encoding?: string): string | undefined; fileExists?(path: string): boolean; getTypeRootsVersion?(): number; resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[]; resolveTypeReferenceDirectives?(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[]; directoryExists?(directoryName: string): boolean; getDirectories?(directoryName: string): string[]; /** * Gets a set of custom transformers to use during emit. */ getCustomTransformers?(): CustomTransformers | undefined; } interface LanguageService { cleanupSemanticCache(): void; getSyntacticDiagnostics(fileName: string): Diagnostic[]; getSemanticDiagnostics(fileName: string): Diagnostic[]; getCompilerOptionsDiagnostics(): Diagnostic[]; /** * @deprecated Use getEncodedSyntacticClassifications instead. */ getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; /** * @deprecated Use getEncodedSemanticClassifications instead. */ getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[]; getEncodedSyntacticClassifications(fileName: string, span: TextSpan): Classifications; getEncodedSemanticClassifications(fileName: string, span: TextSpan): Classifications; getCompletionsAtPosition(fileName: string, position: number): CompletionInfo; getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails; getCompletionEntrySymbol(fileName: string, position: number, entryName: string): Symbol; 取词典自动完成项目(fileName: string, position: number, ignoreName: string): 词典完成条目; getQuickInfoAtPosition(fileName: string, position: number): QuickInfo; getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan; getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan; getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems; getRenameInfo(fileName: string, position: number): RenameInfo; findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[]; getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[]; getTypeDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[]; getImplementationAtPosition(fileName: string, position: number): ImplementationLocation[]; getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[]; findReferences(fileName: string, position: number): ReferencedSymbol[]; getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[]; /** @deprecated */ getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[]; getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string, excludeDtsFiles?: boolean): NavigateToItem[]; getNavigationBarItems(fileName: string): NavigationBarItem[]; getNavigationTree(fileName: string): NavigationTree; getOutliningSpans(fileName: string): OutliningSpan[]; getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[]; getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[]; getIndentationAtPosition(fileName: string, position: number, options: EditorOptions | EditorSettings): number; getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[]; getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[]; getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[]; getDocCommentTemplateAtPosition(fileName: string, position: number): TextInsertion; isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean; getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: number[], formatOptions: FormatCodeSettings): CodeAction[]; getApplicableRefactors(fileName: string, positionOrRaneg: number | TextRange): ApplicableRefactorInfo[]; getEditsForRefactor(fileName: string, formatOptions: FormatCodeSettings, positionOrRange: number | TextRange, refactorName: string, actionName: string): RefactorEditInfo | undefined; getEmitOutput(fileName: string, emitOnlyDtsFiles?: boolean): EmitOutput; getProgram(): Program; dispose(): void; } interface Classifications { spans: number[]; endOfLineState: EndOfLineState; } interface ClassifiedSpan { textSpan: TextSpan; classificationType: ClassificationTypeNames; } /** * Navigation bar interface designed for visual studio's dual-column layout. * This does not form a proper tree. * The navbar is returned as a list of top-level items, each of which has a list of child items. * Child items always have an empty array for their `childItems`. */ interface NavigationBarItem { text: string; kind: ScriptElementKind; kindModifiers: string; spans: TextSpan[]; childItems: NavigationBarItem[]; indent: number; bolded: boolean; grayed: boolean; } /** * Node in a tree of nested declarations in a file. * The top node is always a script or module node. */ interface NavigationTree { /** Name of the declaration, or a short description, e.g. "". */ text: string; kind: ScriptElementKind; /** ScriptElementKindModifier separated by commas, e.g. "public,abstract" */ kindModifiers: string; /** * Spans of the nodes that generated this declaration. * There will be more than one if this is the result of merging. */ spans: TextSpan[]; /** Present if non-empty */ childItems?: NavigationTree[]; } interface TodoCommentDescriptor { text: string; priority: number; } interface TodoComment { descriptor: TodoCommentDescriptor; message: string; position: number; } class TextChange { span: TextSpan; newText: string; } interface FileTextChanges { fileName: string; textChanges: TextChange[]; } interface CodeAction { /** Description of the code action to display in the UI of the editor */ description: string; /** Text changes to apply to each file as part of the code action */ changes: FileTextChanges[]; } /** * A set of one or more available refactoring actions, grouped under a parent refactoring. */ interface ApplicableRefactorInfo { /** * The programmatic name of the refactoring */ name: string; /** * A description of this refactoring category to show to the user. * If the refactoring gets inlined (see below), this text will not be visible. */ description: string; /** * Inlineable refactorings can have their actions hoisted out to the top level * of a context menu. Non-inlineanable refactorings should always be shown inside * their parent grouping. * * If not specified, this value is assumed to be 'true' */ inlineable?: boolean; actions: RefactorActionInfo[]; } /** * Represents a single refactoring action - for example, the "Extract Method..." refactor might * offer several actions, each corresponding to a surround class or closure to extract into. */ type RefactorActionInfo = { /** * The programmatic name of the refactoring action */ name: string; /** * A description of this refactoring action to show to the user. * If the parent refactoring is inlined away, this will be the only text shown, * so this description should make sense by itself if the parent is inlineable=true */ description: string; }; /** * A set of edits to make in response to a refactor action, plus an optional * location where renaming should be invoked from */ type RefactorEditInfo = { edits: FileTextChanges[]; renameFilename?: string; renameLocation?: number; }; interface TextInsertion { newText: string; /** The position in newText the caret should point to after the insertion. */ caretOffset: number; } interface DocumentSpan { textSpan: TextSpan; fileName: string; } interface RenameLocation extends DocumentSpan { } interface ReferenceEntry extends DocumentSpan { isWriteAccess: boolean; isDefinition: boolean; isInString?: true; } interface ImplementationLocation extends DocumentSpan { kind: ScriptElementKind; displayParts: SymbolDisplayPart[]; } interface DocumentHighlights { fileName: string; highlightSpans: HighlightSpan[]; } const enum HighlightSpanKind { none = "none", definition = "definition", reference = "reference", writtenReference = "writtenReference", } interface HighlightSpan { fileName?: string; isInString?: true; textSpan: TextSpan; kind: HighlightSpanKind; } interface NavigateToItem { name: string; kind: ScriptElementKind; kindModifiers: string; matchKind: string; isCaseSensitive: boolean; fileName: string; textSpan: TextSpan; containerName: string; containerKind: ScriptElementKind; } enum IndentStyle { None = 0, Block = 1, Smart = 2, } interface EditorOptions { BaseIndentSize?: number; IndentSize: number; TabSize: number; NewLineCharacter: string; ConvertTabsToSpaces: boolean; IndentStyle: IndentStyle; } interface EditorSettings { baseIndentSize?: number; indentSize?: number; tabSize?: number; newLineCharacter?: string; convertTabsToSpaces?: boolean; indentStyle?: IndentStyle; } interface FormatCodeOptions extends EditorOptions { InsertSpaceAfterCommaDelimiter: boolean; InsertSpaceAfterSemicolonInForStatements: boolean; InsertSpaceBeforeAndAfterBinaryOperators: boolean; InsertSpaceAfterConstructor?: boolean; InsertSpaceAfterKeywordsInControlFlowStatements: boolean; InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean; InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean; InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: boolean; InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean; InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: boolean; InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean; InsertSpaceAfterTypeAssertion?: boolean; InsertSpaceBeforeFunctionParenthesis?: boolean; PlaceOpenBraceOnNewLineForFunctions: boolean; PlaceOpenBraceOnNewLineForControlBlocks: boolean; } interface FormatCodeSettings extends EditorSettings { insertSpaceAfterCommaDelimiter?: boolean; insertSpaceAfterSemicolonInForStatements?: boolean; insertSpaceBeforeAndAfterBinaryOperators?: boolean; insertSpaceAfterConstructor?: boolean; insertSpaceAfterKeywordsInControlFlowStatements?: boolean; insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean; insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean; insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean; insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean; insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean; insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean; insertSpaceAfterTypeAssertion?: boolean; insertSpaceBeforeFunctionParenthesis?: boolean; placeOpenBraceOnNewLineForFunctions?: boolean; placeOpenBraceOnNewLineForControlBlocks?: boolean; } interface DefinitionInfo { fileName: string; textSpan: TextSpan; kind: ScriptElementKind; name: string; containerKind: ScriptElementKind; containerName: string; } interface ReferencedSymbolDefinitionInfo extends DefinitionInfo { displayParts: SymbolDisplayPart[]; } interface ReferencedSymbol { definition: ReferencedSymbolDefinitionInfo; references: ReferenceEntry[]; } enum SymbolDisplayPartKind { aliasName = 0, className = 1, enumName = 2, fieldName = 3, interfaceName = 4, keyword = 5, lineBreak = 6, numericLiteral = 7, stringLiteral = 8, localName = 9, methodName = 10, moduleName = 11, operator = 12, parameterName = 13, propertyName = 14, punctuation = 15, space = 16, text = 17, typeParameterName = 18, enumMemberName = 19, functionName = 20, regularExpressionLiteral = 21, } interface SymbolDisplayPart { text: string; kind: string; } interface JSDocTagInfo { name: string; text?: string; } interface QuickInfo { kind: ScriptElementKind; kindModifiers: string; textSpan: TextSpan; displayParts: SymbolDisplayPart[]; documentation: SymbolDisplayPart[]; tags: JSDocTagInfo[]; } interface RenameInfo { canRename: boolean; localizedErrorMessage: string; displayName: string; fullDisplayName: string; kind: ScriptElementKind; kindModifiers: string; triggerSpan: TextSpan; } interface 词典替换信息 { canRename: boolean; localizedErrorMessage: string; displayName: string; fullDisplayName: string; kindModifiers: string; triggerSpan: TextSpan; } interface SignatureHelpParameter { name: string; documentation: SymbolDisplayPart[]; displayParts: SymbolDisplayPart[]; isOptional: boolean; } /** * Represents a single signature to show in signature help. * The id is used for subsequent calls into the language service to ask questions about the * signature help item in the context of any documents that have been updated. i.e. after * an edit has happened, while signature help is still active, the host can ask important * questions like 'what parameter is the user currently contained within?'. */ interface SignatureHelpItem { isVariadic: boolean; prefixDisplayParts: SymbolDisplayPart[]; suffixDisplayParts: SymbolDisplayPart[]; separatorDisplayParts: SymbolDisplayPart[]; parameters: SignatureHelpParameter[]; documentation: SymbolDisplayPart[]; tags: JSDocTagInfo[]; } /** * Represents a set of signature help items, and the preferred item that should be selected. */ interface SignatureHelpItems { items: SignatureHelpItem[]; applicableSpan: TextSpan; selectedItemIndex: number; argumentIndex: number; argumentCount: number; } interface CompletionInfo { isGlobalCompletion: boolean; isMemberCompletion: boolean; /** * true when the current location also allows for a new identifier */ isNewIdentifierLocation: boolean; entries: CompletionEntry[]; } interface CompletionEntry { name: string; kind: ScriptElementKind; kindModifiers: string; sortText: string; /** * An optional span that indicates the text to be replaced by this completion item. It will be * set if the required span differs from the one generated by the default replacement behavior and should * be used in that case */ replacementSpan?: TextSpan; } interface CompletionEntryDetails { name: string; kind: ScriptElementKind; kindModifiers: string; displayParts: SymbolDisplayPart[]; documentation: SymbolDisplayPart[]; tags: JSDocTagInfo[]; } interface OutliningSpan { /** The span of the document to actually collapse. */ textSpan: TextSpan; /** The span of the document to display when the user hovers over the collapsed span. */ hintSpan: TextSpan; /** The text to display in the editor for the collapsed region. */ bannerText: string; /** * Whether or not this region should be automatically collapsed when * the 'Collapse to Definitions' command is invoked. */ autoCollapse: boolean; } interface EmitOutput { outputFiles: OutputFile[]; emitSkipped: boolean; } const enum OutputFileType { JavaScript = 0, SourceMap = 1, Declaration = 2, } interface OutputFile { name: string; writeByteOrderMark: boolean; text: string; } const enum EndOfLineState { None = 0, InMultiLineCommentTrivia = 1, InSingleQuoteStringLiteral = 2, InDoubleQuoteStringLiteral = 3, InTemplateHeadOrNoSubstitutionTemplate = 4, InTemplateMiddleOrTail = 5, InTemplateSubstitutionPosition = 6, } enum TokenClass { Punctuation = 0, Keyword = 1, Operator = 2, Comment = 3, Whitespace = 4, Identifier = 5, NumberLiteral = 6, StringLiteral = 7, RegExpLiteral = 8, } interface ClassificationResult { finalLexState: EndOfLineState; entries: ClassificationInfo[]; } interface ClassificationInfo { length: number; classification: TokenClass; } interface Classifier { /** * Gives lexical classifications of tokens on a line without any syntactic context. * For instance, a token consisting of the text 'string' can be either an identifier * named 'string' or the keyword 'string', however, because this classifier is not aware, * it relies on certain heuristics to give acceptable results. For classifications where * speed trumps accuracy, this function is preferable; however, for true accuracy, the * syntactic classifier is ideal. In fact, in certain editing scenarios, combining the * lexical, syntactic, and semantic classifiers may issue the best user experience. * * @param text The text of a line to classify. * @param lexState The state of the lexical classifier at the end of the previous line. * @param syntacticClassifierAbsent Whether the client is *not* using a syntactic classifier. * If there is no syntactic classifier (syntacticClassifierAbsent=true), * certain heuristics may be used in its place; however, if there is a * syntactic classifier (syntacticClassifierAbsent=false), certain * classifications which may be incorrectly categorized will be given * back as Identifiers in order to allow the syntactic classifier to * subsume the classification. * @deprecated Use getLexicalClassifications instead. */ getClassificationsForLine(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): ClassificationResult; getEncodedLexicalClassifications(text: string, endOfLineState: EndOfLineState, syntacticClassifierAbsent: boolean): Classifications; } const enum ScriptElementKind { unknown = "", warning = "警告", /** predefined type (void) or keyword (class) */ keyword = "关键字", /** top level script node */ scriptElement = "脚本", /** module foo {} */ moduleElement = "模块", /** class X {} */ classElement = "类", /** var x = class X {} */ localClassElement = "本地类", /** interface Y {} */ interfaceElement = "接口", /** type T = ... */ typeElement = "类型", /** enum E */ enumElement = "枚举", enumMemberElement = "枚举成员", /** * Inside module and script only * const v = .. */ variableElement = "自由变量", /** Inside function */ localVariableElement = "本地自由变量", /** * Inside module and script only * function f() { } */ functionElement = "函数", /** Inside function */ localFunctionElement = "本地函数", /** class X { [public|private]* foo() {} } */ memberFunctionElement = "方法", /** class X { [public|private]* [get|set] foo:number; } */ memberGetAccessorElement = "取属性", memberSetAccessorElement = "置属性", /** * class X { [public|private]* foo:number; } * interface Y { foo:number; } */ memberVariableElement = "原型", /** class X { constructor() { } } */ constructorImplementationElement = "构造函数", /** interface Y { ():number; } */ callSignatureElement = "调用", /** interface Y { []:number; } */ indexSignatureElement = "索引", /** interface Y { new():Y; } */ constructSignatureElement = "构建", /** function foo(*Y*: string) */ parameterElement = "参数", typeParameterElement = "类型参数", primitiveType = "原始类型", label = "标签", alias = "别名", constElement = "常量", letElement = "变量", directory = "目录", externalModuleName = "外部模块名", /** * */ jsxAttribute = "JSX属性", } const enum ScriptElementKindModifier { none = "", publicMemberModifier = "公开", privateMemberModifier = "私有", protectedMemberModifier = "保护", exportedModifier = "导出", ambientModifier = "声明", staticModifier = "静态", abstractModifier = "抽象", } const enum ClassificationTypeNames { comment = "评论", identifier = "标识符", keyword = "关键字", numericLiteral = "数字", operator = "运算符", stringLiteral = "文字", whiteSpace = "空格", text = "文本", punctuation = "标点符号", className = "类名", enumName = "枚举名", interfaceName = "接口名", moduleName = "模块名", typeParameterName = "类型参数名", typeAliasName = "类型别名名", parameterName = "参数名", docCommentTagName = "注释标签名", jsxOpenTagName = "JSX开始标签名", jsxCloseTagName = "JSX结尾标签名", jsxSelfClosingTagName = "JSX自闭标签名", jsxAttribute = "JSX特性", jsxText = "JSX文本", jsxAttributeStringLiteralValue = "JSX特性字面值", } const enum ClassificationType { comment = 1, identifier = 2, keyword = 3, numericLiteral = 4, operator = 5, stringLiteral = 6, regularExpressionLiteral = 7, whiteSpace = 8, text = 9, punctuation = 10, className = 11, enumName = 12, interfaceName = 13, moduleName = 14, typeParameterName = 15, typeAliasName = 16, parameterName = 17, docCommentTagName = 18, jsxOpenTagName = 19, jsxCloseTagName = 20, jsxSelfClosingTagName = 21, jsxAttribute = 22, jsxText = 23, jsxAttributeStringLiteralValue = 24, } } declare namespace ts { function createClassifier(): Classifier; } declare namespace ts.词典完成 { function 取词典自动完成项目(sourceFile: SourceFile, position: number, ignoreName: string): 词典完成条目; } declare namespace ts { /** * The document registry represents a store of SourceFile objects that can be shared between * multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST) * of files in the context. * SourceFile objects account for most of the memory usage by the language service. Sharing * the same DocumentRegistry instance between different instances of LanguageService allow * for more efficient memory utilization since all projects will share at least the library * file (lib.d.ts). * * A more advanced use of the document registry is to serialize sourceFile objects to disk * and re-hydrate them when needed. * * To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it * to all subsequent createLanguageService calls. */ interface DocumentRegistry { /** * Request a stored SourceFile with a given fileName and compilationSettings. * The first call to acquire will call createLanguageServiceSourceFile to generate * the SourceFile if was not found in the registry. * * @param fileName The name of the file requested * @param compilationSettings Some compilation settings like target affects the * shape of a the resulting SourceFile. This allows the DocumentRegistry to store * multiple copies of the same file for different compilation settings. * @parm scriptSnapshot Text of the file. Only used if the file was not found * in the registry and a new one was created. * @parm version Current version of the file. Only used if the file was not found * in the registry and a new one was created. */ acquireDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile; acquireDocumentWithKey(fileName: string, path: Path, compilationSettings: CompilerOptions, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile; /** * Request an updated version of an already existing SourceFile with a given fileName * and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile * to get an updated SourceFile. * * @param fileName The name of the file requested * @param compilationSettings Some compilation settings like target affects the * shape of a the resulting SourceFile. This allows the DocumentRegistry to store * multiple copies of the same file for different compilation settings. * @param scriptSnapshot Text of the file. * @param version Current version of the file. */ updateDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile; updateDocumentWithKey(fileName: string, path: Path, compilationSettings: CompilerOptions, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile; getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey; /** * Informs the DocumentRegistry that a file is not needed any longer. * * Note: It is not allowed to call release on a SourceFile that was not acquired from * this registry originally. * * @param fileName The name of the file to be released * @param compilationSettings The compilation settings used to acquire the file */ releaseDocument(fileName: string, compilationSettings: CompilerOptions): void; releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey): void; reportStats(): string; } type DocumentRegistryBucketKey = string & { __bucketKey: any; }; function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory?: 文字): DocumentRegistry; } declare namespace ts { function preProcessFile(sourceText: string, readImportFiles?: 真假, detectJavaScriptImports?: 真假): PreProcessedFileInfo; } declare namespace ts { interface TranspileOptions { compilerOptions?: CompilerOptions; fileName?: string; reportDiagnostics?: boolean; moduleName?: string; renamedDependencies?: MapLike; transformers?: CustomTransformers; } interface TranspileOutput { outputText: string; diagnostics?: Diagnostic[]; sourceMapText?: string; } function transpileModule(input: string, transpileOptions: TranspileOptions): TranspileOutput; function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string; } declare namespace ts { /** The version of the language service API */ const servicesVersion = "0.5"; interface DisplayPartsSymbolWriter extends SymbolWriter { displayParts(): SymbolDisplayPart[]; } function toEditorSettings(options: EditorOptions | EditorSettings): EditorSettings; function displayPartsToString(displayParts: SymbolDisplayPart[]): 文字; function getDefaultCompilerOptions(): CompilerOptions; function getSupportedCodeFixes(): 文字[]; function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean, scriptKind?: ScriptKind): SourceFile; let disableIncrementalParsing: 真假; function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile; function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry): LanguageService; function 取别名全表(sourceFile: SourceFile): Map; function 转换位置为行数及字符偏移(sourceFile: SourceFile, 位置: number): LineAndCharacter; /** * Get the path of the default library files (lib.d.ts) as distributed with the typescript * node package. * The functionality is not supported if the ts module is consumed outside of a node module. */ function getDefaultLibFilePath(options: CompilerOptions): string; function 写(...data: string[]): 无值; } declare namespace ts.server { interface CompressedData { length: number; compressionKind: string; data: any; } type RequireResult = { module: {}; error: undefined; } | { module: undefined; error: {}; }; interface ServerHost extends System { setTimeout(callback: (...args: any[]) => void, ms: number, ...args: any[]): any; clearTimeout(timeoutId: any): void; setImmediate(callback: (...args: any[]) => void, ...args: any[]): any; clearImmediate(timeoutId: any): void; gc?(): void; trace?(s: string): void; require?(initialPath: string, moduleName: string): RequireResult; } interface SortedArray extends Array { " __sortedArrayBrand": any; } interface SortedReadonlyArray extends ReadonlyArray { " __sortedArrayBrand": any; } interface TypingInstallerRequest { readonly projectName: string; readonly kind: "discover" | "closeProject"; } interface DiscoverTypings extends TypingInstallerRequest { readonly fileNames: string[]; readonly projectRootPath: Path; readonly compilerOptions: CompilerOptions; readonly typeAcquisition: TypeAcquisition; readonly unresolvedImports: SortedReadonlyArray; readonly cachePath?: string; readonly kind: "discover"; } interface CloseProject extends TypingInstallerRequest { readonly kind: "closeProject"; } type ActionSet = "action::set"; type ActionInvalidate = "action::invalidate"; type EventBeginInstallTypes = "event::beginInstallTypes"; type EventEndInstallTypes = "event::endInstallTypes"; type EventInitializationFailed = "event::initializationFailed"; interface TypingInstallerResponse { readonly kind: ActionSet | ActionInvalidate | EventBeginInstallTypes | EventEndInstallTypes | EventInitializationFailed; } interface InitializationFailedResponse extends TypingInstallerResponse { readonly kind: EventInitializationFailed; readonly message: string; } interface ProjectResponse extends TypingInstallerResponse { readonly projectName: string; } interface SetTypings extends ProjectResponse { readonly typeAcquisition: TypeAcquisition; readonly compilerOptions: CompilerOptions; readonly typings: string[]; readonly unresolvedImports: SortedReadonlyArray; readonly kind: ActionSet; } interface InvalidateCachedTypings extends ProjectResponse { readonly kind: ActionInvalidate; } interface InstallTypes extends ProjectResponse { readonly kind: EventBeginInstallTypes | EventEndInstallTypes; readonly eventId: number; readonly typingsInstallerVersion: string; readonly packagesToInstall: ReadonlyArray; } interface BeginInstallTypes extends InstallTypes { readonly kind: EventBeginInstallTypes; } interface EndInstallTypes extends InstallTypes { readonly kind: EventEndInstallTypes; readonly installSuccess: boolean; } } declare namespace ts.server { const ActionSet: ActionSet; const ActionInvalidate: ActionInvalidate; const EventBeginInstallTypes: EventBeginInstallTypes; const EventEndInstallTypes: EventEndInstallTypes; const EventInitializationFailed: EventInitializationFailed; namespace Arguments { const GlobalCacheLocation = "--globalTypingsCacheLocation"; const LogFile = "--logFile"; const EnableTelemetry = "--enableTelemetry"; const TypingSafeListLocation = "--typingSafeListLocation"; /** * This argument specifies the location of the NPM executable. * typingsInstaller will run the command with `${npmLocation} install ...`. */ const NpmLocation = "--npmLocation"; } function hasArgument(argumentName: string): 真假; function findArgument(argumentName: string): string | undefined; } declare namespace ts.server { enum LogLevel { terse = 0, normal = 1, requestTime = 2, verbose = 3, } const emptyArray: SortedReadonlyArray; interface Logger { close(): void; hasLevel(level: LogLevel): boolean; loggingEnabled(): boolean; perftrc(s: string): void; info(s: string): void; startGroup(): void; endGroup(): void; msg(s: string, type?: Msg.Types): void; getLogFileName(): string; } namespace Msg { type Err = "Err"; const Err: Err; type Info = "Info"; const Info: Info; type Perf = "Perf"; const Perf: Perf; type Types = Err | Info | Perf; } function createInstallTypingsRequest(project: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray, cachePath?: string): DiscoverTypings; namespace Errors { function ThrowNoProject(): never; function ThrowProjectLanguageServiceDisabled(): never; function ThrowProjectDoesNotContainDocument(fileName: string, project: Project): never; } function getDefaultFormatCodeSettings(host: ServerHost): FormatCodeSettings; function mergeMapLikes(target: MapLike, source: MapLike): void; function removeItemFromSet(items: T[], itemToRemove: T): 无值; type NormalizedPath = string & { __normalizedPathTag: any; }; function toNormalizedPath(fileName: string): NormalizedPath; function normalizedPathToPath(normalizedPath: NormalizedPath, currentDirectory: string, getCanonicalFileName: (f: string) => string): Path; function asNormalizedPath(fileName: string): NormalizedPath; interface NormalizedPathMap { get(path: NormalizedPath): T; set(path: NormalizedPath, value: T): void; contains(path: NormalizedPath): boolean; remove(path: NormalizedPath): void; } function createNormalizedPathMap(): NormalizedPathMap; interface ProjectOptions { configHasExtendsProperty: boolean; /** * true if config file explicitly listed files */ configHasFilesProperty: boolean; configHasIncludeProperty: boolean; configHasExcludeProperty: boolean; /** * these fields can be present in the project file */ files?: string[]; wildcardDirectories?: Map; compilerOptions?: CompilerOptions; typeAcquisition?: TypeAcquisition; compileOnSave?: boolean; } function isInferredProjectName(name: string): 真假; function makeInferredProjectName(counter: number): 文字; function createSortedArray(): SortedArray; function toSortedArray(arr: string[]): SortedArray; function toSortedArray(arr: T[], comparer: Comparer): SortedArray; function enumerateInsertsAndDeletes(newItems: SortedReadonlyArray, oldItems: SortedReadonlyArray, inserted: (newItem: T) => void, deleted: (oldItem: T) => void, compare?: Comparer): 无值; class ThrottledOperations { private readonly host; private pendingTimeouts; constructor(host: ServerHost); schedule(operationId: string, delay: number, cb: () => void): 无值; private static run(self, operationId, cb); } class GcTimer { private readonly host; private readonly delay; private readonly logger; private timerId; constructor(host: ServerHost, delay: number, logger: Logger); scheduleCollect(): 无值; private static run(self); } function insertSorted(array: SortedArray, insert: T, compare: Comparer): void; function removeSorted(array: SortedArray, remove: T, compare: Comparer): void; } /** * Declaration module describing the TypeScript Server protocol */ declare namespace ts.server.protocol { const enum CommandTypes { Brace = "brace", BraceCompletion = "braceCompletion", Change = "change", Close = "close", Completions = "completions", 词典自动完成 = "词典自动完成", CompletionDetails = "completionEntryDetails", CompileOnSaveAffectedFileList = "compileOnSaveAffectedFileList", CompileOnSaveEmitFile = "compileOnSaveEmitFile", Configure = "configure", Definition = "definition", Implementation = "implementation", Exit = "exit", Format = "format", Formatonkey = "formatonkey", Geterr = "geterr", GeterrForProject = "geterrForProject", SemanticDiagnosticsSync = "semanticDiagnosticsSync", SyntacticDiagnosticsSync = "syntacticDiagnosticsSync", NavBar = "navbar", Navto = "navto", NavTree = "navtree", NavTreeFull = "navtree-full", Occurrences = "occurrences", DocumentHighlights = "documentHighlights", Open = "open", Quickinfo = "quickinfo", References = "references", Reload = "reload", Rename = "rename", Saveto = "saveto", SignatureHelp = "signatureHelp", TypeDefinition = "typeDefinition", ProjectInfo = "projectInfo", ReloadProjects = "reloadProjects", Unknown = "unknown", OpenExternalProject = "openExternalProject", OpenExternalProjects = "openExternalProjects", CloseExternalProject = "closeExternalProject", TodoComments = "todoComments", Indentation = "indentation", DocCommentTemplate = "docCommentTemplate", CompilerOptionsForInferredProjects = "compilerOptionsForInferredProjects", GetCodeFixes = "getCodeFixes", GetSupportedCodeFixes = "getSupportedCodeFixes", GetApplicableRefactors = "getApplicableRefactors", GetEditsForRefactor = "getEditsForRefactor", } /** * A TypeScript Server message */ interface Message { /** * Sequence number of the message */ seq: number; /** * One of "request", "response", or "event" */ type: "request" | "response" | "event"; } /** * Client-initiated request message */ interface Request extends Message { /** * The command to execute */ command: string; /** * Object containing arguments for the command */ arguments?: any; } /** * Request to reload the project structure for all the opened files */ interface ReloadProjectsRequest extends Message { command: CommandTypes.ReloadProjects; } /** * Server-initiated event message */ interface Event extends Message { /** * Name of event */ event: string; /** * Event-specific information */ body?: any; } /** * Response by server to client request message. */ interface Response extends Message { /** * Sequence number of the request message. */ request_seq: number; /** * Outcome of the request. */ success: boolean; /** * The command requested. */ command: string; /** * Contains error message if success === false. */ message?: string; /** * Contains message body if success === true. */ body?: any; } /** * Arguments for FileRequest messages. */ interface FileRequestArgs { /** * The file for the request (absolute pathname required). */ file: string; projectFileName?: string; } /** * Requests a JS Doc comment template for a given position */ interface DocCommentTemplateRequest extends FileLocationRequest { command: CommandTypes.DocCommentTemplate; } /** * Response to DocCommentTemplateRequest */ interface DocCommandTemplateResponse extends Response { body?: TextInsertion; } /** * A request to get TODO comments from the file */ interface TodoCommentRequest extends FileRequest { command: CommandTypes.TodoComments; arguments: TodoCommentRequestArgs; } /** * Arguments for TodoCommentRequest request. */ interface TodoCommentRequestArgs extends FileRequestArgs { /** * Array of target TodoCommentDescriptors that describes TODO comments to be found */ descriptors: TodoCommentDescriptor[]; } /** * Response for TodoCommentRequest request. */ interface TodoCommentsResponse extends Response { body?: TodoComment[]; } /** * A request to get indentation for a location in file */ interface IndentationRequest extends FileLocationRequest { command: CommandTypes.Indentation; arguments: IndentationRequestArgs; } /** * Response for IndentationRequest request. */ interface IndentationResponse extends Response { body?: IndentationResult; } /** * Indentation result representing where indentation should be placed */ interface IndentationResult { /** * The base position in the document that the indent should be relative to */ position: number; /** * The number of columns the indent should be at relative to the position's column. */ indentation: number; } /** * Arguments for IndentationRequest request. */ interface IndentationRequestArgs extends FileLocationRequestArgs { /** * An optional set of settings to be used when computing indentation. * If argument is omitted - then it will use settings for file that were previously set via 'configure' request or global settings. */ options?: EditorSettings; } /** * Arguments for ProjectInfoRequest request. */ interface ProjectInfoRequestArgs extends FileRequestArgs { /** * Indicate if the file name list of the project is needed */ needFileNameList: boolean; } /** * A request to get the project information of the current file. */ interface ProjectInfoRequest extends Request { command: CommandTypes.ProjectInfo; arguments: ProjectInfoRequestArgs; } /** * A request to retrieve compiler options diagnostics for a project */ interface CompilerOptionsDiagnosticsRequest extends Request { arguments: CompilerOptionsDiagnosticsRequestArgs; } /** * Arguments for CompilerOptionsDiagnosticsRequest request. */ interface CompilerOptionsDiagnosticsRequestArgs { /** * Name of the project to retrieve compiler options diagnostics. */ projectFileName: string; } /** * Response message body for "projectInfo" request */ interface ProjectInfo { /** * For configured project, this is the normalized path of the 'tsconfig.json' file * For inferred project, this is undefined */ configFileName: string; /** * The list of normalized file name in the project, including 'lib.d.ts' */ fileNames?: string[]; /** * Indicates if the project has a active language service instance */ languageServiceDisabled?: boolean; } /** * Represents diagnostic info that includes location of diagnostic in two forms * - start position and length of the error span * - startLocation and endLocation - a pair of Location objects that store start/end line and offset of the error span. */ interface DiagnosticWithLinePosition { message: string; start: number; length: number; startLocation: Location; endLocation: Location; category: string; code: number; } /** * Response message for "projectInfo" request */ interface ProjectInfoResponse extends Response { body?: ProjectInfo; } /** * Request whose sole parameter is a file name. */ interface FileRequest extends Request { arguments: FileRequestArgs; } /** * Instances of this interface specify a location in a source file: * (file, line, character offset), where line and character offset are 1-based. */ interface FileLocationRequestArgs extends FileRequestArgs { /** * The line number for the request (1-based). */ line: number; /** * The character offset (on the line) for the request (1-based). */ offset: number; } type FileLocationOrRangeRequestArgs = FileLocationRequestArgs | FileRangeRequestArgs; /** * Request refactorings at a given position or selection area. */ interface GetApplicableRefactorsRequest extends Request { command: CommandTypes.GetApplicableRefactors; arguments: GetApplicableRefactorsRequestArgs; } type GetApplicableRefactorsRequestArgs = FileLocationOrRangeRequestArgs; /** * Response is a list of available refactorings. * Each refactoring exposes one or more "Actions"; a user selects one action to invoke a refactoring */ interface GetApplicableRefactorsResponse extends Response { body?: ApplicableRefactorInfo[]; } /** * A set of one or more available refactoring actions, grouped under a parent refactoring. */ interface ApplicableRefactorInfo { /** * The programmatic name of the refactoring */ name: string; /** * A description of this refactoring category to show to the user. * If the refactoring gets inlined (see below), this text will not be visible. */ description: string; /** * Inlineable refactorings can have their actions hoisted out to the top level * of a context menu. Non-inlineanable refactorings should always be shown inside * their parent grouping. * * If not specified, this value is assumed to be 'true' */ inlineable?: boolean; actions: RefactorActionInfo[]; } /** * Represents a single refactoring action - for example, the "Extract Method..." refactor might * offer several actions, each corresponding to a surround class or closure to extract into. */ type RefactorActionInfo = { /** * The programmatic name of the refactoring action */ name: string; /** * A description of this refactoring action to show to the user. * If the parent refactoring is inlined away, this will be the only text shown, * so this description should make sense by itself if the parent is inlineable=true */ description: string; }; interface GetEditsForRefactorRequest extends Request { command: CommandTypes.GetEditsForRefactor; arguments: GetEditsForRefactorRequestArgs; } /** * Request the edits that a particular refactoring action produces. * Callers must specify the name of the refactor and the name of the action. */ type GetEditsForRefactorRequestArgs = FileLocationOrRangeRequestArgs & { refactor: string; action: string; }; interface GetEditsForRefactorResponse extends Response { body?: RefactorEditInfo; } type RefactorEditInfo = { edits: FileCodeEdits[]; /** * An optional location where the editor should start a rename operation once * the refactoring edits have been applied */ renameLocation?: Location; renameFilename?: string; }; /** * Request for the available codefixes at a specific position. */ interface CodeFixRequest extends Request { command: CommandTypes.GetCodeFixes; arguments: CodeFixRequestArgs; } interface FileRangeRequestArgs extends FileRequestArgs { /** * The line number for the request (1-based). */ startLine: number; /** * The character offset (on the line) for the request (1-based). */ startOffset: number; /** * The line number for the request (1-based). */ endLine: number; /** * The character offset (on the line) for the request (1-based). */ endOffset: number; } /** * Instances of this interface specify errorcodes on a specific location in a sourcefile. */ interface CodeFixRequestArgs extends FileRangeRequestArgs { /** * Errorcodes we want to get the fixes for. */ errorCodes?: number[]; } /** * Response for GetCodeFixes request. */ interface GetCodeFixesResponse extends Response { body?: CodeAction[]; } /** * A request whose arguments specify a file location (file, line, col). */ interface FileLocationRequest extends FileRequest { arguments: FileLocationRequestArgs; } /** * A request to get codes of supported code fixes. */ interface GetSupportedCodeFixesRequest extends Request { command: CommandTypes.GetSupportedCodeFixes; } /** * A response for GetSupportedCodeFixesRequest request. */ interface GetSupportedCodeFixesResponse extends Response { /** * List of error codes supported by the server. */ body?: string[]; } /** * Arguments for EncodedSemanticClassificationsRequest request. */ interface EncodedSemanticClassificationsRequestArgs extends FileRequestArgs { /** * Start position of the span. */ start: number; /** * Length of the span. */ length: number; } /** * Arguments in document highlight request; include: filesToSearch, file, * line, offset. */ interface DocumentHighlightsRequestArgs extends FileLocationRequestArgs { /** * List of files to search for document highlights. */ filesToSearch: string[]; } /** * Go to definition request; value of command field is * "definition". Return response giving the file locations that * define the symbol found in file at location line, col. */ interface DefinitionRequest extends FileLocationRequest { command: CommandTypes.Definition; } /** * Go to type request; value of command field is * "typeDefinition". Return response giving the file locations that * define the type for the symbol found in file at location line, col. */ interface TypeDefinitionRequest extends FileLocationRequest { command: CommandTypes.TypeDefinition; } /** * Go to implementation request; value of command field is * "implementation". Return response giving the file locations that * implement the symbol found in file at location line, col. */ interface ImplementationRequest extends FileLocationRequest { command: CommandTypes.Implementation; } /** * Location in source code expressed as (one-based) line and (one-based) column offset. */ interface Location { line: number; offset: number; } /** * Object found in response messages defining a span of text in source code. */ interface TextSpan { /** * First character of the definition. */ start: Location; /** * One character past last character of the definition. */ end: Location; } /** * Object found in response messages defining a span of text in a specific source file. */ interface FileSpan extends TextSpan { /** * File containing text span. */ file: string; } /** * Definition response message. Gives text range for definition. */ interface DefinitionResponse extends Response { body?: FileSpan[]; } /** * Definition response message. Gives text range for definition. */ interface TypeDefinitionResponse extends Response { body?: FileSpan[]; } /** * Implementation response message. Gives text range for implementations. */ interface ImplementationResponse extends Response { body?: FileSpan[]; } /** * Request to get brace completion for a location in the file. */ interface BraceCompletionRequest extends FileLocationRequest { command: CommandTypes.BraceCompletion; arguments: BraceCompletionRequestArgs; } /** * Argument for BraceCompletionRequest request. */ interface BraceCompletionRequestArgs extends FileLocationRequestArgs { /** * Kind of opening brace */ openingBrace: string; } /** * Get occurrences request; value of command field is * "occurrences". Return response giving spans that are relevant * in the file at a given line and column. */ interface OccurrencesRequest extends FileLocationRequest { command: CommandTypes.Occurrences; } interface OccurrencesResponseItem extends FileSpan { /** * True if the occurrence is a write location, false otherwise. */ isWriteAccess: boolean; /** * True if the occurrence is in a string, undefined otherwise; */ isInString?: true; } interface OccurrencesResponse extends Response { body?: OccurrencesResponseItem[]; } /** * Get document highlights request; value of command field is * "documentHighlights". Return response giving spans that are relevant * in the file at a given line and column. */ interface DocumentHighlightsRequest extends FileLocationRequest { command: CommandTypes.DocumentHighlights; arguments: DocumentHighlightsRequestArgs; } /** * Span augmented with extra information that denotes the kind of the highlighting to be used for span. */ interface HighlightSpan extends TextSpan { kind: HighlightSpanKind; } /** * Represents a set of highligh spans for a give name */ interface DocumentHighlightsItem { /** * File containing highlight spans. */ file: string; /** * Spans to highlight in file. */ highlightSpans: HighlightSpan[]; } /** * Response for a DocumentHighlightsRequest request. */ interface DocumentHighlightsResponse extends Response { body?: DocumentHighlightsItem[]; } /** * Find references request; value of command field is * "references". Return response giving the file locations that * reference the symbol found in file at location line, col. */ interface ReferencesRequest extends FileLocationRequest { command: CommandTypes.References; } interface ReferencesResponseItem extends FileSpan { /** Text of line containing the reference. Including this * with the response avoids latency of editor loading files * to show text of reference line (the server already has * loaded the referencing files). */ lineText: string; /** * True if reference is a write location, false otherwise. */ isWriteAccess: boolean; /** * True if reference is a definition, false otherwise. */ isDefinition: boolean; } /** * The body of a "references" response message. */ interface ReferencesResponseBody { /** * The file locations referencing the symbol. */ refs: ReferencesResponseItem[]; /** * The name of the symbol. */ symbolName: string; /** * The start character offset of the symbol (on the line provided by the references request). */ symbolStartOffset: number; /** * The full display name of the symbol. */ symbolDisplayString: string; } /** * Response to "references" request. */ interface ReferencesResponse extends Response { body?: ReferencesResponseBody; } /** * Argument for RenameRequest request. */ interface RenameRequestArgs extends FileLocationRequestArgs { /** * Should text at specified location be found/changed in comments? */ findInComments?: boolean; /** * Should text at specified location be found/changed in strings? */ findInStrings?: boolean; } /** * Rename request; value of command field is "rename". Return * response giving the file locations that reference the symbol * found in file at location line, col. Also return full display * name of the symbol so that client can print it unambiguously. */ interface RenameRequest extends FileLocationRequest { command: CommandTypes.Rename; arguments: RenameRequestArgs; } /** * Information about the item to be renamed. */ interface RenameInfo { /** * True if item can be renamed. */ canRename: boolean; /** * Error message if item can not be renamed. */ localizedErrorMessage?: string; /** * Display name of the item to be renamed. */ displayName: string; /** * Full display name of item to be renamed. */ fullDisplayName: string; /** * The items's kind (such as 'className' or 'parameterName' or plain 'text'). */ kind: ScriptElementKind; /** * Optional modifiers for the kind (such as 'public'). */ kindModifiers: string; } /** * A group of text spans, all in 'file'. */ interface SpanGroup { /** The file to which the spans apply */ file: string; /** The text spans in this group */ locs: TextSpan[]; } interface RenameResponseBody { /** * Information about the item to be renamed. */ info: RenameInfo; /** * An array of span groups (one per file) that refer to the item to be renamed. */ locs: SpanGroup[]; } /** * Rename response message. */ interface RenameResponse extends Response { body?: RenameResponseBody; } /** * Represents a file in external project. * External project is project whose set of files, compilation options and open\close state * is maintained by the client (i.e. if all this data come from .csproj file in Visual Studio). * External project will exist even if all files in it are closed and should be closed explicitly. * If external project includes one or more tsconfig.json/jsconfig.json files then tsserver will * create configured project for every config file but will maintain a link that these projects were created * as a result of opening external project so they should be removed once external project is closed. */ interface ExternalFile { /** * Name of file file */ fileName: string; /** * Script kind of the file */ scriptKind?: ScriptKindName | ts.ScriptKind; /** * Whether file has mixed content (i.e. .cshtml file that combines html markup with C#/JavaScript) */ hasMixedContent?: boolean; /** * Content of the file */ content?: string; } /** * Represent an external project */ interface ExternalProject { /** * Project name */ projectFileName: string; /** * List of root files in project */ rootFiles: ExternalFile[]; /** * Compiler options for the project */ options: ExternalProjectCompilerOptions; /** * @deprecated typingOptions. Use typeAcquisition instead */ typingOptions?: TypeAcquisition; /** * Explicitly specified type acquisition for the project */ typeAcquisition?: TypeAcquisition; } interface CompileOnSaveMixin { /** * If compile on save is enabled for the project */ compileOnSave?: boolean; } /** * For external projects, some of the project settings are sent together with * compiler settings. */ type ExternalProjectCompilerOptions = CompilerOptions & CompileOnSaveMixin; /** * Represents a set of changes that happen in project */ interface ProjectChanges { /** * List of added files */ added: string[]; /** * List of removed files */ removed: string[]; /** * List of updated files */ updated: string[]; } /** * Information found in a configure request. */ interface ConfigureRequestArguments { /** * Information about the host, for example 'Emacs 24.4' or * 'Sublime Text version 3075' */ hostInfo?: string; /** * If present, tab settings apply only to this file. */ file?: string; /** * The format options to use during formatting and other code editing features. */ formatOptions?: FormatCodeSettings; /** * The host's additional supported .js file extensions */ extraFileExtensions?: JsFileExtensionInfo[]; } /** * Configure request; value of command field is "configure". Specifies * host information, such as host type, tab size, and indent size. */ interface ConfigureRequest extends Request { command: CommandTypes.Configure; arguments: ConfigureRequestArguments; } /** * Response to "configure" request. This is just an acknowledgement, so * no body field is required. */ interface ConfigureResponse extends Response { } /** * Information found in an "open" request. */ interface OpenRequestArgs extends FileRequestArgs { /** * Used when a version of the file content is known to be more up to date than the one on disk. * Then the known content will be used upon opening instead of the disk copy */ fileContent?: string; /** * Used to specify the script kind of the file explicitly. It could be one of the following: * "TS", "JS", "TSX", "JSX" */ scriptKindName?: ScriptKindName; /** * Used to limit the searching for project config file. If given the searching will stop at this * root path; otherwise it will go all the way up to the dist root path. */ projectRootPath?: string; } type ScriptKindName = "TS" | "CTS" | "JS" | "TSX" | "CTSX" | "JSX"; /** * Open request; value of command field is "open". Notify the * server that the client has file open. The server will not * monitor the filesystem for changes in this file and will assume * that the client is updating the server (using the change and/or * reload messages) when the file changes. Server does not currently * send a response to an open request. */ interface OpenRequest extends Request { command: CommandTypes.Open; arguments: OpenRequestArgs; } /** * Request to open or update external project */ interface OpenExternalProjectRequest extends Request { command: CommandTypes.OpenExternalProject; arguments: OpenExternalProjectArgs; } /** * Arguments to OpenExternalProjectRequest request */ type OpenExternalProjectArgs = ExternalProject; /** * Request to open multiple external projects */ interface OpenExternalProjectsRequest extends Request { command: CommandTypes.OpenExternalProjects; arguments: OpenExternalProjectsArgs; } /** * Arguments to OpenExternalProjectsRequest */ interface OpenExternalProjectsArgs { /** * List of external projects to open or update */ projects: ExternalProject[]; } /** * Response to OpenExternalProjectRequest request. This is just an acknowledgement, so * no body field is required. */ interface OpenExternalProjectResponse extends Response { } /** * Response to OpenExternalProjectsRequest request. This is just an acknowledgement, so * no body field is required. */ interface OpenExternalProjectsResponse extends Response { } /** * Request to close external project. */ interface CloseExternalProjectRequest extends Request { command: CommandTypes.CloseExternalProject; arguments: CloseExternalProjectRequestArgs; } /** * Arguments to CloseExternalProjectRequest request */ interface CloseExternalProjectRequestArgs { /** * Name of the project to close */ projectFileName: string; } /** * Response to CloseExternalProjectRequest request. This is just an acknowledgement, so * no body field is required. */ interface CloseExternalProjectResponse extends Response { } /** * Request to set compiler options for inferred projects. * External projects are opened / closed explicitly. * Configured projects are opened when user opens loose file that has 'tsconfig.json' or 'jsconfig.json' anywhere in one of containing folders. * This configuration file will be used to obtain a list of files and configuration settings for the project. * Inferred projects are created when user opens a loose file that is not the part of external project * or configured project and will contain only open file and transitive closure of referenced files if 'useOneInferredProject' is false, * or all open loose files and its transitive closure of referenced files if 'useOneInferredProject' is true. */ interface SetCompilerOptionsForInferredProjectsRequest extends Request { command: CommandTypes.CompilerOptionsForInferredProjects; arguments: SetCompilerOptionsForInferredProjectsArgs; } /** * Argument for SetCompilerOptionsForInferredProjectsRequest request. */ interface SetCompilerOptionsForInferredProjectsArgs { /** * Compiler options to be used with inferred projects. */ options: ExternalProjectCompilerOptions; } /** * Response to SetCompilerOptionsForInferredProjectsResponse request. This is just an acknowledgement, so * no body field is required. */ interface SetCompilerOptionsForInferredProjectsResponse extends Response { } /** * Exit request; value of command field is "exit". Ask the server process * to exit. */ interface ExitRequest extends Request { command: CommandTypes.Exit; } /** * Close request; value of command field is "close". Notify the * server that the client has closed a previously open file. If * file is still referenced by open files, the server will resume * monitoring the filesystem for changes to file. Server does not * currently send a response to a close request. */ interface CloseRequest extends FileRequest { command: CommandTypes.Close; } /** * Request to obtain the list of files that should be regenerated if target file is recompiled. * NOTE: this us query-only operation and does not generate any output on disk. */ interface CompileOnSaveAffectedFileListRequest extends FileRequest { command: CommandTypes.CompileOnSaveAffectedFileList; } /** * Contains a list of files that should be regenerated in a project */ interface CompileOnSaveAffectedFileListSingleProject { /** * Project name */ projectFileName: string; /** * List of files names that should be recompiled */ fileNames: string[]; /** * true if project uses outFile or out compiler option */ projectUsesOutFile: boolean; } /** * Response for CompileOnSaveAffectedFileListRequest request; */ interface CompileOnSaveAffectedFileListResponse extends Response { body: CompileOnSaveAffectedFileListSingleProject[]; } /** * Request to recompile the file. All generated outputs (.js, .d.ts or .js.map files) is written on disk. */ interface CompileOnSaveEmitFileRequest extends FileRequest { command: CommandTypes.CompileOnSaveEmitFile; arguments: CompileOnSaveEmitFileRequestArgs; } /** * Arguments for CompileOnSaveEmitFileRequest */ interface CompileOnSaveEmitFileRequestArgs extends FileRequestArgs { /** * if true - then file should be recompiled even if it does not have any changes. */ forced?: boolean; } /** * Quickinfo request; value of command field is * "quickinfo". Return response giving a quick type and * documentation string for the symbol found in file at location * line, col. */ interface QuickInfoRequest extends FileLocationRequest { command: CommandTypes.Quickinfo; } /** * Body of QuickInfoResponse. */ interface QuickInfoResponseBody { /** * The symbol's kind (such as 'className' or 'parameterName' or plain 'text'). */ kind: ScriptElementKind; /** * Optional modifiers for the kind (such as 'public'). */ kindModifiers: string; /** * Starting file location of symbol. */ start: Location; /** * One past last character of symbol. */ end: Location; /** * Type and kind of symbol. */ displayString: string; /** * Documentation associated with symbol. */ documentation: string; /** * JSDoc tags associated with symbol. */ tags: JSDocTagInfo[]; } /** * Quickinfo response message. */ interface QuickInfoResponse extends Response { body?: QuickInfoResponseBody; } /** * Arguments for format messages. */ interface FormatRequestArgs extends FileLocationRequestArgs { /** * Last line of range for which to format text in file. */ endLine: number; /** * Character offset on last line of range for which to format text in file. */ endOffset: number; /** * Format options to be used. */ options?: FormatCodeSettings; } /** * Format request; value of command field is "format". Return * response giving zero or more edit instructions. The edit * instructions will be sorted in file order. Applying the edit * instructions in reverse to file will result in correctly * reformatted text. */ interface FormatRequest extends FileLocationRequest { command: CommandTypes.Format; arguments: FormatRequestArgs; } /** * Object found in response messages defining an editing * instruction for a span of text in source code. The effect of * this instruction is to replace the text starting at start and * ending one character before end with newText. For an insertion, * the text span is empty. For a deletion, newText is empty. */ interface CodeEdit { /** * First character of the text span to edit. */ start: Location; /** * One character past last character of the text span to edit. */ end: Location; /** * Replace the span defined above with this string (may be * the empty string). */ newText: string; } interface FileCodeEdits { fileName: string; textChanges: CodeEdit[]; } interface CodeFixResponse extends Response { /** The code actions that are available */ body?: CodeAction[]; } interface CodeAction { /** Description of the code action to display in the UI of the editor */ description: string; /** Text changes to apply to each file as part of the code action */ changes: FileCodeEdits[]; } /** * Format and format on key response message. */ interface FormatResponse extends Response { body?: CodeEdit[]; } /** * Arguments for format on key messages. */ interface FormatOnKeyRequestArgs extends FileLocationRequestArgs { /** * Key pressed (';', '\n', or '}'). */ key: string; options?: FormatCodeSettings; } /** * Format on key request; value of command field is * "formatonkey". Given file location and key typed (as string), * return response giving zero or more edit instructions. The * edit instructions will be sorted in file order. Applying the * edit instructions in reverse to file will result in correctly * reformatted text. */ interface FormatOnKeyRequest extends FileLocationRequest { command: CommandTypes.Formatonkey; arguments: FormatOnKeyRequestArgs; } /** * Arguments for completions messages. */ interface CompletionsRequestArgs extends FileLocationRequestArgs { /** * Optional prefix to apply to possible completions. */ prefix?: string; } /** * Completions request; value of command field is "completions". * Given a file location (file, line, col) and a prefix (which may * be the empty string), return the possible completions that * begin with prefix. */ interface CompletionsRequest extends FileLocationRequest { command: CommandTypes.Completions; arguments: CompletionsRequestArgs; } /** * Arguments for completion details request. */ interface CompletionDetailsRequestArgs extends FileLocationRequestArgs { /** * Names of one or more entries for which to obtain details. */ entryNames: string[]; } /** * Completion entry details request; value of command field is * "completionEntryDetails". Given a file location (file, line, * col) and an array of completion entry names return more * detailed information for each completion entry. */ interface CompletionDetailsRequest extends FileLocationRequest { command: CommandTypes.CompletionDetails; arguments: CompletionDetailsRequestArgs; } /** * Part of a symbol description. */ interface SymbolDisplayPart { /** * Text of an item describing the symbol. */ text: string; /** * The symbol's kind (such as 'className' or 'parameterName' or plain 'text'). */ kind: string; } /** * An item found in a completion response. */ interface CompletionEntry { /** * The symbol's name. */ name: string; /** * The symbol's kind (such as 'className' or 'parameterName'). */ kind: ScriptElementKind; /** * Optional modifiers for the kind (such as 'public'). */ kindModifiers: string; /** * A string that is used for comparing completion items so that they can be ordered. This * is often the same as the name but may be different in certain circumstances. */ sortText: string; /** * An optional span that indicates the text to be replaced by this completion item. If present, * this span should be used instead of the default one. */ replacementSpan?: TextSpan; } /** * Additional completion entry details, available on demand */ interface CompletionEntryDetails { /** * The symbol's name. */ name: string; /** * The symbol's kind (such as 'className' or 'parameterName'). */ kind: ScriptElementKind; /** * Optional modifiers for the kind (such as 'public'). */ kindModifiers: string; /** * Display parts of the symbol (similar to quick info). */ displayParts: SymbolDisplayPart[]; /** * Documentation strings for the symbol. */ documentation: SymbolDisplayPart[]; /** * JSDoc tags for the symbol. */ tags: JSDocTagInfo[]; } interface 词典完成请求参数 extends FileLocationRequestArgs { ignoreName: string; } interface 词典完成请求 extends FileLocationRequest { command: CommandTypes.词典自动完成; arguments: 词典完成请求参数; } interface 词典完成条目 { name: string; range: Range; isStringLiteral: boolean; rangeMap?: RangeMap; } interface Position { readonly line: number; readonly character: number; } interface Range { readonly start: Position; readonly end: Position; } interface 词典完成条目响应 extends Response { body?: 词典完成条目; } interface CompletionsResponse extends Response { body?: CompletionEntry[]; } interface CompletionDetailsResponse extends Response { body?: CompletionEntryDetails[]; } /** * Signature help information for a single parameter */ interface SignatureHelpParameter { /** * The parameter's name */ name: string; /** * Documentation of the parameter. */ documentation: SymbolDisplayPart[]; /** * Display parts of the parameter. */ displayParts: SymbolDisplayPart[]; /** * Whether the parameter is optional or not. */ isOptional: boolean; } /** * Represents a single signature to show in signature help. */ interface SignatureHelpItem { /** * Whether the signature accepts a variable number of arguments. */ isVariadic: boolean; /** * The prefix display parts. */ prefixDisplayParts: SymbolDisplayPart[]; /** * The suffix display parts. */ suffixDisplayParts: SymbolDisplayPart[]; /** * The separator display parts. */ separatorDisplayParts: SymbolDisplayPart[]; /** * The signature helps items for the parameters. */ parameters: SignatureHelpParameter[]; /** * The signature's documentation */ documentation: SymbolDisplayPart[]; /** * The signature's JSDoc tags */ tags: JSDocTagInfo[]; } /** * Signature help items found in the response of a signature help request. */ interface SignatureHelpItems { /** * The signature help items. */ items: SignatureHelpItem[]; /** * The span for which signature help should appear on a signature */ applicableSpan: TextSpan; /** * The item selected in the set of available help items. */ selectedItemIndex: number; /** * The argument selected in the set of parameters. */ argumentIndex: number; /** * The argument count */ argumentCount: number; } /** * Arguments of a signature help request. */ interface SignatureHelpRequestArgs extends FileLocationRequestArgs { } /** * Signature help request; value of command field is "signatureHelp". * Given a file location (file, line, col), return the signature * help. */ interface SignatureHelpRequest extends FileLocationRequest { command: CommandTypes.SignatureHelp; arguments: SignatureHelpRequestArgs; } /** * Response object for a SignatureHelpRequest. */ interface SignatureHelpResponse extends Response { body?: SignatureHelpItems; } /** * Synchronous request for semantic diagnostics of one file. */ interface SemanticDiagnosticsSyncRequest extends FileRequest { command: CommandTypes.SemanticDiagnosticsSync; arguments: SemanticDiagnosticsSyncRequestArgs; } interface SemanticDiagnosticsSyncRequestArgs extends FileRequestArgs { includeLinePosition?: boolean; } /** * Response object for synchronous sematic diagnostics request. */ interface SemanticDiagnosticsSyncResponse extends Response { body?: Diagnostic[] | DiagnosticWithLinePosition[]; } /** * Synchronous request for syntactic diagnostics of one file. */ interface SyntacticDiagnosticsSyncRequest extends FileRequest { command: CommandTypes.SyntacticDiagnosticsSync; arguments: SyntacticDiagnosticsSyncRequestArgs; } interface SyntacticDiagnosticsSyncRequestArgs extends FileRequestArgs { includeLinePosition?: boolean; } /** * Response object for synchronous syntactic diagnostics request. */ interface SyntacticDiagnosticsSyncResponse extends Response { body?: Diagnostic[] | DiagnosticWithLinePosition[]; } /** * Arguments for GeterrForProject request. */ interface GeterrForProjectRequestArgs { /** * the file requesting project error list */ file: string; /** * Delay in milliseconds to wait before starting to compute * errors for the files in the file list */ delay: number; } /** * GeterrForProjectRequest request; value of command field is * "geterrForProject". It works similarly with 'Geterr', only * it request for every file in this project. */ interface GeterrForProjectRequest extends Request { command: CommandTypes.GeterrForProject; arguments: GeterrForProjectRequestArgs; } /** * Arguments for geterr messages. */ interface GeterrRequestArgs { /** * List of file names for which to compute compiler errors. * The files will be checked in list order. */ files: string[]; /** * Delay in milliseconds to wait before starting to compute * errors for the files in the file list */ delay: number; } /** * Geterr request; value of command field is "geterr". Wait for * delay milliseconds and then, if during the wait no change or * reload messages have arrived for the first file in the files * list, get the syntactic errors for the file, field requests, * and then get the semantic errors for the file. Repeat with a * smaller delay for each subsequent file on the files list. Best * practice for an editor is to send a file list containing each * file that is currently visible, in most-recently-used order. */ interface GeterrRequest extends Request { command: CommandTypes.Geterr; arguments: GeterrRequestArgs; } type RequestCompletedEventName = "requestCompleted"; /** * Event that is sent when server have finished processing request with specified id. */ interface RequestCompletedEvent extends Event { event: RequestCompletedEventName; body: RequestCompletedEventBody; } interface RequestCompletedEventBody { request_seq: number; } /** * Item of diagnostic information found in a DiagnosticEvent message. */ interface Diagnostic { /** * Starting file location at which text applies. */ start: Location; /** * The last file location at which the text applies. */ end: Location; /** * Text of diagnostic message. */ text: string; /** * The category of the diagnostic message, e.g. "error" vs. "warning" */ category: string; /** * The error code of the diagnostic message. */ code?: number; /** * The name of the plugin reporting the message. */ source?: string; } interface DiagnosticWithFileName extends Diagnostic { /** * Name of the file the diagnostic is in */ fileName: string; } interface DiagnosticEventBody { /** * The file for which diagnostic information is reported. */ file: string; /** * An array of diagnostic information items. */ diagnostics: Diagnostic[]; } /** * Event message for "syntaxDiag" and "semanticDiag" event types. * These events provide syntactic and semantic errors for a file. */ interface DiagnosticEvent extends Event { body?: DiagnosticEventBody; } interface ConfigFileDiagnosticEventBody { /** * The file which trigged the searching and error-checking of the config file */ triggerFile: string; /** * The name of the found config file. */ configFile: string; /** * An arry of diagnostic information items for the found config file. */ diagnostics: DiagnosticWithFileName[]; } /** * Event message for "configFileDiag" event type. * This event provides errors for a found config file. */ interface ConfigFileDiagnosticEvent extends Event { body?: ConfigFileDiagnosticEventBody; event: "configFileDiag"; } type ProjectLanguageServiceStateEventName = "projectLanguageServiceState"; interface ProjectLanguageServiceStateEvent extends Event { event: ProjectLanguageServiceStateEventName; body?: ProjectLanguageServiceStateEventBody; } interface ProjectLanguageServiceStateEventBody { /** * Project name that has changes in the state of language service. * For configured projects this will be the config file path. * For external projects this will be the name of the projects specified when project was open. * For inferred projects this event is not raised. */ projectName: string; /** * True if language service state switched from disabled to enabled * and false otherwise. */ languageServiceEnabled: boolean; } /** * Arguments for reload request. */ interface ReloadRequestArgs extends FileRequestArgs { /** * Name of temporary file from which to reload file * contents. May be same as file. */ tmpfile: string; } /** * Reload request message; value of command field is "reload". * Reload contents of file with name given by the 'file' argument * from temporary file with name given by the 'tmpfile' argument. * The two names can be identical. */ interface ReloadRequest extends FileRequest { command: CommandTypes.Reload; arguments: ReloadRequestArgs; } /** * Response to "reload" request. This is just an acknowledgement, so * no body field is required. */ interface ReloadResponse extends Response { } /** * Arguments for saveto request. */ interface SavetoRequestArgs extends FileRequestArgs { /** * Name of temporary file into which to save server's view of * file contents. */ tmpfile: string; } /** * Saveto request message; value of command field is "saveto". * For debugging purposes, save to a temporaryfile (named by * argument 'tmpfile') the contents of file named by argument * 'file'. The server does not currently send a response to a * "saveto" request. */ interface SavetoRequest extends FileRequest { command: CommandTypes.Saveto; arguments: SavetoRequestArgs; } /** * Arguments for navto request message. */ interface NavtoRequestArgs extends FileRequestArgs { /** * Search term to navigate to from current location; term can * be '.*' or an identifier prefix. */ searchValue: string; /** * Optional limit on the number of items to return. */ maxResultCount?: number; /** * Optional flag to indicate we want results for just the current file * or the entire project. */ currentFileOnly?: boolean; projectFileName?: string; } /** * Navto request message; value of command field is "navto". * Return list of objects giving file locations and symbols that * match the search term given in argument 'searchTerm'. The * context for the search is given by the named file. */ interface NavtoRequest extends FileRequest { command: CommandTypes.Navto; arguments: NavtoRequestArgs; } /** * An item found in a navto response. */ interface NavtoItem { /** * The symbol's name. */ name: string; /** * The symbol's kind (such as 'className' or 'parameterName'). */ kind: ScriptElementKind; /** * exact, substring, or prefix. */ matchKind?: string; /** * If this was a case sensitive or insensitive match. */ isCaseSensitive?: boolean; /** * Optional modifiers for the kind (such as 'public'). */ kindModifiers?: string; /** * The file in which the symbol is found. */ file: string; /** * The location within file at which the symbol is found. */ start: Location; /** * One past the last character of the symbol. */ end: Location; /** * Name of symbol's container symbol (if any); for example, * the class name if symbol is a class member. */ containerName?: string; /** * Kind of symbol's container symbol (if any). */ containerKind?: ScriptElementKind; } /** * Navto response message. Body is an array of navto items. Each * item gives a symbol that matched the search term. */ interface NavtoResponse extends Response { body?: NavtoItem[]; } /** * Arguments for change request message. */ interface ChangeRequestArgs extends FormatRequestArgs { /** * Optional string to insert at location (file, line, offset). */ insertString?: string; } /** * Change request message; value of command field is "change". * Update the server's view of the file named by argument 'file'. * Server does not currently send a response to a change request. */ interface ChangeRequest extends FileLocationRequest { command: CommandTypes.Change; arguments: ChangeRequestArgs; } /** * Response to "brace" request. */ interface BraceResponse extends Response { body?: TextSpan[]; } /** * Brace matching request; value of command field is "brace". * Return response giving the file locations of matching braces * found in file at location line, offset. */ interface BraceRequest extends FileLocationRequest { command: CommandTypes.Brace; } /** * NavBar items request; value of command field is "navbar". * Return response giving the list of navigation bar entries * extracted from the requested file. */ interface NavBarRequest extends FileRequest { command: CommandTypes.NavBar; } /** * NavTree request; value of command field is "navtree". * Return response giving the navigation tree of the requested file. */ interface NavTreeRequest extends FileRequest { command: CommandTypes.NavTree; } interface NavigationBarItem { /** * The item's display text. */ text: string; /** * The symbol's kind (such as 'className' or 'parameterName'). */ kind: ScriptElementKind; /** * Optional modifiers for the kind (such as 'public'). */ kindModifiers?: string; /** * The definition locations of the item. */ spans: TextSpan[]; /** * Optional children. */ childItems?: NavigationBarItem[]; /** * Number of levels deep this item should appear. */ indent: number; } /** protocol.NavigationTree is identical to ts.NavigationTree, except using protocol.TextSpan instead of ts.TextSpan */ interface NavigationTree { text: string; kind: ScriptElementKind; kindModifiers: string; spans: TextSpan[]; childItems?: NavigationTree[]; } type TelemetryEventName = "telemetry"; interface TelemetryEvent extends Event { event: TelemetryEventName; body: TelemetryEventBody; } interface TelemetryEventBody { telemetryEventName: string; payload: any; } type TypesInstallerInitializationFailedEventName = "typesInstallerInitializationFailed"; interface TypesInstallerInitializationFailedEvent extends Event { event: TypesInstallerInitializationFailedEventName; body: TypesInstallerInitializationFailedEventBody; } interface TypesInstallerInitializationFailedEventBody { message: string; } type TypingsInstalledTelemetryEventName = "typingsInstalled"; interface TypingsInstalledTelemetryEventBody extends TelemetryEventBody { telemetryEventName: TypingsInstalledTelemetryEventName; payload: TypingsInstalledTelemetryEventPayload; } interface TypingsInstalledTelemetryEventPayload { /** * Comma separated list of installed typing packages */ installedPackages: string; /** * true if install request succeeded, otherwise - false */ installSuccess: boolean; /** * version of typings installer */ typingsInstallerVersion: string; } type BeginInstallTypesEventName = "beginInstallTypes"; type EndInstallTypesEventName = "endInstallTypes"; interface BeginInstallTypesEvent extends Event { event: BeginInstallTypesEventName; body: BeginInstallTypesEventBody; } interface EndInstallTypesEvent extends Event { event: EndInstallTypesEventName; body: EndInstallTypesEventBody; } interface InstallTypesEventBody { /** * correlation id to match begin and end events */ eventId: number; /** * list of packages to install */ packages: ReadonlyArray; } interface BeginInstallTypesEventBody extends InstallTypesEventBody { } interface EndInstallTypesEventBody extends InstallTypesEventBody { /** * true if installation succeeded, otherwise false */ success: boolean; } interface NavBarResponse extends Response { body?: NavigationBarItem[]; } interface NavTreeResponse extends Response { body?: NavigationTree; } const enum IndentStyle { None = "None", Block = "Block", Smart = "Smart", } interface EditorSettings { baseIndentSize?: number; indentSize?: number; tabSize?: number; newLineCharacter?: string; convertTabsToSpaces?: boolean; indentStyle?: IndentStyle | ts.IndentStyle; } interface FormatCodeSettings extends EditorSettings { insertSpaceAfterCommaDelimiter?: boolean; insertSpaceAfterSemicolonInForStatements?: boolean; insertSpaceBeforeAndAfterBinaryOperators?: boolean; insertSpaceAfterConstructor?: boolean; insertSpaceAfterKeywordsInControlFlowStatements?: boolean; insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean; insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean; insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean; insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean; insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean; insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean; insertSpaceAfterTypeAssertion?: boolean; insertSpaceBeforeFunctionParenthesis?: boolean; placeOpenBraceOnNewLineForFunctions?: boolean; placeOpenBraceOnNewLineForControlBlocks?: boolean; } interface CompilerOptions { allowJs?: boolean; allowSyntheticDefaultImports?: boolean; allowUnreachableCode?: boolean; allowUnusedLabels?: boolean; alwaysStrict?: boolean; baseUrl?: string; charset?: string; checkJs?: boolean; declaration?: boolean; declarationDir?: string; disableSizeLimit?: boolean; downlevelIteration?: boolean; emitBOM?: boolean; emitDecoratorMetadata?: boolean; experimentalDecorators?: boolean; forceConsistentCasingInFileNames?: boolean; importHelpers?: boolean; inlineSourceMap?: boolean; inlineSources?: boolean; isolatedModules?: boolean; jsx?: JsxEmit | ts.JsxEmit; lib?: string[]; locale?: string; mapRoot?: string; maxNodeModuleJsDepth?: number; module?: ModuleKind | ts.ModuleKind; moduleResolution?: ModuleResolutionKind | ts.ModuleResolutionKind; newLine?: NewLineKind | ts.NewLineKind; noEmit?: boolean; noEmitHelpers?: boolean; noEmitOnError?: boolean; noErrorTruncation?: boolean; noFallthroughCasesInSwitch?: boolean; noImplicitAny?: boolean; noImplicitReturns?: boolean; noImplicitThis?: boolean; noUnusedLocals?: boolean; noUnusedParameters?: boolean; noImplicitUseStrict?: boolean; noLib?: boolean; noResolve?: boolean; out?: string; outDir?: string; outFile?: string; paths?: MapLike; plugins?: PluginImport[]; preserveConstEnums?: boolean; project?: string; reactNamespace?: string; removeComments?: boolean; rootDir?: string; rootDirs?: string[]; skipLibCheck?: boolean; skipDefaultLibCheck?: boolean; sourceMap?: boolean; sourceRoot?: string; strict?: boolean; strictNullChecks?: boolean; suppressExcessPropertyErrors?: boolean; suppressImplicitAnyIndexErrors?: boolean; target?: ScriptTarget | ts.ScriptTarget; traceResolution?: boolean; types?: string[]; /** Paths used to used to compute primary types search locations */ typeRoots?: string[]; [option: string]: CompilerOptionsValue | undefined; } const enum JsxEmit { None = "None", Preserve = "Preserve", ReactNative = "ReactNative", React = "React", } const enum ModuleKind { None = "None", CommonJS = "CommonJS", AMD = "AMD", UMD = "UMD", System = "System", ES6 = "ES6", ES2015 = "ES2015", } const enum ModuleResolutionKind { Classic = "Classic", Node = "Node", } const enum NewLineKind { Crlf = "Crlf", Lf = "Lf", } const enum ScriptTarget { ES3 = "ES3", ES5 = "ES5", ES6 = "ES6", ES2015 = "ES2015", } } declare namespace ts.server { interface ServerCancellationToken extends HostCancellationToken { setRequest(requestId: number): void; resetRequest(requestId: number): void; } const nullCancellationToken: ServerCancellationToken; interface PendingErrorCheck { fileName: NormalizedPath; project: Project; } interface EventSender { event(payload: T, eventName: string): void; } type CommandNames = protocol.CommandTypes; const CommandNames: 通用型; function formatMessage(msg: T, logger: server.Logger, byteLength: (s: string, encoding: string) => number, newLine: string): string; interface SessionOptions { host: ServerHost; cancellationToken: ServerCancellationToken; useSingleInferredProject: boolean; typingsInstaller: ITypingsInstaller; byteLength: (buf: string, encoding?: string) => number; hrtime: (start?: number[]) => number[]; logger: Logger; canUseEvents: boolean; eventHandler?: ProjectServiceEventHandler; throttleWaitMilliseconds?: number; globalPlugins?: string[]; pluginProbeLocations?: string[]; allowLocalPluginLoads?: boolean; } class Session implements EventSender { private readonly gcTimer; protected projectService: ProjectService; private changeSeq; private currentRequestId; private errorCheck; private eventHandler; private host; private readonly cancellationToken; protected readonly typingsInstaller: ITypingsInstaller; private byteLength; private hrtime; protected logger: Logger; private canUseEvents; constructor(opts: SessionOptions); private sendRequestCompletedEvent(requestId); private defaultEventHandler(event); logError(err: Error, cmd: string): 无值; send(msg: protocol.Message): 无值; configFileDiagnosticEvent(triggerFile: string, configFile: string, diagnostics: Diagnostic[]): 无值; event(info: T, eventName: string): 无值; output(info: any, cmdName: string, reqSeq?: 数字, errorMsg?: string): 无值; private semanticCheck(file, project); private syntacticCheck(file, project); private updateProjectStructure(seq, matchSeq, ms?); private updateErrorCheck(next, checkList, seq, matchSeq, ms?, followMs?, requireOpen?); private cleanProjects(caption, projects); private cleanup(); private getEncodedSemanticClassifications(args); private getProject(projectFileName); private getConfigFileAndProject(args); private getConfigFileDiagnostics(configFile, project, includeLinePosition); private convertToDiagnosticsWithLinePositionFromDiagnosticFile(diagnostics); private getCompilerOptionsDiagnostics(args); private convertToDiagnosticsWithLinePosition(diagnostics, scriptInfo); private getDiagnosticsWorker(args, isSemantic, selector, includeLinePosition); private getDefinition(args, simplifiedResult); private getTypeDefinition(args); private getImplementation(args, simplifiedResult); private getOccurrences(args); private getSyntacticDiagnosticsSync(args); private getSemanticDiagnosticsSync(args); private getDocumentHighlights(args, simplifiedResult); private setCompilerOptionsForInferredProjects(args); private getProjectInfo(args); private getProjectInfoWorker(uncheckedFileName, projectFileName, needFileNameList, excludeConfigFiles); private getRenameInfo(args); private getProjects(args); private getDefaultProject(args); private getRenameLocations(args, simplifiedResult); private getReferences(args, simplifiedResult); /** * @param fileName is the name of the file to be opened * @param fileContent is a version of the file content that is known to be more up to date than the one on disk */ private openClientFile(fileName, fileContent?, scriptKind?, projectRootPath?); private getPosition(args, scriptInfo); private getFileAndProject(args, errorOnMissingProject?); private getFileAndProjectWithoutRefreshingInferredProjects(args, errorOnMissingProject?); private getFileAndProjectWorker(uncheckedFileName, projectFileName, refreshInferredProjects, errorOnMissingProject); private getOutliningSpans(args); private getTodoComments(args); private getDocCommentTemplate(args); private getIndentation(args); private getBreakpointStatement(args); private getNameOrDottedNameSpan(args); private isValidBraceCompletion(args); private getQuickInfoWorker(args, simplifiedResult); private getFormattingEditsForRange(args); private getFormattingEditsForRangeFull(args); private getFormattingEditsForDocumentFull(args); private getFormattingEditsAfterKeystrokeFull(args); private getFormattingEditsAfterKeystroke(args); private getCompletions(args, simplifiedResult); private getCompletionEntryDetails(args); private 取词典自动完成项目(args); private getCompileOnSaveAffectedFileList(args); private emitFile(args); private getSignatureHelpItems(args, simplifiedResult); private getDiagnostics(next, delay, fileNames); private change(args); private reload(args, reqSeq); private saveToTmp(fileName, tempFileName); private closeClientFile(fileName); private decorateNavigationBarItems(items, scriptInfo); private getNavigationBarItems(args, simplifiedResult); private decorateNavigationTree(tree, scriptInfo); private decorateSpan(span, scriptInfo); private getNavigationTree(args, simplifiedResult); private getNavigateToItems(args, simplifiedResult); private getSupportedCodeFixes(); private isLocation(locationOrSpan); private extractPositionAndRange(args, scriptInfo); private getApplicableRefactors(args); private getEditsForRefactor(args, simplifiedResult); private getCodeFixes(args, simplifiedResult); private getStartAndEndPosition(args, scriptInfo); private mapCodeAction(codeAction, scriptInfo); private mapTextChangesToCodeEdits(project, textChanges); private convertTextChangeToCodeEdit(change, scriptInfo); private getBraceMatching(args, simplifiedResult); private getDiagnosticsForProject(next, delay, fileName); getCanonicalFileName(fileName: string): 文字; exit(): 无值; private notRequired(); private requiredResponse(response); private handlers; addProtocolHandler(command: string, handler: (request: protocol.Request) => { response?: any; responseRequired: boolean; }): 无值; private setCurrentRequest(requestId); private resetCurrentRequest(requestId); executeWithRequestId(requestId: number, f: () => T): T; executeCommand(request: protocol.Request): { response?: any; responseRequired?: boolean; }; onMessage(message: string): 无值; } } declare namespace ts.server { interface LineCollection { charCount(): number; lineCount(): number; isLeaf(): this is LineLeaf; walk(rangeStart: number, rangeLength: number, walkFns: ILineIndexWalker): void; } interface AbsolutePositionAndLineText { absolutePosition: number; lineText: string | undefined; } enum CharRangeSection { PreStart = 0, Start = 1, Entire = 2, Mid = 3, End = 4, PostEnd = 5, } interface ILineIndexWalker { goSubtree: boolean; done: boolean; leaf(relativeStart: number, relativeLength: number, lineCollection: LineLeaf): void; pre?(relativeStart: number, relativeLength: number, lineCollection: LineCollection, parent: LineNode, nodeType: CharRangeSection): void; post?(relativeStart: number, relativeLength: number, lineCollection: LineCollection, parent: LineNode, nodeType: CharRangeSection): void; } class TextChange { pos: number; deleteLen: number; insertedText: string; constructor(pos: number, deleteLen: number, insertedText?: string); getTextChangeRange(): TextChangeRange; } class ScriptVersionCache { private changes; private readonly versions; private minVersion; private currentVersion; private static readonly changeNumberThreshold; private static readonly changeLengthThreshold; private static readonly maxVersions; private versionToIndex(version); private currentVersionToIndex(); edit(pos: number, deleteLen: number, insertedText?: string): 无值; latest(): LineIndexSnapshot; latestVersion(): 数字; reload(script: string): 无值; getSnapshot(): LineIndexSnapshot; getTextChangesBetweenVersions(oldVersion: number, newVersion: number): TextChangeRange; static fromString(script: string): ScriptVersionCache; } class LineIndexSnapshot implements IScriptSnapshot { readonly version: number; readonly cache: ScriptVersionCache; readonly index: LineIndex; readonly changesSincePreviousVersion: ReadonlyArray; constructor(version: number, cache: ScriptVersionCache, index: LineIndex, changesSincePreviousVersion?: ReadonlyArray); getText(rangeStart: number, rangeEnd: number): 文字; getLength(): 数字; getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange; } class LineIndex { root: LineNode; checkEdits: 真假; absolutePositionOfStartOfLine(oneBasedLine: number): number; positionToLineOffset(position: number): protocol.Location; private positionToColumnAndLineText(position); lineNumberToInfo(oneBasedLine: number): AbsolutePositionAndLineText; load(lines: string[]): 无值; walk(rangeStart: number, rangeLength: number, walkFns: ILineIndexWalker): 无值; getText(rangeStart: number, rangeLength: number): 文字; getLength(): number; every(f: (ll: LineLeaf, s: number, len: number) => boolean, rangeStart: number, rangeEnd?: number): 真假; edit(pos: number, deleteLength: number, newText?: string): LineIndex; private static buildTreeFromBottom(nodes); static linesFromText(text: string): { lines: 文字[]; lineMap: 数字[]; }; } class LineNode implements LineCollection { private readonly children; totalChars: 数字; totalLines: 数字; constructor(children?: LineCollection[]); isLeaf(): 真假; updateCounts(): 无值; private execWalk(rangeStart, rangeLength, walkFns, childIndex, nodeType); private skipChild(relativeStart, relativeLength, childIndex, walkFns, nodeType); walk(rangeStart: number, rangeLength: number, walkFns: ILineIndexWalker): 无值; charOffsetToLineInfo(lineNumberAccumulator: number, relativePosition: number): { oneBasedLine: number; zeroBasedColumn: number; lineText: string | undefined; }; lineNumberToInfo(relativeOneBasedLine: number, positionAccumulator: number): { position: number; leaf: LineLeaf | undefined; }; /** * Input line number is relative to the start of this node. * Output line number is relative to the child. * positionAccumulator will be an absolute position once relativeLineNumber reaches 0. */ private childFromLineNumber(relativeOneBasedLine, positionAccumulator); private childFromCharOffset(lineNumberAccumulator, relativePosition); private splitAfter(childIndex); remove(child: LineCollection): 无值; private findChildIndex(child); insertAt(child: LineCollection, nodes: LineCollection[]): LineNode[]; add(collection: LineCollection): void; charCount(): 数字; lineCount(): 数字; } class LineLeaf implements LineCollection { text: string; constructor(text: string); isLeaf(): 真假; walk(rangeStart: number, rangeLength: number, walkFns: ILineIndexWalker): 无值; charCount(): 数字; lineCount(): 数字; } } declare namespace ts.server { class ScriptInfo { private readonly host; readonly fileName: NormalizedPath; readonly scriptKind: ScriptKind; hasMixedContent: 真假; /** * All projects that include this file */ readonly containingProjects: Project[]; private formatCodeSettings; readonly path: Path; private fileWatcher; private textStorage; private isOpen; constructor(host: ServerHost, fileName: NormalizedPath, scriptKind: ScriptKind, hasMixedContent?: 真假); isScriptOpen(): 真假; open(newText: string): 无值; close(): 无值; getSnapshot(): IScriptSnapshot; getFormatCodeSettings(): FormatCodeSettings; attachToProject(project: Project): boolean; isAttached(project: Project): 真假; detachFromProject(project: Project): 无值; detachAllProjects(): 无值; getDefaultProject(): Project; registerFileUpdate(): void; setFormatOptions(formatSettings: FormatCodeSettings): void; setWatcher(watcher: FileWatcher): void; stopWatcher(): 无值; getLatestVersion(): 文字; reload(script: string): 无值; saveTo(fileName: string): 无值; reloadFromFile(tempFileName?: NormalizedPath): 无值; getLineInfo(line: number): AbsolutePositionAndLineText; editContent(start: number, end: number, newText: string): void; markContainingProjectsAsDirty(): 无值; /** * @param line 1 based index */ lineToTextSpan(line: number): TextSpan; /** * @param line 1 based index * @param offset 1 based index */ lineOffsetToPosition(line: number, offset: number): number; positionToLineOffset(position: number): protocol.Location; isJavaScript(): 真假; } } declare namespace ts.server { class LSHost implements LanguageServiceHost, ModuleResolutionHost { private readonly host; private project; private readonly cancellationToken; private compilationSettings; private readonly resolvedModuleNames; private readonly resolvedTypeReferenceDirectives; private readonly getCanonicalFileName; private filesWithChangedSetOfUnresolvedImports; private resolveModuleName; readonly trace: (s: string) => void; readonly realpath?: (path: string) => string; constructor(host: ServerHost, project: Project, cancellationToken: HostCancellationToken); dispose(): 无值; startRecordingFilesWithChangedResolutions(): 无值; finishRecordingFilesWithChangedResolutions(): Path[]; private resolveNamesWithLocalCache(names, containingFile, cache, loader, getResult, getResultFileName, logChanges); getNewLine(): 文字; getProjectVersion(): 文字; getCompilationSettings(): CompilerOptions; useCaseSensitiveFileNames(): 真假; getCancellationToken(): HostCancellationToken; resolveTypeReferenceDirectives(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[]; resolveModuleNames(moduleNames: string[], containingFile: string): ResolvedModuleFull[]; getDefaultLibFileName(): 文字; getScriptSnapshot(filename: string): IScriptSnapshot; getScriptFileNames(): 文字[]; getTypeRootsVersion(): 数字; getScriptKind(fileName: string): ScriptKind; getScriptVersion(filename: string): 文字; getCurrentDirectory(): string; resolvePath(path: string): string; fileExists(file: string): boolean; readFile(fileName: string): string | undefined; directoryExists(path: string): boolean; readDirectory(path: string, extensions?: ReadonlyArray, exclude?: ReadonlyArray, include?: ReadonlyArray, depth?: number): string[]; getDirectories(path: string): string[]; notifyFileRemoved(info: ScriptInfo): 无值; setCompilationSettings(opt: CompilerOptions): 无值; } } declare namespace ts.server { interface ITypingsInstaller { enqueueInstallTypingsRequest(p: Project, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray): void; attach(projectService: ProjectService): void; onProjectClosed(p: Project): void; readonly globalTypingsCacheLocation: string; } const nullTypingsInstaller: ITypingsInstaller; class TypingsCache { private readonly installer; private readonly perProjectCache; constructor(installer: ITypingsInstaller); getTypingsForProject(project: Project, unresolvedImports: SortedReadonlyArray, forceRefresh: boolean): SortedReadonlyArray; updateTypingsForProject(projectName: string, compilerOptions: CompilerOptions, typeAcquisition: TypeAcquisition, unresolvedImports: SortedReadonlyArray, newTypings: string[]): 无值; deleteTypingsForProject(projectName: string): 无值; onProjectClosed(project: Project): 无值; } } declare namespace ts.server { function shouldEmitFile(scriptInfo: ScriptInfo): 真假; /** * An abstract file info that maintains a shape signature. */ class BuilderFileInfo { readonly scriptInfo: ScriptInfo; readonly project: Project; private lastCheckedShapeSignature; constructor(scriptInfo: ScriptInfo, project: Project); isExternalModuleOrHasOnlyAmbientExternalModules(): 真假; /** * For script files that contains only ambient external modules, although they are not actually external module files, * they can only be consumed via importing elements from them. Regular script files cannot consume them. Therefore, * there are no point to rebuild all script files if these special files have changed. However, if any statement * in the file is not ambient external module, we treat it as a regular script file. */ private containsOnlyAmbientModules(sourceFile); private computeHash(text); private getSourceFile(); /** * @return {boolean} indicates if the shape signature has changed since last update. */ updateShapeSignature(): 真假; } interface Builder { readonly project: Project; getFilesAffectedBy(scriptInfo: ScriptInfo): string[]; onProjectUpdateGraph(): void; emitFile(scriptInfo: ScriptInfo, writeFile: (path: string, data: string, writeByteOrderMark?: boolean) => void): boolean; clear(): void; } function createBuilder(project: Project): Builder; } declare namespace ts.server { enum ProjectKind { Inferred = 0, Configured = 1, External = 2, } function allRootFilesAreJsOrDts(project: Project): boolean; function allFilesAreJsOrDts(project: Project): boolean; class UnresolvedImportsMap { readonly perFileMap: Map>; private version; clear(): 无值; getVersion(): 数字; remove(path: Path): 无值; get(path: Path): ReadonlyArray<文字>; set(path: Path, value: ReadonlyArray): 无值; } interface PluginCreateInfo { project: Project; languageService: LanguageService; languageServiceHost: LanguageServiceHost; serverHost: ServerHost; config: any; } interface PluginModule { create(createInfo: PluginCreateInfo): LanguageService; getExternalFiles?(proj: Project): string[]; } interface PluginModuleFactory { (mod: { typescript: typeof ts; }): PluginModule; } abstract class Project { private readonly projectName; readonly projectKind: ProjectKind; readonly projectService: ProjectService; private documentRegistry; private compilerOptions; compileOnSaveEnabled: boolean; private rootFiles; private rootFilesMap; private program; private externalFiles; private missingFilesMap; private cachedUnresolvedImportsPerFile; private lastCachedUnresolvedImportsList; protected languageService: LanguageService; languageServiceEnabled: 真假; protected lsHost: LSHost; builder: Builder; /** * Set of files names that were updated since the last call to getChangesSinceVersion. */ private updatedFileNames; /** * Set of files that was returned from the last call to getChangesSinceVersion. */ private lastReportedFileNames; /** * Last version that was reported. */ private lastReportedVersion; /** * Current project structure version. * This property is changed in 'updateGraph' based on the set of files in program */ private projectStructureVersion; /** * Current version of the project state. It is changed when: * - new root file was added/removed * - edit happen in some file that is currently included in the project. * This property is different from projectStructureVersion since in most cases edits don't affect set of files in the project */ private projectStateVersion; private typingFiles; protected projectErrors: Diagnostic[]; typesVersion: 数字; isNonTsProject(): 真假; isJsOnlyProject(): 真假; getCachedUnresolvedImportsPerFile_TestOnly(): UnresolvedImportsMap; static resolveModule(moduleName: string, initialDir: string, host: ServerHost, log: (message: string) => void): {}; constructor(projectName: string, projectKind: ProjectKind, projectService: ProjectService, documentRegistry: DocumentRegistry, hasExplicitListOfFiles: boolean, languageServiceEnabled: boolean, compilerOptions: CompilerOptions, compileOnSaveEnabled: boolean); private setInternalCompilerOptionsForEmittingJsFiles(); /** * Get the errors that dont have any file name associated */ getGlobalProjectErrors(): Diagnostic[]; getAllProjectErrors(): Diagnostic[]; getLanguageService(ensureSynchronized?: 真假): LanguageService; getCompileOnSaveAffectedFileList(scriptInfo: ScriptInfo): string[]; getProjectVersion(): 文字; enableLanguageService(): 无值; disableLanguageService(): 无值; getProjectName(): 文字; abstract getProjectRootPath(): string | undefined; abstract getTypeAcquisition(): TypeAcquisition; getExternalFiles(): SortedReadonlyArray; getSourceFile(path: Path): SourceFile; updateTypes(): 无值; close(): 无值; getCompilerOptions(): CompilerOptions; hasRoots(): 真假; getRootFiles(): NormalizedPath[]; getRootFilesLSHost(): 文字[]; getRootScriptInfos(): ScriptInfo[]; getScriptInfos(): ScriptInfo[]; getFileEmitOutput(info: ScriptInfo, emitOnlyDtsFiles: boolean): EmitOutput; getFileNames(excludeFilesFromExternalLibraries?: boolean, excludeConfigFiles?: boolean): NormalizedPath[]; hasConfigFile(configFilePath: NormalizedPath): 真假; getAllEmittableFiles(): 文字[]; containsScriptInfo(info: ScriptInfo): boolean; containsFile(filename: NormalizedPath, requireOpen?: boolean): 真假; isRoot(info: ScriptInfo): 真假; addRoot(info: ScriptInfo): 无值; removeFile(info: ScriptInfo, detachFromProject?: 真假): 无值; registerFileUpdate(fileName: string): 无值; markAsDirty(): 无值; private extractUnresolvedImportsFromSourceFile(file, result); /** * Updates set of files that contribute to this project * @returns: true if set of files in the project stays the same and false - otherwise. */ updateGraph(): boolean; private setTypings(typings); private updateGraphWorker(); isWatchedMissingFile(path: Path): 真假; getScriptInfoLSHost(fileName: string): ScriptInfo; getScriptInfoForNormalizedPath(fileName: NormalizedPath): ScriptInfo; getScriptInfo(uncheckedFileName: string): ScriptInfo; filesToString(): 文字; setCompilerOptions(compilerOptions: CompilerOptions): 无值; reloadScript(filename: NormalizedPath, tempFileName?: NormalizedPath): boolean; getReferencedFiles(path: Path): Path[]; protected removeRoot(info: ScriptInfo): void; } /** * If a file is opened and no tsconfig (or jsconfig) is found, * the file and its imports/references are put into an InferredProject. */ class InferredProject extends Project { private static newName; private _isJsInferredProject; toggleJsInferredProject(isJsInferredProject: boolean): 无值; setCompilerOptions(options?: CompilerOptions): 无值; directoriesWatchedForTsconfig: string[]; constructor(projectService: ProjectService, documentRegistry: DocumentRegistry, compilerOptions: CompilerOptions); addRoot(info: ScriptInfo): 无值; removeRoot(info: ScriptInfo): 无值; getProjectRootPath(): 文字; close(): 无值; getTypeAcquisition(): TypeAcquisition; } /** * If a file is opened, the server will look for a tsconfig (or jsconfig) * and if successfull create a ConfiguredProject for it. * Otherwise it will create an InferredProject. */ class ConfiguredProject extends Project { private wildcardDirectories; compileOnSaveEnabled: boolean; private typeAcquisition; private projectFileWatcher; private directoryWatcher; private directoriesWatchedForWildcards; private typeRootsWatchers; readonly canonicalConfigFilePath: NormalizedPath; private plugins; /** Used for configured projects which may have multiple open roots */ openRefCount: 数字; constructor(configFileName: NormalizedPath, projectService: ProjectService, documentRegistry: DocumentRegistry, hasExplicitListOfFiles: boolean, compilerOptions: CompilerOptions, wildcardDirectories: Map, languageServiceEnabled: boolean, compileOnSaveEnabled: boolean); getConfigFilePath(): 文字; enablePlugins(): 无值; private enablePlugin(pluginConfigEntry, searchPaths); private enableProxy(pluginModuleFactory, configEntry); getProjectRootPath(): 文字; setProjectErrors(projectErrors: Diagnostic[]): 无值; setTypeAcquisition(newTypeAcquisition: TypeAcquisition): void; getTypeAcquisition(): TypeAcquisition; getExternalFiles(): SortedReadonlyArray; watchConfigFile(callback: (project: ConfiguredProject) => void): 无值; watchTypeRoots(callback: (project: ConfiguredProject, path: string) => void): 无值; watchConfigDirectory(callback: (project: ConfiguredProject, path: string) => void): 无值; watchWildcards(callback: (project: ConfiguredProject, path: string) => void): 无值; stopWatchingDirectory(): 无值; close(): 无值; addOpenRef(): 无值; deleteOpenRef(): 数字; getEffectiveTypeRoots(): 文字[]; } /** * Project whose configuration is handled externally, such as in a '.csproj'. * These are created only if a host explicitly calls `openExternalProject`. */ class ExternalProject extends Project { externalProjectName: string; compileOnSaveEnabled: boolean; private readonly projectFilePath; private typeAcquisition; constructor(externalProjectName: string, projectService: ProjectService, documentRegistry: DocumentRegistry, compilerOptions: CompilerOptions, languageServiceEnabled: boolean, compileOnSaveEnabled: boolean, projectFilePath?: string); getProjectRootPath(): 文字; getTypeAcquisition(): TypeAcquisition; setProjectErrors(projectErrors: Diagnostic[]): 无值; setTypeAcquisition(newTypeAcquisition: TypeAcquisition): void; } } declare namespace ts.server { const maxProgramSizeForNonTsFiles: 数字; const ContextEvent = "context"; const ConfigFileDiagEvent = "configFileDiag"; const ProjectLanguageServiceStateEvent = "projectLanguageServiceState"; const ProjectInfoTelemetryEvent = "projectInfo"; interface ContextEvent { eventName: typeof ContextEvent; data: { project: Project; fileName: NormalizedPath; }; } interface ConfigFileDiagEvent { eventName: typeof ConfigFileDiagEvent; data: { triggerFile: string; configFileName: string; diagnostics: Diagnostic[]; }; } interface ProjectLanguageServiceStateEvent { eventName: typeof ProjectLanguageServiceStateEvent; data: { project: Project; languageServiceEnabled: boolean; }; } /** This will be converted to the payload of a protocol.TelemetryEvent in session.defaultEventHandler. */ interface ProjectInfoTelemetryEvent { readonly eventName: typeof ProjectInfoTelemetryEvent; readonly data: ProjectInfoTelemetryEventData; } interface ProjectInfoTelemetryEventData { /** Cryptographically secure hash of project file location. */ readonly projectId: string; /** Count of file extensions seen in the project. */ readonly fileStats: FileStats; /** * Any compiler options that might contain paths will be taken out. * Enum compiler options will be converted to strings. */ readonly compilerOptions: CompilerOptions; readonly extends: boolean | undefined; readonly files: boolean | undefined; readonly include: boolean | undefined; readonly exclude: boolean | undefined; readonly compileOnSave: boolean; readonly typeAcquisition: ProjectInfoTypeAcquisitionData; readonly configFileName: "tsconfig.json" | "jsconfig.json" | "other"; readonly projectType: "external" | "configured"; readonly languageServiceEnabled: boolean; /** TypeScript version used by the server. */ readonly version: string; } interface ProjectInfoTypeAcquisitionData { readonly enable: boolean; readonly include: boolean; readonly exclude: boolean; } interface FileStats { readonly js: number; readonly jsx: number; readonly ts: number; readonly cts: number; readonly tsx: number; readonly ctsx: number; readonly dts: number; readonly dcts: number; } type ProjectServiceEvent = ContextEvent | ConfigFileDiagEvent | ProjectLanguageServiceStateEvent | ProjectInfoTelemetryEvent; interface ProjectServiceEventHandler { (event: ProjectServiceEvent): void; } interface SafeList { [name: string]: { match: RegExp; exclude?: Array>; types?: string[]; }; } function convertFormatOptions(protocolOptions: protocol.FormatCodeSettings): FormatCodeSettings; function convertCompilerOptions(protocolOptions: protocol.ExternalProjectCompilerOptions): CompilerOptions & protocol.CompileOnSaveMixin; function tryConvertScriptKindName(scriptKindName: protocol.ScriptKindName | ScriptKind): ScriptKind; function convertScriptKindName(scriptKindName: protocol.ScriptKindName): ScriptKind.Unknown | ScriptKind.JS | ScriptKind.JSX | ScriptKind.TS | ScriptKind.TSX | ScriptKind.CTS | ScriptKind.CTSX; /** * This helper function processes a list of projects and return the concatenated, sortd and deduplicated output of processing each project. * 这个辅助函数处理项目列表和返回的级联，sortd和重复数据删除处理每一个项目输出。 */ function combineProjectOutput(projects: Project[], action: (project: Project) => T[], comparer?: (a: T, b: T) => number, areEqual?: (a: T, b: T) => boolean): T[]; interface HostConfiguration { formatCodeOptions: FormatCodeSettings; hostInfo: string; extraFileExtensions?: JsFileExtensionInfo[]; } interface OpenConfiguredProjectResult { configFileName?: NormalizedPath; configFileErrors?: Diagnostic[]; } interface ProjectServiceOptions { host: ServerHost; logger: Logger; cancellationToken: HostCancellationToken; useSingleInferredProject: boolean; typingsInstaller: ITypingsInstaller; eventHandler?: ProjectServiceEventHandler; throttleWaitMilliseconds?: number; globalPlugins?: string[]; pluginProbeLocations?: string[]; allowLocalPluginLoads?: boolean; } class ProjectService { readonly typingsCache: TypingsCache; private readonly documentRegistry; /** * Container of all known scripts */ private readonly filenameToScriptInfo; /** * maps external project file name to list of config files that were the part of this project */ private readonly externalProjectToConfiguredProjectMap; /** * external projects (configuration and list of root files is not controlled by tsserver) */ readonly externalProjects: ExternalProject[]; /** * projects built from openFileRoots */ readonly inferredProjects: InferredProject[]; /** * projects specified by a tsconfig.json file */ readonly configuredProjects: ConfiguredProject[]; /** * list of open files */ readonly openFiles: ScriptInfo[]; private compilerOptionsForInferredProjects; private compileOnSaveForInferredProjects; private readonly projectToSizeMap; private readonly directoryWatchers; private readonly throttledOperations; private readonly hostConfiguration; private static safelist; private changedFiles; readonly toCanonicalFileName: (f: string) => string; lastDeletedFile: ScriptInfo; readonly host: ServerHost; readonly logger: Logger; readonly cancellationToken: HostCancellationToken; readonly useSingleInferredProject: boolean; readonly typingsInstaller: ITypingsInstaller; readonly throttleWaitMilliseconds?: number; private readonly eventHandler?; readonly globalPlugins: ReadonlyArray; readonly pluginProbeLocations: ReadonlyArray; readonly allowLocalPluginLoads: boolean; /** Tracks projects that we have already sent telemetry for. */ private readonly seenProjects; constructor(opts: ProjectServiceOptions); ensureInferredProjectsUpToDate_TestOnly(): 无值; getCompilerOptionsForInferredProjects(): CompilerOptions; onUpdateLanguageServiceStateForProject(project: Project, languageServiceEnabled: boolean): 无值; updateTypingsForProject(response: SetTypings | InvalidateCachedTypings): void; setCompilerOptionsForInferredProjects(projectCompilerOptions: protocol.ExternalProjectCompilerOptions): void; stopWatchingDirectory(directory: string): 无值; findProject(projectName: string): Project; getDefaultProjectForFile(fileName: NormalizedPath, refreshInferredProjects: boolean): Project; private ensureInferredProjectsUpToDate(); private findContainingExternalProject(fileName); getFormatCodeOptions(file?: NormalizedPath): FormatCodeSettings; private updateProjectGraphs(projects); private onSourceFileChanged(fileName); private handleDeletedFile(info); private onTypeRootFileChanged(project, fileName); /** * This is the callback function when a watched directory has added or removed source code files. * @param project the project that associates with this directory watcher * @param fileName the absolute file name that changed in watched directory */ private onSourceFileInDirectoryChangedForConfiguredProject(project, fileName); private handleChangeInSourceFileForConfiguredProject(project, triggerFile); private onConfigChangedForConfiguredProject(project); /** * This is the callback function when a watched directory has an added tsconfig file. */ private onConfigFileAddedForInferredProject(fileName); private getCanonicalFileName(fileName); private removeProject(project); private assignScriptInfoToInferredProjectIfNecessary(info, addToListOfOpenFiles); /** * Remove this file from the set of open, non-configured files. * @param info The file that has been closed or newly configured */ private closeOpenFile(info); private deleteOrphanScriptInfoNotInAnyProject(); /** * This function tries to search for a tsconfig.json for the given file. If we found it, * we first detect if there is already a configured project created for it: if so, we re-read * the tsconfig file content and update the project; otherwise we create a new one. */ private openOrUpdateConfiguredProjectForFile(fileName, projectRootPath?); private findConfigFile(searchPath, projectRootPath?); private printProjects(); private findConfiguredProjectByProjectName(configFileName); private findExternalProjectByProjectName(projectFileName); private convertConfigFileContentToProjectOptions(configFilename); private exceededTotalSizeLimitForNonTsFiles(name, options, fileNames, propertyReader); private createAndAddExternalProject(projectFileName, files, options, typeAcquisition); private sendProjectTelemetry(projectKey, project, projectOptions?); private reportConfigFileDiagnostics(configFileName, diagnostics, triggerFile); private createAndAddConfiguredProject(configFileName, projectOptions, configFileErrors, clientFileName?); private watchConfigDirectoryForProject(project, options); private addFilesToProjectAndUpdateGraph(project, files, propertyReader, clientFileName, typeAcquisition, configFileErrors); private openConfigFile(configFileName, clientFileName?); private updateNonInferredProject(project, newUncheckedFiles, propertyReader, newOptions, newTypeAcquisition, compileOnSave, configFileErrors); private updateConfiguredProject(project); createInferredProjectWithRootFileIfNecessary(root: ScriptInfo): InferredProject; /** * @param uncheckedFileName is absolute pathname * @param fileContent is a known version of the file content that is more up to date than the one on disk */ getOrCreateScriptInfo(uncheckedFileName: string, openedByClient: boolean, fileContent?: string, scriptKind?: ScriptKind): ScriptInfo; getScriptInfo(uncheckedFileName: string): ScriptInfo; watchClosedScriptInfo(info: ScriptInfo): 无值; getOrCreateScriptInfoForNormalizedPath(fileName: NormalizedPath, openedByClient: boolean, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean): ScriptInfo; getScriptInfoForNormalizedPath(fileName: NormalizedPath): ScriptInfo; getScriptInfoForPath(fileName: Path): ScriptInfo; setHostConfiguration(args: protocol.ConfigureRequestArguments): 无值; closeLog(): 无值; /** * This function rebuilds the project for every file opened by the client */ reloadProjects(): 无值; /** * This function is to update the project structure for every projects. * It is called on the premise that all the configured projects are * up to date. */ refreshInferredProjects(): 无值; /** * Open file whose contents is managed by the client * @param filename is absolute pathname * @param fileContent is a known version of the file content that is more up to date than the one on disk */ openClientFile(fileName: string, fileContent?: string, scriptKind?: ScriptKind, projectRootPath?: string): OpenConfiguredProjectResult; openClientFileWithNormalizedPath(fileName: NormalizedPath, fileContent?: string, scriptKind?: ScriptKind, hasMixedContent?: boolean, projectRootPath?: NormalizedPath): OpenConfiguredProjectResult; /** * Close file whose contents is managed by the client * @param filename is absolute pathname */ closeClientFile(uncheckedFileName: string): 无值; private collectChanges(lastKnownProjectVersions, currentProjects, result); private closeConfiguredProject(configFile); closeExternalProject(uncheckedFileName: string, suppressRefresh?: 真假): void; openExternalProjects(projects: protocol.ExternalProject[]): void; /** Makes a filename safe to insert in a RegExp */ private static filenameEscapeRegexp; private static escapeFilenameForRegex(filename); resetSafeList(): void; loadSafeList(fileName: string): void; applySafeList(proj: protocol.ExternalProject): void; openExternalProject(proj: protocol.ExternalProject, suppressRefreshOfInferredProjects?: 真假): void; } } export = ts; export as namespace ts;