Last active
July 2, 2020 08:20
-
-
Save robpalme/65354cdc55ced147ed606342315fb4f2 to your computer and use it in GitHub Desktop.
Property-to-Var optimisation on TypeScript Compiler
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| var ts_versionMajorMinor, | |
| ts_version, | |
| ts_tryGetNativeMap, | |
| ts_Map, | |
| ts_createMapShim, | |
| ts_emptyArray, | |
| ts_createMap, | |
| ts_createMapFromEntries, | |
| ts_createMapFromTemplate, | |
| ts_length, | |
| ts_forEach, | |
| ts_forEachRight, | |
| ts_firstDefined, | |
| ts_firstDefinedIterator, | |
| ts_Debug, | |
| ts_zipWith, | |
| ts_zipToIterator, | |
| ts_zipToMap, | |
| ts_every, | |
| ts_find, | |
| ts_findLast, | |
| ts_findIndex, | |
| ts_findLastIndex, | |
| ts_findMap, | |
| ts_contains, | |
| ts_arraysEqual, | |
| ts_indexOfAnyCharCode, | |
| ts_countWhere, | |
| ts_filter, | |
| ts_filterMutate, | |
| ts_clear, | |
| ts_map, | |
| ts_mapIterator, | |
| ts_sameMap, | |
| ts_flatten, | |
| ts_flatMap, | |
| ts_flatMapToMutable, | |
| ts_emptyIterator, | |
| ts_flatMapIterator, | |
| ts_sameFlatMap, | |
| ts_mapAllOrFail, | |
| ts_mapDefined, | |
| ts_mapDefinedIterator, | |
| ts_mapDefinedMap, | |
| ts_singleIterator, | |
| ts_spanMap, | |
| ts_mapEntries, | |
| ts_some, | |
| ts_getRangesWhere, | |
| ts_concatenate, | |
| ts_indicesOf, | |
| ts_deduplicate, | |
| ts_insertSorted, | |
| ts_sortAndDeduplicate, | |
| ts_arrayIsEqualTo, | |
| ts_compact, | |
| ts_relativeComplement, | |
| ts_sum, | |
| ts_append, | |
| ts_addRange, | |
| ts_pushIfUnique, | |
| ts_appendIfUnique, | |
| ts_sort, | |
| ts_arrayIterator, | |
| ts_arrayReverseIterator, | |
| ts_stableSort, | |
| ts_rangeEquals, | |
| ts_elementAt, | |
| ts_firstOrUndefined, | |
| ts_first, | |
| ts_lastOrUndefined, | |
| ts_last, | |
| ts_singleOrUndefined, | |
| ts_singleOrMany, | |
| ts_replaceElement, | |
| ts_binarySearch, | |
| ts_binarySearchKey, | |
| ts_reduceLeft, | |
| ts_hasProperty, | |
| ts_getProperty, | |
| ts_getOwnKeys, | |
| ts_getAllKeys, | |
| ts_getOwnValues, | |
| ts_arrayFrom, | |
| ts_assign, | |
| ts_equalOwnProperties, | |
| ts_arrayToMap, | |
| ts_arrayToNumericMap, | |
| ts_arrayToMultiMap, | |
| ts_group, | |
| ts_clone, | |
| ts_extend, | |
| ts_copyProperties, | |
| ts_maybeBind, | |
| ts_mapMap, | |
| ts_createMultiMap, | |
| ts_isArray, | |
| ts_toArray, | |
| ts_isString, | |
| ts_isNumber, | |
| ts_tryCast, | |
| ts_cast, | |
| ts_noop, | |
| ts_returnFalse, | |
| ts_returnTrue, | |
| ts_returnUndefined, | |
| ts_identity, | |
| ts_toLowerCase, | |
| ts_toFileNameLowerCase, | |
| ts_notImplemented, | |
| ts_memoize, | |
| ts_compose, | |
| ts_equateValues, | |
| ts_equateStringsCaseInsensitive, | |
| ts_equateStringsCaseSensitive, | |
| ts_compareValues, | |
| ts_compareTextSpans, | |
| ts_min, | |
| ts_compareStringsCaseInsensitive, | |
| ts_compareStringsCaseSensitive, | |
| ts_getStringComparer, | |
| ts_getUILocale, | |
| ts_setUILocale, | |
| ts_compareStringsCaseSensitiveUI, | |
| ts_compareProperties, | |
| ts_compareBooleans, | |
| ts_getSpellingSuggestion, | |
| ts_endsWith, | |
| ts_removeSuffix, | |
| ts_tryRemoveSuffix, | |
| ts_stringContains, | |
| ts_removeMinAndVersionNumbers, | |
| ts_orderedRemoveItem, | |
| ts_orderedRemoveItemAt, | |
| ts_unorderedRemoveItemAt, | |
| ts_unorderedRemoveItem, | |
| ts_createGetCanonicalFileName, | |
| ts_patternText, | |
| ts_matchedText, | |
| ts_findBestPatternMatch, | |
| ts_startsWith, | |
| ts_removePrefix, | |
| ts_tryRemovePrefix, | |
| ts_and, | |
| ts_or, | |
| ts_not, | |
| ts_assertType, | |
| ts_singleElementArray, | |
| ts_enumerateInsertsAndDeletes, | |
| ts_fill, | |
| ts_cartesianProduct, | |
| ts_unescapeLeadingUnderscores, | |
| ts_SyntaxKind, | |
| ts_NodeFlags, | |
| ts_ModifierFlags, | |
| ts_TransformFlags, | |
| ts_EmitFlags, | |
| ts_SymbolFlags, | |
| ts_TypeFlags, | |
| ts_ObjectFlags, | |
| ts_FlowFlags, | |
| ts_objectAllocator, | |
| ts_getModifierFlagsNoCache, | |
| ts_isParseTreeNode, | |
| ts_getEmitFlags, | |
| ts_nodeIsSynthesized, | |
| ts_getParseTreeNode, | |
| ts_getSourceFileOfNode, | |
| ts_getSourceTextOfNodeFromSourceFile, | |
| ts_sys, | |
| ts_getDirectoryPath, | |
| ts_resolvePath, | |
| ts_timestamp, | |
| ts_performance, | |
| ts_perfLogger, | |
| ts_Version, | |
| ts_VersionRange, | |
| ts_OperationCanceledException, | |
| ts_RefFileKind, | |
| ts_ExitStatus, | |
| ts_TypeReferenceSerializationKind, | |
| ts_DiagnosticCategory, | |
| ts_diagnosticCategoryName, | |
| ts_ModuleResolutionKind, | |
| ts_WatchFileKind, | |
| ts_WatchDirectoryKind, | |
| ts_PollingWatchKind, | |
| ts_ModuleKind, | |
| ts_commentPragmas, | |
| ts_generateDjb2Hash, | |
| ts_setStackTraceLimit, | |
| ts_FileWatcherEventKind, | |
| ts_PollingInterval, | |
| ts_missingFileModifiedTime, | |
| ts_unchangedPollThresholds, | |
| ts_setCustomPollingValues, | |
| ts_createDynamicPriorityPollingWatchFile, | |
| ts_getNormalizedAbsolutePath, | |
| ts_closeFileWatcherOf, | |
| ts_createSingleFileWatcherPerName, | |
| ts_onWatchedFileStat, | |
| ts_getFileWatcherEventKind, | |
| ts_ignoredPaths, | |
| ts_sysLog, | |
| ts_setSysLog, | |
| ts_closeFileWatcher, | |
| ts_directorySeparator, | |
| ts_normalizePath, | |
| ts_createDirectoryWatcherSupportingRecursive, | |
| ts_createFileWatcherCallback, | |
| ts_combinePaths, | |
| ts_getFallbackOptions, | |
| ts_createSystemWatchFunctions, | |
| ts_writeFileEnsuringDirectories, | |
| ts_patchWriteFileEnsuringDirectory, | |
| ts_getNodeMajorVersion, | |
| ts_resolveJSModule, | |
| ts_normalizeSlashes, | |
| ts_getRootLength, | |
| ts_containsPath, | |
| ts_getRelativePathToDirectoryOrUrl, | |
| ts_emptyFileSystemEntries, | |
| ts_matchFiles, | |
| ts_getFileMatcherPatterns, | |
| ts_isAnyDirectorySeparator, | |
| ts_isUrl, | |
| ts_isRootedDiskPath, | |
| ts_isDiskPathRoot, | |
| ts_pathIsAbsolute, | |
| ts_pathIsRelative, | |
| ts_hasExtension, | |
| ts_fileExtensionIs, | |
| ts_fileExtensionIsOneOf, | |
| ts_hasTrailingDirectorySeparator, | |
| ts_getBaseFileName, | |
| ts_getAnyExtensionFromPath, | |
| ts_getPathComponents, | |
| ts_getPathFromPathComponents, | |
| ts_reducePathComponents, | |
| ts_getNormalizedPathComponents, | |
| ts_getNormalizedAbsolutePathWithoutRoot, | |
| ts_toPath, | |
| ts_normalizePathAndParts, | |
| ts_removeTrailingDirectorySeparator, | |
| ts_ensureTrailingDirectorySeparator, | |
| ts_ensurePathIsNonModuleName, | |
| ts_changeAnyExtension, | |
| ts_comparePathsCaseSensitive, | |
| ts_comparePathsCaseInsensitive, | |
| ts_comparePaths, | |
| ts_startsWithDirectory, | |
| ts_getPathComponentsRelativeTo, | |
| ts_getRelativePathFromDirectory, | |
| ts_convertToRelativePath, | |
| ts_getRelativePathFromFile, | |
| ts_forEachAncestorDirectory, | |
| ts_Diagnostics, | |
| ts_transpileModule, | |
| ts_tokenIsIdentifierOrKeyword, | |
| ts_tokenIsIdentifierOrKeywordOrGreaterThan, | |
| ts_isUnicodeIdentifierStart, | |
| ts_tokenToString, | |
| ts_stringToToken, | |
| ts_computeLineStarts, | |
| ts_getPositionOfLineAndCharacter, | |
| ts_computePositionOfLineAndCharacter, | |
| ts_getLineStarts, | |
| ts_computeLineAndCharacterOfPosition, | |
| ts_getLineAndCharacterOfPosition, | |
| ts_isWhiteSpaceLike, | |
| ts_isWhiteSpaceSingleLine, | |
| ts_isLineBreak, | |
| ts_isOctalDigit, | |
| ts_couldStartTrivia, | |
| ts_positionIsSynthesized, | |
| ts_skipTrivia, | |
| ts_isShebangTrivia, | |
| ts_scanShebangTrivia, | |
| ts_forEachLeadingCommentRange, | |
| ts_forEachTrailingCommentRange, | |
| ts_reduceEachLeadingCommentRange, | |
| ts_reduceEachTrailingCommentRange, | |
| ts_getLeadingCommentRanges, | |
| ts_getTrailingCommentRanges, | |
| ts_getShebang, | |
| ts_isIdentifierStart, | |
| ts_isIdentifierPart, | |
| ts_isIdentifierText, | |
| ts_parsePseudoBigInt, | |
| ts_createScanner, | |
| ts_utf16EncodeAsString, | |
| ts_isExternalModuleNameRelative, | |
| ts_compareDiagnostics, | |
| ts_sortAndDeduplicateDiagnostics, | |
| ts_getDefaultLibFileName, | |
| ts_textSpanEnd, | |
| ts_textSpanIsEmpty, | |
| ts_textSpanContainsPosition, | |
| ts_textRangeContainsPositionInclusive, | |
| ts_textSpanContainsTextSpan, | |
| ts_textSpanOverlapsWith, | |
| ts_textSpanOverlap, | |
| ts_textSpanIntersectsWithTextSpan, | |
| ts_textSpanIntersectsWith, | |
| ts_decodedTextSpanIntersectsWith, | |
| ts_textSpanIntersectsWithPosition, | |
| ts_textSpanIntersection, | |
| ts_createTextSpan, | |
| ts_createTextSpanFromBounds, | |
| ts_textChangeRangeNewSpan, | |
| ts_textChangeRangeIsUnchanged, | |
| ts_createTextChangeRange, | |
| ts_unchangedTextChangeRange, | |
| ts_collapseTextChangeRangesAcrossMultipleVersions, | |
| ts_getTypeParameterOwner, | |
| ts_hasModifier, | |
| ts_isParameterPropertyDeclaration, | |
| ts_isEmptyBindingPattern, | |
| ts_isEmptyBindingElement, | |
| ts_walkUpBindingElementsAndPatterns, | |
| ts_getModifierFlags, | |
| ts_getCombinedModifierFlags, | |
| ts_getCombinedNodeFlags, | |
| ts_createCompilerDiagnostic, | |
| ts_setLocalizedDiagnosticMessages, | |
| ts_validateLocaleAndSetLanguage, | |
| ts_getOriginalNode, | |
| ts_escapeLeadingUnderscores, | |
| ts_idText, | |
| ts_symbolName, | |
| ts_nodeHasName, | |
| ts_getNameOfJSDocTypedef, | |
| ts_isNamedDeclaration, | |
| ts_getAssignmentDeclarationKind, | |
| ts_getElementOrPropertyAccessArgumentExpressionOrName, | |
| ts_isBindableStaticElementAccessExpression, | |
| ts_getNonAssignedNameOfDeclaration, | |
| ts_getNameOfDeclaration, | |
| ts_isAccessExpression, | |
| ts_getJSDocParameterTags, | |
| ts_getJSDocTypeParameterTags, | |
| ts_hasJSDocParameterTags, | |
| ts_getJSDocAugmentsTag, | |
| ts_getJSDocClassTag, | |
| ts_getJSDocPublicTag, | |
| ts_getJSDocPrivateTag, | |
| ts_getJSDocProtectedTag, | |
| ts_getJSDocReadonlyTag, | |
| ts_getJSDocEnumTag, | |
| ts_getJSDocThisTag, | |
| ts_getJSDocReturnTag, | |
| ts_getJSDocTemplateTag, | |
| ts_getJSDocTypeTag, | |
| ts_getJSDocType, | |
| ts_getJSDocReturnType, | |
| ts_getJSDocCommentsAndTags, | |
| ts_getJSDocTags, | |
| ts_getAllJSDocTagsOfKind, | |
| ts_isJSDocTypeAlias, | |
| ts_isInJSFile, | |
| ts_getJSDocTypeParameterDeclarations, | |
| ts_getEffectiveTypeParameterDeclarations, | |
| ts_getEffectiveConstraintOfTypeParameter, | |
| ts_isNumericLiteral, | |
| ts_isBigIntLiteral, | |
| ts_isStringLiteral, | |
| ts_isJsxText, | |
| ts_isRegularExpressionLiteral, | |
| ts_isNoSubstitutionTemplateLiteral, | |
| ts_isTemplateHead, | |
| ts_isTemplateMiddle, | |
| ts_isTemplateTail, | |
| ts_isIdentifier, | |
| ts_isQualifiedName, | |
| ts_isComputedPropertyName, | |
| ts_isPrivateIdentifier, | |
| ts_isIdentifierOrPrivateIdentifier, | |
| ts_isTypeParameterDeclaration, | |
| ts_isParameter, | |
| ts_isDecorator, | |
| ts_isPropertySignature, | |
| ts_isPropertyDeclaration, | |
| ts_isMethodSignature, | |
| ts_isMethodDeclaration, | |
| ts_isConstructorDeclaration, | |
| ts_isGetAccessorDeclaration, | |
| ts_isSetAccessorDeclaration, | |
| ts_isCallSignatureDeclaration, | |
| ts_isConstructSignatureDeclaration, | |
| ts_isIndexSignatureDeclaration, | |
| ts_isGetOrSetAccessorDeclaration, | |
| ts_isTypePredicateNode, | |
| ts_isTypeReferenceNode, | |
| ts_isFunctionTypeNode, | |
| ts_isConstructorTypeNode, | |
| ts_isTypeQueryNode, | |
| ts_isTypeLiteralNode, | |
| ts_isArrayTypeNode, | |
| ts_isTupleTypeNode, | |
| ts_isUnionTypeNode, | |
| ts_isIntersectionTypeNode, | |
| ts_isConditionalTypeNode, | |
| ts_isInferTypeNode, | |
| ts_isParenthesizedTypeNode, | |
| ts_isThisTypeNode, | |
| ts_isTypeOperatorNode, | |
| ts_isIndexedAccessTypeNode, | |
| ts_isMappedTypeNode, | |
| ts_isLiteralTypeNode, | |
| ts_isImportTypeNode, | |
| ts_isObjectBindingPattern, | |
| ts_isArrayBindingPattern, | |
| ts_isBindingElement, | |
| ts_isArrayLiteralExpression, | |
| ts_isObjectLiteralExpression, | |
| ts_isPropertyAccessExpression, | |
| ts_isPropertyAccessChain, | |
| ts_isElementAccessExpression, | |
| ts_isElementAccessChain, | |
| ts_isCallExpression, | |
| ts_isCallChain, | |
| ts_isOptionalChain, | |
| ts_isOptionalChainRoot, | |
| ts_isExpressionOfOptionalChainRoot, | |
| ts_isOutermostOptionalChain, | |
| ts_isNullishCoalesce, | |
| ts_isNewExpression, | |
| ts_isTaggedTemplateExpression, | |
| ts_isTypeAssertion, | |
| ts_isConstTypeReference, | |
| ts_isParenthesizedExpression, | |
| ts_skipPartiallyEmittedExpressions, | |
| ts_isFunctionExpression, | |
| ts_isArrowFunction, | |
| ts_isDeleteExpression, | |
| ts_isTypeOfExpression, | |
| ts_isVoidExpression, | |
| ts_isAwaitExpression, | |
| ts_isPrefixUnaryExpression, | |
| ts_isPostfixUnaryExpression, | |
| ts_isBinaryExpression, | |
| ts_isConditionalExpression, | |
| ts_isTemplateExpression, | |
| ts_isYieldExpression, | |
| ts_isSpreadElement, | |
| ts_isClassExpression, | |
| ts_isOmittedExpression, | |
| ts_isExpressionWithTypeArguments, | |
| ts_isAsExpression, | |
| ts_isNonNullExpression, | |
| ts_isMetaProperty, | |
| ts_isTemplateSpan, | |
| ts_isSemicolonClassElement, | |
| ts_isBlock, | |
| ts_isVariableStatement, | |
| ts_isEmptyStatement, | |
| ts_isExpressionStatement, | |
| ts_isIfStatement, | |
| ts_isDoStatement, | |
| ts_isWhileStatement, | |
| ts_isForStatement, | |
| ts_isForInStatement, | |
| ts_isForOfStatement, | |
| ts_isContinueStatement, | |
| ts_isBreakStatement, | |
| ts_isBreakOrContinueStatement, | |
| ts_isReturnStatement, | |
| ts_isWithStatement, | |
| ts_isSwitchStatement, | |
| ts_isLabeledStatement, | |
| ts_isThrowStatement, | |
| ts_isTryStatement, | |
| ts_isDebuggerStatement, | |
| ts_isVariableDeclaration, | |
| ts_isVariableDeclarationList, | |
| ts_isFunctionDeclaration, | |
| ts_isClassDeclaration, | |
| ts_isInterfaceDeclaration, | |
| ts_isTypeAliasDeclaration, | |
| ts_isEnumDeclaration, | |
| ts_isModuleDeclaration, | |
| ts_isModuleBlock, | |
| ts_isCaseBlock, | |
| ts_isNamespaceExportDeclaration, | |
| ts_isImportEqualsDeclaration, | |
| ts_isImportDeclaration, | |
| ts_isImportClause, | |
| ts_isNamespaceImport, | |
| ts_isNamespaceExport, | |
| ts_isNamedExportBindings, | |
| ts_isNamedImports, | |
| ts_isImportSpecifier, | |
| ts_isExportAssignment, | |
| ts_isExportDeclaration, | |
| ts_isNamedExports, | |
| ts_isExportSpecifier, | |
| ts_isMissingDeclaration, | |
| ts_isExternalModuleReference, | |
| ts_isJsxElement, | |
| ts_isJsxSelfClosingElement, | |
| ts_isJsxOpeningElement, | |
| ts_isJsxClosingElement, | |
| ts_isJsxFragment, | |
| ts_isJsxOpeningFragment, | |
| ts_isJsxClosingFragment, | |
| ts_isJsxAttribute, | |
| ts_isJsxAttributes, | |
| ts_isJsxSpreadAttribute, | |
| ts_isJsxExpression, | |
| ts_isCaseClause, | |
| ts_isDefaultClause, | |
| ts_isHeritageClause, | |
| ts_isCatchClause, | |
| ts_isPropertyAssignment, | |
| ts_isShorthandPropertyAssignment, | |
| ts_isSpreadAssignment, | |
| ts_isEnumMember, | |
| ts_isSourceFile, | |
| ts_isBundle, | |
| ts_isUnparsedSource, | |
| ts_isUnparsedPrepend, | |
| ts_isUnparsedTextLike, | |
| ts_isUnparsedNode, | |
| ts_isJSDocTypeExpression, | |
| ts_isJSDocAllType, | |
| ts_isJSDocUnknownType, | |
| ts_isJSDocNullableType, | |
| ts_isJSDocNonNullableType, | |
| ts_isJSDocOptionalType, | |
| ts_isJSDocFunctionType, | |
| ts_isJSDocVariadicType, | |
| ts_isJSDoc, | |
| ts_isJSDocAuthorTag, | |
| ts_isJSDocAugmentsTag, | |
| ts_isJSDocClassTag, | |
| ts_isJSDocPublicTag, | |
| ts_isJSDocPrivateTag, | |
| ts_isJSDocProtectedTag, | |
| ts_isJSDocReadonlyTag, | |
| ts_isJSDocEnumTag, | |
| ts_isJSDocThisTag, | |
| ts_isJSDocParameterTag, | |
| ts_isJSDocReturnTag, | |
| ts_isJSDocTypeTag, | |
| ts_isJSDocTemplateTag, | |
| ts_isJSDocTypedefTag, | |
| ts_isJSDocPropertyTag, | |
| ts_isJSDocPropertyLikeTag, | |
| ts_isJSDocTypeLiteral, | |
| ts_isJSDocCallbackTag, | |
| ts_isJSDocSignature, | |
| ts_isSyntaxList, | |
| ts_isNode, | |
| ts_isNodeKind, | |
| ts_isToken, | |
| ts_isNodeArray, | |
| ts_isLiteralKind, | |
| ts_isLiteralExpression, | |
| ts_isTemplateLiteralKind, | |
| ts_isTemplateLiteralToken, | |
| ts_isTemplateMiddleOrTemplateTail, | |
| ts_isImportOrExportSpecifier, | |
| ts_isTypeOnlyImportOrExportDeclaration, | |
| ts_isStringTextContainingNode, | |
| ts_isGeneratedIdentifier, | |
| ts_isPrivateIdentifierPropertyDeclaration, | |
| ts_isPrivateIdentifierPropertyAccessExpression, | |
| ts_isModifierKind, | |
| ts_modifierToFlag, | |
| ts_isParameterPropertyModifier, | |
| ts_isClassMemberModifier, | |
| ts_isModifier, | |
| ts_isEntityName, | |
| ts_isPropertyName, | |
| ts_isBindingName, | |
| ts_isFunctionLike, | |
| ts_isFunctionLikeDeclaration, | |
| ts_isFunctionLikeKind, | |
| ts_isFunctionOrModuleBlock, | |
| ts_isClassElement, | |
| ts_isClassLike, | |
| ts_isAccessor, | |
| ts_isMethodOrAccessor, | |
| ts_isTypeElement, | |
| ts_isClassOrTypeElement, | |
| ts_isObjectLiteralElementLike, | |
| ts_isTypeNodeKind, | |
| ts_isTypeNode, | |
| ts_isFunctionOrConstructorTypeNode, | |
| ts_isBindingPattern, | |
| ts_isAssignmentPattern, | |
| ts_isArrayBindingElement, | |
| ts_isDeclarationBindingElement, | |
| ts_isBindingOrAssignmentPattern, | |
| ts_isObjectBindingOrAssignmentPattern, | |
| ts_isArrayBindingOrAssignmentPattern, | |
| ts_isPropertyAccessOrQualifiedNameOrImportTypeNode, | |
| ts_isPropertyAccessOrQualifiedName, | |
| ts_isCallLikeExpression, | |
| ts_isCallOrNewExpression, | |
| ts_isTemplateLiteral, | |
| ts_isLeftHandSideExpression, | |
| ts_isUnaryExpression, | |
| ts_isUnaryExpressionWithWrite, | |
| ts_isExpression, | |
| ts_isAssertionExpression, | |
| ts_isPartiallyEmittedExpression, | |
| ts_isNotEmittedStatement, | |
| ts_isSyntheticReference, | |
| ts_isNotEmittedOrPartiallyEmittedNode, | |
| ts_isIterationStatement, | |
| ts_isScopeMarker, | |
| ts_hasScopeMarker, | |
| ts_isAnyImportOrReExport, | |
| ts_isAmbientModule, | |
| ts_needsScopeMarker, | |
| ts_isExternalModuleIndicator, | |
| ts_isForInOrOfStatement, | |
| ts_isConciseBody, | |
| ts_isFunctionBody, | |
| ts_isForInitializer, | |
| ts_isModuleBody, | |
| ts_isNamespaceBody, | |
| ts_isJSDocNamespaceBody, | |
| ts_isNamedImportBindings, | |
| ts_isModuleOrEnumDeclaration, | |
| ts_isDeclaration, | |
| ts_isDeclarationStatement, | |
| ts_isStatementButNotDeclaration, | |
| ts_isStatement, | |
| ts_isFunctionBlock, | |
| ts_isModuleReference, | |
| ts_isJsxTagNameExpression, | |
| ts_isJsxChild, | |
| ts_isJsxAttributeLike, | |
| ts_isStringLiteralOrJsxExpression, | |
| ts_isJsxOpeningLikeElement, | |
| ts_isCaseOrDefaultClause, | |
| ts_isJSDocNode, | |
| ts_isJSDocCommentContainingNode, | |
| ts_isJSDocTag, | |
| ts_isSetAccessor, | |
| ts_isGetAccessor, | |
| ts_hasJSDocNodes, | |
| ts_hasType, | |
| ts_hasInitializer, | |
| ts_hasOnlyExpressionInitializer, | |
| ts_isObjectLiteralElement, | |
| ts_isTypeReferenceType, | |
| ts_guessIndentation, | |
| ts_isStringLiteralLike, | |
| ts_resolvingEmptyArray, | |
| ts_emptyMap, | |
| ts_emptyUnderscoreEscapedMap, | |
| ts_externalHelpersModuleNameText, | |
| ts_defaultMaximumTruncationLength, | |
| ts_getDeclarationOfKind, | |
| ts_createUnderscoreEscapedMap, | |
| ts_hasEntries, | |
| ts_createSymbolTable, | |
| ts_isTransientSymbol, | |
| ts_changesAffectModuleResolution, | |
| ts_moduleResolutionOptionDeclarations, | |
| ts_optionsHaveModuleResolutionChanges, | |
| ts_findAncestor, | |
| ts_forEachAncestor, | |
| ts_forEachEntry, | |
| ts_forEachKey, | |
| ts_copyEntries, | |
| ts_arrayToSet, | |
| ts_cloneMap, | |
| ts_usingSingleLineStringWriter, | |
| ts_getFullWidth, | |
| ts_getResolvedModule, | |
| ts_setResolvedModule, | |
| ts_setResolvedTypeReferenceDirective, | |
| ts_projectReferenceIsEqualTo, | |
| ts_moduleResolutionIsEqualTo, | |
| ts_packageIdToString, | |
| ts_typeDirectiveIsEqualTo, | |
| ts_hasChangesInResolutions, | |
| ts_containsParseError, | |
| ts_forEachChild, | |
| ts_isStatementWithLocals, | |
| ts_getStartPositionOfLine, | |
| ts_nodePosToString, | |
| ts_getEndLinePosition, | |
| ts_isFileLevelUniqueName, | |
| ts_nodeIsMissing, | |
| ts_nodeIsPresent, | |
| ts_insertStatementsAfterStandardPrologue, | |
| ts_insertStatementsAfterCustomPrologue, | |
| ts_insertStatementAfterStandardPrologue, | |
| ts_insertStatementAfterCustomPrologue, | |
| ts_fullTripleSlashReferencePathRegEx, | |
| ts_fullTripleSlashAMDReferencePathRegEx, | |
| ts_isRecognizedTripleSlashComment, | |
| ts_isPinnedComment, | |
| ts_getTokenPosOfNode, | |
| ts_getNonDecoratorTokenPosOfNode, | |
| ts_getTextOfNodeFromSourceText, | |
| ts_getTextOfNode, | |
| ts_indexOfNode, | |
| ts_getLiteralText, | |
| ts_getTextOfConstantValue, | |
| ts_makeIdentifierFromModuleName, | |
| ts_isBlockOrCatchScoped, | |
| ts_isCatchClauseVariableDeclarationOrBindingElement, | |
| ts_isModuleWithStringLiteralName, | |
| ts_isNonGlobalAmbientModule, | |
| ts_isEffectiveModuleDeclaration, | |
| ts_isShorthandAmbientModuleSymbol, | |
| ts_isBlockScopedContainerTopLevel, | |
| ts_isGlobalScopeAugmentation, | |
| ts_isExternalModuleAugmentation, | |
| ts_isExternalModule, | |
| ts_isModuleAugmentationExternal, | |
| ts_getNonAugmentationDeclaration, | |
| ts_isEffectiveExternalModule, | |
| ts_startsWithUseStrict, | |
| ts_isEffectiveStrictModeSourceFile, | |
| ts_isBlockScope, | |
| ts_isDeclarationWithTypeParameters, | |
| ts_isDeclarationWithTypeParameterChildren, | |
| ts_isAnyImportSyntax, | |
| ts_isLateVisibilityPaintedStatement, | |
| ts_getEnclosingBlockScopeContainer, | |
| ts_declarationNameToString, | |
| ts_getNameFromIndexInfo, | |
| ts_getTextOfPropertyName, | |
| ts_entityNameToString, | |
| ts_createDiagnosticForNode, | |
| ts_createDiagnosticForNodeArray, | |
| ts_createDiagnosticForNodeInSourceFile, | |
| ts_createDiagnosticForNodeFromMessageChain, | |
| ts_getSpanOfTokenAtPosition, | |
| ts_getErrorSpanForNode, | |
| ts_isExternalOrCommonJsModule, | |
| ts_isJsonSourceFile, | |
| ts_isEnumConst, | |
| ts_isDeclarationReadonly, | |
| ts_isVarConst, | |
| ts_isLet, | |
| ts_isSuperCall, | |
| ts_isImportCall, | |
| ts_isImportMeta, | |
| ts_isLiteralImportTypeNode, | |
| ts_isPrologueDirective, | |
| ts_getLeadingCommentRangesOfNode, | |
| ts_getJSDocCommentRanges, | |
| ts_isPartOfTypeNode, | |
| ts_isChildOfNodeWithKind, | |
| ts_forEachReturnStatement, | |
| ts_forEachYieldExpression, | |
| ts_getRestParameterElementType, | |
| ts_getMembersOfDeclaration, | |
| ts_isVariableLike, | |
| ts_isVariableLikeOrAccessor, | |
| ts_isVariableDeclarationInVariableStatement, | |
| ts_isValidESSymbolDeclaration, | |
| ts_introducesArgumentsExoticObject, | |
| ts_unwrapInnermostStatementOfLabel, | |
| ts_isObjectLiteralMethod, | |
| ts_isObjectLiteralOrClassExpressionMethod, | |
| ts_isIdentifierTypePredicate, | |
| ts_isThisTypePredicate, | |
| ts_getPropertyAssignment, | |
| ts_getTsConfigObjectLiteralExpression, | |
| ts_getTsConfigPropArrayElementValue, | |
| ts_getTsConfigPropArray, | |
| ts_getContainingFunction, | |
| ts_getContainingFunctionDeclaration, | |
| ts_getContainingClass, | |
| ts_getThisContainer, | |
| ts_getNewTargetContainer, | |
| ts_getSuperContainer, | |
| ts_getImmediatelyInvokedFunctionExpression, | |
| ts_isSuperOrSuperProperty, | |
| ts_isSuperProperty, | |
| ts_isThisProperty, | |
| ts_getEntityNameFromTypeNode, | |
| ts_getInvokedExpression, | |
| ts_nodeCanBeDecorated, | |
| ts_nodeIsDecorated, | |
| ts_nodeOrChildIsDecorated, | |
| ts_childIsDecorated, | |
| ts_isJSXTagName, | |
| ts_isExpressionNode, | |
| ts_isInExpressionContext, | |
| ts_isPartOfTypeQuery, | |
| ts_isExternalModuleImportEqualsDeclaration, | |
| ts_getExternalModuleImportEqualsDeclarationExpression, | |
| ts_isInternalModuleImportEqualsDeclaration, | |
| ts_isSourceFileJS, | |
| ts_isSourceFileNotJS, | |
| ts_isInJsonFile, | |
| ts_isSourceFileNotJson, | |
| ts_isInJSDoc, | |
| ts_isJSDocIndexSignature, | |
| ts_isRequireCall, | |
| ts_isSingleOrDoubleQuote, | |
| ts_isStringDoubleQuoted, | |
| ts_getDeclarationOfExpando, | |
| ts_isAssignmentDeclaration, | |
| ts_getEffectiveInitializer, | |
| ts_getDeclaredExpandoInitializer, | |
| ts_getAssignedExpandoInitializer, | |
| ts_getExpandoInitializer, | |
| ts_isDefaultedExpandoInitializer, | |
| ts_getNameOfExpando, | |
| ts_getRightMostAssignedExpression, | |
| ts_isExportsIdentifier, | |
| ts_isModuleExportsAccessExpression, | |
| ts_isBindableObjectDefinePropertyCall, | |
| ts_isLiteralLikeAccess, | |
| ts_isLiteralLikeElementAccess, | |
| ts_isBindableStaticAccessExpression, | |
| ts_isBindableStaticNameExpression, | |
| ts_getNameOrArgument, | |
| ts_getElementOrPropertyAccessName, | |
| ts_getAssignmentDeclarationPropertyAccessKind, | |
| ts_getInitializerOfBinaryExpression, | |
| ts_isPrototypePropertyAssignment, | |
| ts_isSpecialPropertyDeclaration, | |
| ts_isFunctionSymbol, | |
| ts_importFromModuleSpecifier, | |
| ts_tryGetImportFromModuleSpecifier, | |
| ts_getExternalModuleName, | |
| ts_getNamespaceDeclarationNode, | |
| ts_isDefaultImport, | |
| ts_forEachImportClauseDeclaration, | |
| ts_hasQuestionToken, | |
| ts_isJSDocConstructSignature, | |
| ts_isTypeAlias, | |
| ts_getSingleInitializerOfVariableStatementOrPropertyDeclaration, | |
| ts_getParameterSymbolFromJSDoc, | |
| ts_getHostSignatureFromJSDoc, | |
| ts_getHostSignatureFromJSDocHost, | |
| ts_getJSDocHost, | |
| ts_getTypeParameterFromJsDoc, | |
| ts_hasRestParameter, | |
| ts_isRestParameter, | |
| ts_hasTypeArguments, | |
| ts_getAssignmentTargetKind, | |
| ts_isAssignmentTarget, | |
| ts_isNodeWithPossibleHoistedDeclaration, | |
| ts_isValueSignatureDeclaration, | |
| ts_walkUpParenthesizedTypes, | |
| ts_walkUpParenthesizedExpressions, | |
| ts_skipParentheses, | |
| ts_isDeleteTarget, | |
| ts_isNodeDescendantOf, | |
| ts_isDeclarationName, | |
| ts_getDeclarationFromName, | |
| ts_isLiteralComputedPropertyDeclarationName, | |
| ts_isIdentifierName, | |
| ts_isAliasSymbolDeclaration, | |
| ts_getAliasDeclarationFromName, | |
| ts_isAliasableExpression, | |
| ts_exportAssignmentIsAlias, | |
| ts_getExportAssignmentExpression, | |
| ts_getPropertyAssignmentAliasLikeExpression, | |
| ts_getEffectiveBaseTypeNode, | |
| ts_getClassExtendsHeritageElement, | |
| ts_getClassImplementsHeritageClauseElements, | |
| ts_getAllSuperTypeNodes, | |
| ts_getInterfaceBaseTypeNodes, | |
| ts_getHeritageClause, | |
| ts_getAncestor, | |
| ts_isKeyword, | |
| ts_isContextualKeyword, | |
| ts_isNonContextualKeyword, | |
| ts_isFutureReservedKeyword, | |
| ts_isStringANonContextualKeyword, | |
| ts_isStringAKeyword, | |
| ts_isIdentifierANonContextualKeyword, | |
| ts_isTrivia, | |
| ts_getFunctionFlags, | |
| ts_isAsyncFunction, | |
| ts_isStringOrNumericLiteralLike, | |
| ts_isSignedNumericLiteral, | |
| ts_hasDynamicName, | |
| ts_isDynamicName, | |
| ts_isWellKnownSymbolSyntactically, | |
| ts_getPropertyNameForPropertyNameNode, | |
| ts_isPropertyNameLiteral, | |
| ts_getTextOfIdentifierOrLiteral, | |
| ts_getEscapedTextOfIdentifierOrLiteral, | |
| ts_getSymbolId, | |
| ts_getPropertyNameForUniqueESSymbol, | |
| ts_getPropertyNameForKnownSymbolName, | |
| ts_getSymbolNameForPrivateIdentifier, | |
| ts_isKnownSymbol, | |
| ts_isESSymbolIdentifier, | |
| ts_isPushOrUnshiftIdentifier, | |
| ts_isParameterDeclaration, | |
| ts_getRootDeclaration, | |
| ts_nodeStartsNewLexicalEnvironment, | |
| ts_getOriginalSourceFile, | |
| ts_getExpressionAssociativity, | |
| ts_getOperatorAssociativity, | |
| ts_getExpressionPrecedence, | |
| ts_getOperator, | |
| ts_getOperatorPrecedence, | |
| ts_getBinaryOperatorPrecedence, | |
| ts_createDiagnosticCollection, | |
| ts_escapeString, | |
| ts_escapeNonAsciiString, | |
| ts_escapeJsxAttributeString, | |
| ts_stripQuotes, | |
| ts_isIntrinsicJsxName, | |
| ts_getIndentString, | |
| ts_getIndentSize, | |
| ts_createTextWriter, | |
| ts_getTrailingSemicolonDeferringWriter, | |
| ts_getResolvedExternalModuleName, | |
| ts_getExternalModuleNameFromDeclaration, | |
| ts_getExternalModuleNameFromPath, | |
| ts_getOwnEmitOutputFilePath, | |
| ts_getDeclarationEmitOutputFilePath, | |
| ts_getDeclarationEmitOutputFilePathWorker, | |
| ts_getSourceFilesToEmit, | |
| ts_sourceFileMayBeEmitted, | |
| ts_getSourceFilePathInNewDir, | |
| ts_getSourceFilePathInNewDirWorker, | |
| ts_writeFile, | |
| ts_getLineOfLocalPosition, | |
| ts_getLineOfLocalPositionFromLineMap, | |
| ts_getFirstConstructorWithBody, | |
| ts_getSetAccessorValueParameter, | |
| ts_getSetAccessorTypeAnnotationNode, | |
| ts_getThisParameter, | |
| ts_parameterIsThisKeyword, | |
| ts_isThisIdentifier, | |
| ts_identifierIsThisKeyword, | |
| ts_getAllAccessorDeclarations, | |
| ts_getEffectiveTypeAnnotationNode, | |
| ts_getTypeAnnotationNode, | |
| ts_getEffectiveReturnTypeNode, | |
| ts_getEffectiveSetAccessorTypeAnnotationNode, | |
| ts_emitNewLineBeforeLeadingComments, | |
| ts_emitNewLineBeforeLeadingCommentsOfPosition, | |
| ts_emitNewLineBeforeLeadingCommentOfPosition, | |
| ts_emitComments, | |
| ts_emitDetachedComments, | |
| ts_writeCommentRange, | |
| ts_hasModifiers, | |
| ts_hasStaticModifier, | |
| ts_hasReadonlyModifier, | |
| ts_getSelectedModifierFlags, | |
| ts_isLogicalOperator, | |
| ts_isAssignmentOperator, | |
| ts_tryGetClassExtendingExpressionWithTypeArguments, | |
| ts_tryGetClassImplementingOrExtendingExpressionWithTypeArguments, | |
| ts_isAssignmentExpression, | |
| ts_isDestructuringAssignment, | |
| ts_isExpressionWithTypeArgumentsInClassExtendsClause, | |
| ts_isEntityNameExpression, | |
| ts_getFirstIdentifier, | |
| ts_isDottedName, | |
| ts_isPropertyAccessEntityNameExpression, | |
| ts_tryGetPropertyAccessOrIdentifierToString, | |
| ts_isPrototypeAccess, | |
| ts_isRightSideOfQualifiedNameOrPropertyAccess, | |
| ts_isEmptyObjectLiteral, | |
| ts_isEmptyArrayLiteral, | |
| ts_getLocalSymbolForExportDefault, | |
| ts_supportedTSExtensionsForExtractExtension, | |
| ts_tryExtractTSExtension, | |
| ts_convertToBase64, | |
| ts_base64encode, | |
| ts_base64decode, | |
| ts_parseConfigFileTextToJson, | |
| ts_readJson, | |
| ts_directoryProbablyExists, | |
| ts_getNewLineCharacter, | |
| ts_createRange, | |
| ts_moveRangeEnd, | |
| ts_moveRangePos, | |
| ts_moveRangePastDecorators, | |
| ts_moveRangePastModifiers, | |
| ts_isCollapsedRange, | |
| ts_createTokenRange, | |
| ts_rangeIsOnSingleLine, | |
| ts_rangeStartPositionsAreOnSameLine, | |
| ts_rangeEndPositionsAreOnSameLine, | |
| ts_rangeStartIsOnSameLineAsRangeEnd, | |
| ts_rangeEndIsOnSameLineAsRangeStart, | |
| ts_isNodeArrayMultiLine, | |
| ts_positionsAreOnSameLine, | |
| ts_getStartPositionOfRange, | |
| ts_isDeclarationNameOfEnumOrNamespace, | |
| ts_getInitializedVariables, | |
| ts_isWatchSet, | |
| ts_getCheckFlags, | |
| ts_getDeclarationModifierFlagsFromSymbol, | |
| ts_skipAlias, | |
| ts_getCombinedLocalAndExportSymbolFlags, | |
| ts_isWriteOnlyAccess, | |
| ts_isWriteAccess, | |
| ts_compareDataObjects, | |
| ts_clearMap, | |
| ts_mutateMapSkippingNewValues, | |
| ts_mutateMap, | |
| ts_isAbstractConstructorType, | |
| ts_isAbstractConstructorSymbol, | |
| ts_getClassLikeDeclarationOfSymbol, | |
| ts_getObjectFlags, | |
| ts_typeHasCallOrConstructSignatures, | |
| ts_forSomeAncestorDirectory, | |
| ts_isUMDExportSymbol, | |
| ts_showModuleSpecifier, | |
| ts_getLastChild, | |
| ts_addToSeen, | |
| ts_isObjectTypeDeclaration, | |
| ts_isBundleFileTextLike, | |
| ts_createNode, | |
| ts_getDotOrQuestionDotToken, | |
| ts_isNamedImportsOrExports, | |
| ts_setObjectAllocator, | |
| ts_formatStringFromArgs, | |
| ts_localizedDiagnosticMessages, | |
| ts_getLocaleSpecificMessage, | |
| ts_createFileDiagnostic, | |
| ts_formatMessage, | |
| ts_createCompilerDiagnosticFromMessageChain, | |
| ts_chainDiagnosticMessages, | |
| ts_concatenateDiagnosticMessageChains, | |
| ts_compareDiagnosticsSkipRelatedInformation, | |
| ts_getEmitScriptTarget, | |
| ts_getEmitModuleKind, | |
| ts_getEmitModuleResolutionKind, | |
| ts_hasJsonModuleEmitEnabled, | |
| ts_unreachableCodeIsError, | |
| ts_unusedLabelIsError, | |
| ts_getAreDeclarationMapsEnabled, | |
| ts_getAllowSyntheticDefaultImports, | |
| ts_getEmitDeclarations, | |
| ts_isIncrementalCompilation, | |
| ts_getStrictOptionValue, | |
| ts_semanticDiagnosticsOptionDeclarations, | |
| ts_compilerOptionsAffectSemanticDiagnostics, | |
| ts_affectsEmitOptionDeclarations, | |
| ts_compilerOptionsAffectEmit, | |
| ts_getCompilerOptionValue, | |
| ts_hasZeroOrOneAsteriskCharacter, | |
| ts_discoverProbableSymlinks, | |
| ts_tryRemoveDirectoryPrefix, | |
| ts_regExpEscape, | |
| ts_commonPackageFolders, | |
| ts_getRegularExpressionForWildcard, | |
| ts_getRegularExpressionsForWildcards, | |
| ts_isImplicitGlob, | |
| ts_getRegexFromPattern, | |
| ts_ensureScriptKind, | |
| ts_getScriptKindFromFileName, | |
| ts_supportedTSExtensions, | |
| ts_supportedTSExtensionsWithJson, | |
| ts_supportedJSExtensions, | |
| ts_supportedJSAndJsonExtensions, | |
| ts_getSupportedExtensions, | |
| ts_getSuppoertedExtensionsWithJsonIfResolveJsonModule, | |
| ts_hasJSFileExtension, | |
| ts_hasTSFileExtension, | |
| ts_isSupportedSourceFileName, | |
| ts_getExtensionPriority, | |
| ts_adjustExtensionPriority, | |
| ts_getNextLowestExtensionPriority, | |
| ts_removeFileExtension, | |
| ts_tryRemoveExtension, | |
| ts_removeExtension, | |
| ts_changeExtension, | |
| ts_tryParsePattern, | |
| ts_extensionIsTS, | |
| ts_resolutionExtensionIsTSOrJson, | |
| ts_extensionFromPath, | |
| ts_isAnySupportedFileExtension, | |
| ts_tryGetExtensionFromPath, | |
| ts_isCheckJsEnabledForFile, | |
| ts_matchPatternOrExact, | |
| ts_sliceAfter, | |
| ts_addRelatedInfo, | |
| ts_minAndMax, | |
| ts_getNodeId, | |
| ts_NodeSet, | |
| ts_NodeMap, | |
| ts_rangeOfNode, | |
| ts_rangeOfTypeParameters, | |
| ts_skipTypeChecking, | |
| ts_isJsonEqual, | |
| ts_getOrUpdate, | |
| ts_pseudoBigIntToString, | |
| ts_isValidTypeOnlyAliasUseSite, | |
| ts_typeOnlyDeclarationIsExport, | |
| ts_isJSDocLikeText, | |
| ts_createSourceFile, | |
| ts_parseIsolatedEntityName, | |
| ts_parseJsonText, | |
| ts_updateSourceFile, | |
| ts_parseIsolatedJSDocComment, | |
| ts_parseJSDocTypeExpressionForTests, | |
| ts_convertToObjectWorker, | |
| ts_isDeclarationFileName, | |
| ts_processCommentPragmas, | |
| ts_processPragmasIntoFields, | |
| ts_tagNamesAreEquivalent, | |
| ts_compileOnSaveCommandLineOption, | |
| ts_libs, | |
| ts_libMap, | |
| ts_optionsForWatch, | |
| ts_commonOptionsWithBuild, | |
| ts_optionDeclarations, | |
| ts_sourceFileAffectingCompilerOptions, | |
| ts_transpileOptionValueCompilerOptions, | |
| ts_buildOpts, | |
| ts_typeAcquisitionDeclarations, | |
| ts_createOptionNameMap, | |
| ts_getOptionsNameMap, | |
| ts_defaultInitCompilerOptions, | |
| ts_convertEnableAutoDiscoveryToEnable, | |
| ts_createCompilerDiagnosticForInvalidCustomType, | |
| ts_parseCustomTypeOption, | |
| ts_parseListTypeOption, | |
| ts_parseCommandLineWorker, | |
| ts_compilerOptionsDidYouMeanDiagnostics, | |
| ts_parseCommandLine, | |
| ts_getOptionFromName, | |
| ts_parseBuildCommand, | |
| ts_getDiagnosticText, | |
| ts_getParsedCommandLineOfConfigFile, | |
| ts_readConfigFile, | |
| ts_readJsonConfigFile, | |
| ts_convertToObject, | |
| ts_convertToTSConfig, | |
| ts_generateTSConfig, | |
| ts_convertToOptionsWithAbsolutePaths, | |
| ts_parseJsonConfigFileContent, | |
| ts_parseJsonSourceFileConfigFileContent, | |
| ts_setConfigFileInOptions, | |
| ts_canJsonReportNoInutFiles, | |
| ts_updateErrorForNoInputFiles, | |
| ts_nodeModuleNameResolver, | |
| ts_convertCompilerOptionsFromJson, | |
| ts_convertTypeAcquisitionFromJson, | |
| ts_getFileNamesFromConfigSpecs, | |
| ts_convertCompilerOptionsForTelemetry, | |
| ts_trace, | |
| ts_isTraceEnabled, | |
| ts_getPackageJsonTypesVersionsPaths, | |
| ts_getEffectiveTypeRoots, | |
| ts_resolveTypeReferenceDirective, | |
| ts_getAutomaticTypeDirectiveNames, | |
| ts_createModuleResolutionCache, | |
| ts_createCacheWithRedirects, | |
| ts_createModuleResolutionCacheWithMaps, | |
| ts_resolveModuleNameFromCache, | |
| ts_resolveModuleName, | |
| ts_tryResolveJSModule, | |
| ts_nodeModulesPathPart, | |
| ts_pathContainsNodeModules, | |
| ts_parsePackageName, | |
| ts_getTypesPackageName, | |
| ts_mangleScopedPackageName, | |
| ts_getPackageNameFromTypesPackageName, | |
| ts_unmangleScopedPackageName, | |
| ts_classicNameResolver, | |
| ts_loadModuleFromGlobalCache, | |
| ts_getModuleInstanceState, | |
| ts_bindSourceFile, | |
| ts_isExportsOrModuleExportsOrAlias, | |
| ts_computeTransformFlagsForNode, | |
| ts_skipOuterExpressions, | |
| ts_getTransformFlagsSubtreeExclusions, | |
| ts_createGetSymbolWalker, | |
| ts_isInstantiatedModule, | |
| ts_getResolutionDiagnostic, | |
| ts_createPrinter, | |
| ts_createKeywordTypeNode, | |
| ts_createTypeReferenceNode, | |
| ts_createLiteralTypeNode, | |
| ts_setEmitFlags, | |
| ts_createLiteral, | |
| ts_createPrefix, | |
| ts_createTrue, | |
| ts_createFalse, | |
| ts_createTypeOperatorNode, | |
| ts_createThis, | |
| ts_createIdentifier, | |
| ts_createInferTypeNode, | |
| ts_createUnionOrIntersectionTypeNode, | |
| ts_createIndexedAccessTypeNode, | |
| ts_createConditionalTypeNode, | |
| ts_createToken, | |
| ts_createMappedTypeNode, | |
| ts_createTypeLiteralNode, | |
| ts_createArrayTypeNode, | |
| ts_createRestTypeNode, | |
| ts_createOptionalTypeNode, | |
| ts_createTupleTypeNode, | |
| ts_createQualifiedName, | |
| ts_createPropertySignature, | |
| ts_setSyntheticLeadingComments, | |
| ts_setCommentRange, | |
| ts_createParameter, | |
| ts_createIndexSignature, | |
| ts_createThisTypeNode, | |
| ts_createTypePredicateNodeWithModifier, | |
| ts_createSignatureDeclaration, | |
| ts_createTypeParameterDeclaration, | |
| ts_getSynthesizedClone, | |
| ts_visitEachChild, | |
| ts_nullTransformationContext, | |
| ts_moduleSpecifiers, | |
| ts_createNodeArray, | |
| ts_createImportTypeNode, | |
| ts_createTypeQueryNode, | |
| ts_createPropertyAccess, | |
| ts_createElementAccess, | |
| ts_createComputedPropertyName, | |
| ts_createProperty, | |
| ts_createExportDeclaration, | |
| ts_createNamedExports, | |
| ts_createExportSpecifier, | |
| ts_createEmptyExports, | |
| ts_createModifiersFromModifierFlags, | |
| ts_createExportAssignment, | |
| ts_createTypeAliasDeclaration, | |
| ts_createHeritageClause, | |
| ts_createInterfaceDeclaration, | |
| ts_createModuleBlock, | |
| ts_createModuleDeclaration, | |
| ts_createEnumDeclaration, | |
| ts_createEnumMember, | |
| ts_setTextRange, | |
| ts_createVariableStatement, | |
| ts_createVariableDeclarationList, | |
| ts_createVariableDeclaration, | |
| ts_createPrivateIdentifier, | |
| ts_createClassDeclaration, | |
| ts_createImportEqualsDeclaration, | |
| ts_createExternalModuleReference, | |
| ts_createNamespaceExportDeclaration, | |
| ts_createImportDeclaration, | |
| ts_createImportClause, | |
| ts_createNamespaceImport, | |
| ts_createNamespaceExport, | |
| ts_createNamedImports, | |
| ts_createImportSpecifier, | |
| ts_createSetAccessor, | |
| ts_createGetAccessor, | |
| ts_visitNode, | |
| ts_getMutableClone, | |
| ts_createUnionTypeNode, | |
| ts_createConstructorTypeNode, | |
| ts_visitNodes, | |
| ts_createFunctionTypeNode, | |
| ts_updateImportTypeNode, | |
| ts_updateLiteralTypeNode, | |
| ts_createConstructor, | |
| ts_createExpressionWithTypeArguments, | |
| ts_getDeclarationName, | |
| ts_resolveTripleslashReference, | |
| ts_findUseStrictPrologue, | |
| ts_isCommaSequence, | |
| ts_createTypeChecker, | |
| ts_signatureHasRestParameter, | |
| ts_signatureHasLiteralTypes, | |
| ts_aggregateTransformFlags, | |
| ts_updateNode, | |
| ts_createNumericLiteral, | |
| ts_createBigIntLiteral, | |
| ts_createStringLiteral, | |
| ts_createRegularExpressionLiteral, | |
| ts_updateIdentifier, | |
| ts_createTempVariable, | |
| ts_createLoopVariable, | |
| ts_createUniqueName, | |
| ts_createOptimisticUniqueName, | |
| ts_createFileLevelUniqueName, | |
| ts_getGeneratedNameForNode, | |
| ts_createSuper, | |
| ts_createNull, | |
| ts_createModifier, | |
| ts_updateQualifiedName, | |
| ts_updateComputedPropertyName, | |
| ts_updateTypeParameterDeclaration, | |
| ts_parenthesizeExpressionForList, | |
| ts_updateParameter, | |
| ts_parenthesizeForAccess, | |
| ts_createDecorator, | |
| ts_updateDecorator, | |
| ts_updatePropertySignature, | |
| ts_updateProperty, | |
| ts_createMethodSignature, | |
| ts_updateMethodSignature, | |
| ts_createMethod, | |
| ts_createObjectDefinePropertyCall, | |
| ts_createPropertyDescriptor, | |
| ts_updateMethod, | |
| ts_updateConstructor, | |
| ts_updateGetAccessor, | |
| ts_updateSetAccessor, | |
| ts_createCallSignature, | |
| ts_updateCallSignature, | |
| ts_createConstructSignature, | |
| ts_updateConstructSignature, | |
| ts_updateIndexSignature, | |
| ts_createTypePredicateNode, | |
| ts_updateTypePredicateNode, | |
| ts_updateTypePredicateNodeWithModifier, | |
| ts_parenthesizeTypeParameters, | |
| ts_updateTypeReferenceNode, | |
| ts_updateFunctionTypeNode, | |
| ts_updateConstructorTypeNode, | |
| ts_updateTypeQueryNode, | |
| ts_updateTypeLiteralNode, | |
| ts_parenthesizeArrayTypeMember, | |
| ts_updateArrayTypeNode, | |
| ts_updateTupleTypeNode, | |
| ts_updateOptionalTypeNode, | |
| ts_updateRestTypeNode, | |
| ts_updateUnionTypeNode, | |
| ts_createIntersectionTypeNode, | |
| ts_updateIntersectionTypeNode, | |
| ts_parenthesizeElementTypeMembers, | |
| ts_parenthesizeConditionalTypeMember, | |
| ts_updateConditionalTypeNode, | |
| ts_updateInferTypeNode, | |
| ts_createParenthesizedType, | |
| ts_updateParenthesizedType, | |
| ts_parenthesizeElementTypeMember, | |
| ts_updateTypeOperatorNode, | |
| ts_updateIndexedAccessTypeNode, | |
| ts_updateMappedTypeNode, | |
| ts_createObjectBindingPattern, | |
| ts_updateObjectBindingPattern, | |
| ts_createArrayBindingPattern, | |
| ts_updateArrayBindingPattern, | |
| ts_createBindingElement, | |
| ts_updateBindingElement, | |
| ts_parenthesizeListElements, | |
| ts_createArrayLiteral, | |
| ts_updateArrayLiteral, | |
| ts_createObjectLiteral, | |
| ts_updateObjectLiteral, | |
| ts_updatePropertyAccess, | |
| ts_createPropertyAccessChain, | |
| ts_updatePropertyAccessChain, | |
| ts_updateElementAccess, | |
| ts_createElementAccessChain, | |
| ts_updateElementAccessChain, | |
| ts_createCall, | |
| ts_updateCall, | |
| ts_createCallChain, | |
| ts_updateCallChain, | |
| ts_parenthesizeForNew, | |
| ts_createNew, | |
| ts_updateNew, | |
| ts_createTaggedTemplate, | |
| ts_updateTaggedTemplate, | |
| ts_parenthesizePrefixOperand, | |
| ts_createTypeAssertion, | |
| ts_updateTypeAssertion, | |
| ts_createParen, | |
| ts_updateParen, | |
| ts_createFunctionExpression, | |
| ts_updateFunctionExpression, | |
| ts_parenthesizeConciseBody, | |
| ts_createArrowFunction, | |
| ts_updateArrowFunction, | |
| ts_createDelete, | |
| ts_updateDelete, | |
| ts_createTypeOf, | |
| ts_updateTypeOf, | |
| ts_createVoid, | |
| ts_updateVoid, | |
| ts_createAwait, | |
| ts_updateAwait, | |
| ts_updatePrefix, | |
| ts_parenthesizePostfixOperand, | |
| ts_createPostfix, | |
| ts_updatePostfix, | |
| ts_parenthesizeBinaryOperand, | |
| ts_createBinary, | |
| ts_updateBinary, | |
| ts_parenthesizeForConditionalHead, | |
| ts_parenthesizeSubexpressionOfConditionalExpression, | |
| ts_createConditional, | |
| ts_updateConditional, | |
| ts_createTemplateExpression, | |
| ts_updateTemplateExpression, | |
| ts_createTemplateHead, | |
| ts_createTemplateMiddle, | |
| ts_createTemplateTail, | |
| ts_createNoSubstitutionTemplateLiteral, | |
| ts_createYield, | |
| ts_updateYield, | |
| ts_createSpread, | |
| ts_updateSpread, | |
| ts_createClassExpression, | |
| ts_updateClassExpression, | |
| ts_createOmittedExpression, | |
| ts_updateExpressionWithTypeArguments, | |
| ts_createAsExpression, | |
| ts_updateAsExpression, | |
| ts_createNonNullExpression, | |
| ts_updateNonNullExpression, | |
| ts_createMetaProperty, | |
| ts_updateMetaProperty, | |
| ts_createTemplateSpan, | |
| ts_updateTemplateSpan, | |
| ts_createSemicolonClassElement, | |
| ts_createBlock, | |
| ts_updateBlock, | |
| ts_updateVariableStatement, | |
| ts_createEmptyStatement, | |
| ts_parenthesizeExpressionForExpressionStatement, | |
| ts_createExpressionStatement, | |
| ts_updateExpressionStatement, | |
| ts_createStatement, | |
| ts_updateStatement, | |
| ts_createIf, | |
| ts_updateIf, | |
| ts_createDo, | |
| ts_updateDo, | |
| ts_createWhile, | |
| ts_updateWhile, | |
| ts_createFor, | |
| ts_updateFor, | |
| ts_createForIn, | |
| ts_updateForIn, | |
| ts_createForOf, | |
| ts_updateForOf, | |
| ts_createContinue, | |
| ts_updateContinue, | |
| ts_createBreak, | |
| ts_updateBreak, | |
| ts_createReturn, | |
| ts_updateReturn, | |
| ts_createWith, | |
| ts_updateWith, | |
| ts_createSwitch, | |
| ts_updateSwitch, | |
| ts_createLabel, | |
| ts_updateLabel, | |
| ts_createThrow, | |
| ts_updateThrow, | |
| ts_createTry, | |
| ts_updateTry, | |
| ts_createDebuggerStatement, | |
| ts_updateVariableDeclaration, | |
| ts_createTypeScriptVariableDeclaration, | |
| ts_updateTypeScriptVariableDeclaration, | |
| ts_updateVariableDeclarationList, | |
| ts_createFunctionDeclaration, | |
| ts_updateFunctionDeclaration, | |
| ts_updateClassDeclaration, | |
| ts_updateInterfaceDeclaration, | |
| ts_updateTypeAliasDeclaration, | |
| ts_updateEnumDeclaration, | |
| ts_updateModuleDeclaration, | |
| ts_updateModuleBlock, | |
| ts_createCaseBlock, | |
| ts_updateCaseBlock, | |
| ts_updateNamespaceExportDeclaration, | |
| ts_updateImportEqualsDeclaration, | |
| ts_updateImportDeclaration, | |
| ts_updateImportClause, | |
| ts_updateNamespaceImport, | |
| ts_updateNamespaceExport, | |
| ts_updateNamedImports, | |
| ts_updateImportSpecifier, | |
| ts_parenthesizeDefaultExpression, | |
| ts_updateExportAssignment, | |
| ts_updateExportDeclaration, | |
| ts_updateNamedExports, | |
| ts_updateExportSpecifier, | |
| ts_updateExternalModuleReference, | |
| ts_createJSDocTypeExpression, | |
| ts_createJSDocTypeTag, | |
| ts_createJSDocReturnTag, | |
| ts_createJSDocThisTag, | |
| ts_createJSDocParamTag, | |
| ts_createJSDocComment, | |
| ts_createJsxElement, | |
| ts_updateJsxElement, | |
| ts_createJsxSelfClosingElement, | |
| ts_updateJsxSelfClosingElement, | |
| ts_createJsxOpeningElement, | |
| ts_updateJsxOpeningElement, | |
| ts_createJsxClosingElement, | |
| ts_updateJsxClosingElement, | |
| ts_createJsxFragment, | |
| ts_createJsxText, | |
| ts_updateJsxText, | |
| ts_createJsxOpeningFragment, | |
| ts_createJsxJsxClosingFragment, | |
| ts_updateJsxFragment, | |
| ts_createJsxAttribute, | |
| ts_updateJsxAttribute, | |
| ts_createJsxAttributes, | |
| ts_updateJsxAttributes, | |
| ts_createJsxSpreadAttribute, | |
| ts_updateJsxSpreadAttribute, | |
| ts_createJsxExpression, | |
| ts_updateJsxExpression, | |
| ts_createCaseClause, | |
| ts_updateCaseClause, | |
| ts_createDefaultClause, | |
| ts_updateDefaultClause, | |
| ts_updateHeritageClause, | |
| ts_createCatchClause, | |
| ts_updateCatchClause, | |
| ts_createPropertyAssignment, | |
| ts_updatePropertyAssignment, | |
| ts_createShorthandPropertyAssignment, | |
| ts_updateShorthandPropertyAssignment, | |
| ts_createSpreadAssignment, | |
| ts_updateSpreadAssignment, | |
| ts_updateEnumMember, | |
| ts_updateSourceFileNode, | |
| ts_createNotEmittedStatement, | |
| ts_createEndOfDeclarationMarker, | |
| ts_createMergeDeclarationMarker, | |
| ts_createPartiallyEmittedExpression, | |
| ts_updatePartiallyEmittedExpression, | |
| ts_createCommaList, | |
| ts_updateCommaList, | |
| ts_createSyntheticReferenceExpression, | |
| ts_updateSyntheticReferenceExpression, | |
| ts_createBundle, | |
| ts_valuesHelper, | |
| ts_readHelper, | |
| ts_spreadHelper, | |
| ts_spreadArraysHelper, | |
| ts_restHelper, | |
| ts_decorateHelper, | |
| ts_metadataHelper, | |
| ts_paramHelper, | |
| ts_awaiterHelper, | |
| ts_assignHelper, | |
| ts_awaitHelper, | |
| ts_asyncGeneratorHelper, | |
| ts_asyncDelegator, | |
| ts_asyncValues, | |
| ts_extendsHelper, | |
| ts_templateObjectHelper, | |
| ts_generatorHelper, | |
| ts_importStarHelper, | |
| ts_importDefaultHelper, | |
| ts_classPrivateFieldGetHelper, | |
| ts_classPrivateFieldSetHelper, | |
| ts_createUnparsedSourceFile, | |
| ts_getBuildInfo, | |
| ts_createInputFiles, | |
| ts_updateBundle, | |
| ts_createImmediatelyInvokedFunctionExpression, | |
| ts_createImmediatelyInvokedArrowFunction, | |
| ts_createComma, | |
| ts_createLessThan, | |
| ts_createAssignment, | |
| ts_createStrictEquality, | |
| ts_createStrictInequality, | |
| ts_createAdd, | |
| ts_createSubtract, | |
| ts_createPostfixIncrement, | |
| ts_createLogicalAnd, | |
| ts_createLogicalOr, | |
| ts_createNullishCoalesce, | |
| ts_createLogicalNot, | |
| ts_createVoidZero, | |
| ts_createExportDefault, | |
| ts_createExternalModuleExport, | |
| ts_disposeEmitNodes, | |
| ts_getOrCreateEmitNode, | |
| ts_removeAllComments, | |
| ts_addEmitFlags, | |
| ts_getSourceMapRange, | |
| ts_setSourceMapRange, | |
| ts_createSourceMapSource, | |
| ts_getTokenSourceMapRange, | |
| ts_setTokenSourceMapRange, | |
| ts_getStartsOnNewLine, | |
| ts_setStartsOnNewLine, | |
| ts_getCommentRange, | |
| ts_getSyntheticLeadingComments, | |
| ts_addSyntheticLeadingComment, | |
| ts_getSyntheticTrailingComments, | |
| ts_setSyntheticTrailingComments, | |
| ts_addSyntheticTrailingComment, | |
| ts_moveSyntheticComments, | |
| ts_getConstantValue, | |
| ts_setConstantValue, | |
| ts_addEmitHelper, | |
| ts_addEmitHelpers, | |
| ts_removeEmitHelper, | |
| ts_getEmitHelpers, | |
| ts_moveEmitHelpers, | |
| ts_compareEmitHelpers, | |
| ts_setOriginalNode, | |
| ts_createTypeCheck, | |
| ts_createMemberAccessForPropertyName, | |
| ts_createFunctionCall, | |
| ts_createFunctionApply, | |
| ts_createArraySlice, | |
| ts_createArrayConcat, | |
| ts_createMathPow, | |
| ts_createExpressionForJsxElement, | |
| ts_createExpressionForJsxFragment, | |
| ts_getUnscopedHelperName, | |
| ts_createValuesHelper, | |
| ts_createReadHelper, | |
| ts_createSpreadHelper, | |
| ts_createSpreadArraysHelper, | |
| ts_createForOfBindingStatement, | |
| ts_insertLeadingStatement, | |
| ts_restoreEnclosingLabel, | |
| ts_createCallBinding, | |
| ts_inlineExpressions, | |
| ts_createExpressionFromEntityName, | |
| ts_createExpressionForPropertyName, | |
| ts_createExpressionForObjectLiteralElementLike, | |
| ts_getInternalName, | |
| ts_isInternalName, | |
| ts_getLocalName, | |
| ts_isLocalName, | |
| ts_getExportName, | |
| ts_isExportName, | |
| ts_getExternalModuleOrNamespaceExportName, | |
| ts_getNamespaceMemberName, | |
| ts_convertToFunctionBody, | |
| ts_convertFunctionDeclarationToExpression, | |
| ts_addPrologue, | |
| ts_addStandardPrologue, | |
| ts_addCustomPrologue, | |
| ts_ensureUseStrict, | |
| ts_getLeftmostExpression, | |
| ts_isOuterExpression, | |
| ts_skipAssertions, | |
| ts_recreateOuterExpressions, | |
| ts_startOnNewLine, | |
| ts_getExternalHelpersModuleName, | |
| ts_hasRecordedExternalHelpers, | |
| ts_createExternalHelpersImportDeclarationIfNeeded, | |
| ts_getOrCreateExternalHelpersModuleNameIfNeeded, | |
| ts_getLocalNameForExternalImport, | |
| ts_getExternalModuleNameLiteral, | |
| ts_tryGetModuleNameFromFile, | |
| ts_getInitializerOfBindingOrAssignmentElement, | |
| ts_getTargetOfBindingOrAssignmentElement, | |
| ts_getRestIndicatorOfBindingOrAssignmentElement, | |
| ts_getPropertyNameOfBindingOrAssignmentElement, | |
| ts_tryGetPropertyNameOfBindingOrAssignmentElement, | |
| ts_getElementsOfBindingOrAssignmentPattern, | |
| ts_convertToArrayAssignmentElement, | |
| ts_convertToObjectAssignmentElement, | |
| ts_convertToAssignmentPattern, | |
| ts_convertToObjectAssignmentPattern, | |
| ts_convertToArrayAssignmentPattern, | |
| ts_convertToAssignmentElementTarget, | |
| ts_mergeLexicalEnvironment, | |
| ts_visitLexicalEnvironment, | |
| ts_visitParameterList, | |
| ts_visitFunctionBody, | |
| ts_liftToBlock, | |
| ts_reduceEachChild, | |
| ts_createSourceMapGenerator, | |
| ts_getLineInfo, | |
| ts_tryGetSourceMappingURL, | |
| ts_isRawSourceMap, | |
| ts_tryParseRawSourceMap, | |
| ts_decodeMappings, | |
| ts_sameMapping, | |
| ts_isSourceMapping, | |
| ts_createDocumentPositionMapper, | |
| ts_identitySourceMapConsumer, | |
| ts_getOriginalNodeId, | |
| ts_chainBundle, | |
| ts_getExportNeedsImportStarHelper, | |
| ts_getImportNeedsImportStarHelper, | |
| ts_getImportNeedsImportDefaultHelper, | |
| ts_collectExternalModuleInfo, | |
| ts_isSimpleCopiableExpression, | |
| ts_isSimpleInlineableExpression, | |
| ts_isCompoundAssignment, | |
| ts_getNonAssignmentOperatorForCompoundAssignment, | |
| ts_addPrologueDirectivesAndInitialSuperCall, | |
| ts_helperString, | |
| ts_getProperties, | |
| ts_isInitializedProperty, | |
| ts_flattenDestructuringAssignment, | |
| ts_flattenDestructuringBinding, | |
| ts_transformTypeScript, | |
| ts_transformClassFields, | |
| ts_advancedAsyncSuperHelper, | |
| ts_asyncSuperHelper, | |
| ts_transformES2017, | |
| ts_createSuperAccessVariableStatement, | |
| ts_transformES2018, | |
| ts_createAssignHelper, | |
| ts_transformES2019, | |
| ts_transformES2020, | |
| ts_transformESNext, | |
| ts_transformJsx, | |
| ts_transformES2016, | |
| ts_transformES2015, | |
| ts_transformES5, | |
| ts_transformGenerators, | |
| ts_transformModule, | |
| ts_transformSystemModule, | |
| ts_transformECMAScriptModule, | |
| ts_canProduceDiagnostics, | |
| ts_createGetSymbolAccessibilityDiagnosticForNodeName, | |
| ts_createGetSymbolAccessibilityDiagnosticForNode, | |
| ts_transformNodes, | |
| ts_getDeclarationDiagnostics, | |
| ts_isInternalDeclaration, | |
| ts_getOutputPathsFor, | |
| ts_transformDeclarations, | |
| ts_noTransformers, | |
| ts_getTransformers, | |
| ts_noEmitSubstitution, | |
| ts_noEmitNotification, | |
| ts_isBuildInfoFile, | |
| ts_forEachEmittedFile, | |
| ts_getTsBuildInfoEmitOutputFilePath, | |
| ts_getOutputPathsForBundle, | |
| ts_getOutputExtension, | |
| ts_getOutputDeclarationFileName, | |
| ts_getAllProjectOutputs, | |
| ts_getOutputFileNames, | |
| ts_getFirstProjectOutput, | |
| ts_emitFiles, | |
| ts_getBuildInfoText, | |
| ts_notImplementedResolver, | |
| ts_createPrependNodes, | |
| ts_emitUsingBuildInfo, | |
| ts_createCachedDirectoryStructureHost, | |
| ts_ConfigFileProgramReloadLevel, | |
| ts_updateMissingFilePathsWatch, | |
| ts_updateWatchingWildcardDirectories, | |
| ts_isEmittedFileOfProgram, | |
| ts_WatchLogLevel, | |
| ts_getWatchFactory, | |
| ts_findConfigFile, | |
| ts_computeCommonSourceDirectoryOfFilenames, | |
| ts_createCompilerHost, | |
| ts_createCompilerHostWorker, | |
| ts_changeCompilerHostLikeToUseCache, | |
| ts_getPreEmitDiagnostics, | |
| ts_formatDiagnostics, | |
| ts_formatDiagnostic, | |
| ts_ForegroundColorEscapeSequences, | |
| ts_formatColorAndReset, | |
| ts_formatLocation, | |
| ts_formatDiagnosticsWithColorAndContext, | |
| ts_flattenDiagnosticMessageText, | |
| ts_loadWithLocalCache, | |
| ts_inferredTypesContainingFile, | |
| ts_isProgramUptoDate, | |
| ts_getConfigFileParsingDiagnostics, | |
| ts_createProgram, | |
| ts_handleNoEmitOptions, | |
| ts_parseConfigHostFromCompilerHostLike, | |
| ts_resolveConfigFileProjectName, | |
| ts_resolveProjectReferencePath, | |
| ts_getFileEmitOutput, | |
| ts_BuilderState, | |
| ts_cloneMapOrUndefined, | |
| ts_BuilderProgramKind, | |
| ts_getBuilderCreationParameters, | |
| ts_createBuilderProgram, | |
| ts_createBuildProgramUsingProgramBuildInfo, | |
| ts_createRedirectedBuilderProgram, | |
| ts_createSemanticDiagnosticsBuilderProgram, | |
| ts_createEmitAndSemanticDiagnosticsBuilderProgram, | |
| ts_createAbstractBuilder, | |
| ts_removeIgnoredPath, | |
| ts_canWatchDirectory, | |
| ts_maxNumberOfFilesToIterateForInvalidation, | |
| ts_createResolutionCache, | |
| ts_createDiagnosticReporter, | |
| ts_screenStartingMessageCodes, | |
| ts_getLocaleTimeString, | |
| ts_createWatchStatusReporter, | |
| ts_parseConfigFileWithSystem, | |
| ts_getErrorCountForSummary, | |
| ts_getWatchErrorSummaryDiagnosticMessage, | |
| ts_getErrorSummaryText, | |
| ts_listFiles, | |
| ts_emitFilesAndReportErrors, | |
| ts_emitFilesAndReportErrorsAndGetExitStatus, | |
| ts_noopFileWatcher, | |
| ts_createWatchHost, | |
| ts_WatchType, | |
| ts_createWatchFactory, | |
| ts_createCompilerHostFromProgramHost, | |
| ts_setGetSourceFileAsHashVersioned, | |
| ts_createProgramHost, | |
| ts_createWatchCompilerHostOfConfigFile, | |
| ts_createWatchCompilerHostOfFilesAndCompilerOptions, | |
| ts_createIncrementalCompilerHost, | |
| ts_createIncrementalProgram, | |
| ts_performIncrementalCompilation, | |
| ts_readBuilderProgram, | |
| ts_createWatchCompilerHost, | |
| ts_createWatchProgram, | |
| ts_UpToDateStatusType, | |
| ts_isCircularBuildOrder, | |
| ts_getBuildOrderFromAnyBuildOrder, | |
| ts_createBuilderStatusReporter, | |
| ts_createSolutionBuilderHost, | |
| ts_createSolutionBuilderWithWatchHost, | |
| ts_createSolutionBuilder, | |
| ts_createSolutionBuilderWithWatch, | |
| ts_InvalidatedProjectKind, | |
| ts_isBuild, | |
| ts_executeCommandLine; | |
| /*! ***************************************************************************** | |
| 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. | |
| ***************************************************************************** */ | |
| "use strict"; | |
| var __spreadArrays = (this && this.__spreadArrays) || function () { | |
| for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length; | |
| for (var r = Array(s), k = 0, i = 0; i < il; i++) | |
| for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) | |
| r[k] = a[j]; | |
| return r; | |
| }; | |
| var __assign = (this && this.__assign) || function () { | |
| __assign = Object.assign || function(t) { | |
| for (var s, i = 1, n = arguments.length; i < n; i++) { | |
| s = arguments[i]; | |
| for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | |
| t[p] = s[p]; | |
| } | |
| return t; | |
| }; | |
| return __assign.apply(this, arguments); | |
| }; | |
| var __generator = (this && this.__generator) || function (thisArg, body) { | |
| var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; | |
| return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; | |
| function verb(n) { return function (v) { return step([n, v]); }; } | |
| function step(op) { | |
| if (f) throw new TypeError("Generator is already executing."); | |
| while (_) try { | |
| if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; | |
| if (y = 0, t) op = [op[0] & 2, t.value]; | |
| switch (op[0]) { | |
| case 0: case 1: t = op; break; | |
| case 4: _.label++; return { value: op[1], done: false }; | |
| case 5: _.label++; y = op[1]; op = [0]; continue; | |
| case 7: op = _.ops.pop(); _.trys.pop(); continue; | |
| default: | |
| if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } | |
| if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } | |
| if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } | |
| if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } | |
| if (t[2]) _.ops.pop(); | |
| _.trys.pop(); continue; | |
| } | |
| op = body.call(thisArg, _); | |
| } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } | |
| if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; | |
| } | |
| }; | |
| var __makeTemplateObject = (this && this.__makeTemplateObject) || function (cooked, raw) { | |
| if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; } | |
| return cooked; | |
| }; | |
| var ts; | |
| (function (ts) { | |
| ts_versionMajorMinor = "3.8"; | |
| ts_version = "3.8.3"; | |
| function tryGetNativeMap() { | |
| return typeof Map !== "undefined" && "entries" in Map.prototype ? Map : undefined; | |
| } | |
| ts_tryGetNativeMap = tryGetNativeMap; | |
| ts_Map = tryGetNativeMap() || (function () { | |
| if (typeof ts_createMapShim === "function") { | |
| return ts_createMapShim(); | |
| } | |
| throw new Error("TypeScript requires an environment that provides a compatible native Map implementation."); | |
| })(); | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| ts_emptyArray = []; | |
| function createMap() { | |
| return new ts_Map(); | |
| } | |
| ts_createMap = createMap; | |
| function createMapFromEntries(entries) { | |
| var map = createMap(); | |
| for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) { | |
| var _a = entries_1[_i], key = _a[0], value = _a[1]; | |
| map.set(key, value); | |
| } | |
| return map; | |
| } | |
| ts_createMapFromEntries = createMapFromEntries; | |
| function createMapFromTemplate(template) { | |
| var map = new ts_Map(); | |
| for (var key in template) { | |
| if (hasOwnProperty.call(template, key)) { | |
| map.set(key, template[key]); | |
| } | |
| } | |
| return map; | |
| } | |
| ts_createMapFromTemplate = createMapFromTemplate; | |
| function length(array) { | |
| return array ? array.length : 0; | |
| } | |
| ts_length = length; | |
| function forEach(array, callback) { | |
| if (array) { | |
| for (var i = 0; i < array.length; i++) { | |
| var result = callback(array[i], i); | |
| if (result) { | |
| return result; | |
| } | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_forEach = forEach; | |
| function forEachRight(array, callback) { | |
| if (array) { | |
| for (var i = array.length - 1; i >= 0; i--) { | |
| var result = callback(array[i], i); | |
| if (result) { | |
| return result; | |
| } | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_forEachRight = forEachRight; | |
| function firstDefined(array, callback) { | |
| if (array === undefined) { | |
| return undefined; | |
| } | |
| for (var i = 0; i < array.length; i++) { | |
| var result = callback(array[i], i); | |
| if (result !== undefined) { | |
| return result; | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_firstDefined = firstDefined; | |
| function firstDefinedIterator(iter, callback) { | |
| while (true) { | |
| var iterResult = iter.next(); | |
| if (iterResult.done) { | |
| return undefined; | |
| } | |
| var result = callback(iterResult.value); | |
| if (result !== undefined) { | |
| return result; | |
| } | |
| } | |
| } | |
| ts_firstDefinedIterator = firstDefinedIterator; | |
| function zipWith(arrayA, arrayB, callback) { | |
| var result = []; | |
| ts_Debug.assertEqual(arrayA.length, arrayB.length); | |
| for (var i = 0; i < arrayA.length; i++) { | |
| result.push(callback(arrayA[i], arrayB[i], i)); | |
| } | |
| return result; | |
| } | |
| ts_zipWith = zipWith; | |
| function zipToIterator(arrayA, arrayB) { | |
| ts_Debug.assertEqual(arrayA.length, arrayB.length); | |
| var i = 0; | |
| return { | |
| next: function () { | |
| if (i === arrayA.length) { | |
| return { value: undefined, done: true }; | |
| } | |
| i++; | |
| return { value: [arrayA[i - 1], arrayB[i - 1]], done: false }; | |
| } | |
| }; | |
| } | |
| ts_zipToIterator = zipToIterator; | |
| function zipToMap(keys, values) { | |
| ts_Debug.assert(keys.length === values.length); | |
| var map = createMap(); | |
| for (var i = 0; i < keys.length; ++i) { | |
| map.set(keys[i], values[i]); | |
| } | |
| return map; | |
| } | |
| ts_zipToMap = zipToMap; | |
| function every(array, callback) { | |
| if (array) { | |
| for (var i = 0; i < array.length; i++) { | |
| if (!callback(array[i], i)) { | |
| return false; | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| ts_every = every; | |
| function find(array, predicate) { | |
| for (var i = 0; i < array.length; i++) { | |
| var value = array[i]; | |
| if (predicate(value, i)) { | |
| return value; | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_find = find; | |
| function findLast(array, predicate) { | |
| for (var i = array.length - 1; i >= 0; i--) { | |
| var value = array[i]; | |
| if (predicate(value, i)) { | |
| return value; | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_findLast = findLast; | |
| function findIndex(array, predicate, startIndex) { | |
| for (var i = startIndex || 0; i < array.length; i++) { | |
| if (predicate(array[i], i)) { | |
| return i; | |
| } | |
| } | |
| return -1; | |
| } | |
| ts_findIndex = findIndex; | |
| function findLastIndex(array, predicate, startIndex) { | |
| for (var i = startIndex === undefined ? array.length - 1 : startIndex; i >= 0; i--) { | |
| if (predicate(array[i], i)) { | |
| return i; | |
| } | |
| } | |
| return -1; | |
| } | |
| ts_findLastIndex = findLastIndex; | |
| function findMap(array, callback) { | |
| for (var i = 0; i < array.length; i++) { | |
| var result = callback(array[i], i); | |
| if (result) { | |
| return result; | |
| } | |
| } | |
| return ts_Debug.fail(); | |
| } | |
| ts_findMap = findMap; | |
| function contains(array, value, equalityComparer) { | |
| if (equalityComparer === void 0) { equalityComparer = equateValues; } | |
| if (array) { | |
| for (var _i = 0, array_1 = array; _i < array_1.length; _i++) { | |
| var v = array_1[_i]; | |
| if (equalityComparer(v, value)) { | |
| return true; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| ts_contains = contains; | |
| function arraysEqual(a, b, equalityComparer) { | |
| if (equalityComparer === void 0) { equalityComparer = equateValues; } | |
| return a.length === b.length && a.every(function (x, i) { return equalityComparer(x, b[i]); }); | |
| } | |
| ts_arraysEqual = arraysEqual; | |
| function indexOfAnyCharCode(text, charCodes, start) { | |
| for (var i = start || 0; i < text.length; i++) { | |
| if (contains(charCodes, text.charCodeAt(i))) { | |
| return i; | |
| } | |
| } | |
| return -1; | |
| } | |
| ts_indexOfAnyCharCode = indexOfAnyCharCode; | |
| function countWhere(array, predicate) { | |
| var count = 0; | |
| if (array) { | |
| for (var i = 0; i < array.length; i++) { | |
| var v = array[i]; | |
| if (predicate(v, i)) { | |
| count++; | |
| } | |
| } | |
| } | |
| return count; | |
| } | |
| ts_countWhere = countWhere; | |
| function filter(array, f) { | |
| if (array) { | |
| var len = array.length; | |
| var i = 0; | |
| while (i < len && f(array[i])) | |
| i++; | |
| if (i < len) { | |
| var result = array.slice(0, i); | |
| i++; | |
| while (i < len) { | |
| var item = array[i]; | |
| if (f(item)) { | |
| result.push(item); | |
| } | |
| i++; | |
| } | |
| return result; | |
| } | |
| } | |
| return array; | |
| } | |
| ts_filter = filter; | |
| function filterMutate(array, f) { | |
| var outIndex = 0; | |
| for (var i = 0; i < array.length; i++) { | |
| if (f(array[i], i, array)) { | |
| array[outIndex] = array[i]; | |
| outIndex++; | |
| } | |
| } | |
| array.length = outIndex; | |
| } | |
| ts_filterMutate = filterMutate; | |
| function clear(array) { | |
| array.length = 0; | |
| } | |
| ts_clear = clear; | |
| function map(array, f) { | |
| var result; | |
| if (array) { | |
| result = []; | |
| for (var i = 0; i < array.length; i++) { | |
| result.push(f(array[i], i)); | |
| } | |
| } | |
| return result; | |
| } | |
| ts_map = map; | |
| function mapIterator(iter, mapFn) { | |
| return { | |
| next: function () { | |
| var iterRes = iter.next(); | |
| return iterRes.done ? iterRes : { value: mapFn(iterRes.value), done: false }; | |
| } | |
| }; | |
| } | |
| ts_mapIterator = mapIterator; | |
| function sameMap(array, f) { | |
| if (array) { | |
| for (var i = 0; i < array.length; i++) { | |
| var item = array[i]; | |
| var mapped = f(item, i); | |
| if (item !== mapped) { | |
| var result = array.slice(0, i); | |
| result.push(mapped); | |
| for (i++; i < array.length; i++) { | |
| result.push(f(array[i], i)); | |
| } | |
| return result; | |
| } | |
| } | |
| } | |
| return array; | |
| } | |
| ts_sameMap = sameMap; | |
| function flatten(array) { | |
| var result = []; | |
| for (var _i = 0, array_2 = array; _i < array_2.length; _i++) { | |
| var v = array_2[_i]; | |
| if (v) { | |
| if (isArray(v)) { | |
| addRange(result, v); | |
| } | |
| else { | |
| result.push(v); | |
| } | |
| } | |
| } | |
| return result; | |
| } | |
| ts_flatten = flatten; | |
| function flatMap(array, mapfn) { | |
| var result; | |
| if (array) { | |
| for (var i = 0; i < array.length; i++) { | |
| var v = mapfn(array[i], i); | |
| if (v) { | |
| if (isArray(v)) { | |
| result = addRange(result, v); | |
| } | |
| else { | |
| result = append(result, v); | |
| } | |
| } | |
| } | |
| } | |
| return result || ts_emptyArray; | |
| } | |
| ts_flatMap = flatMap; | |
| function flatMapToMutable(array, mapfn) { | |
| var result = []; | |
| if (array) { | |
| for (var i = 0; i < array.length; i++) { | |
| var v = mapfn(array[i], i); | |
| if (v) { | |
| if (isArray(v)) { | |
| addRange(result, v); | |
| } | |
| else { | |
| result.push(v); | |
| } | |
| } | |
| } | |
| } | |
| return result; | |
| } | |
| ts_flatMapToMutable = flatMapToMutable; | |
| function flatMapIterator(iter, mapfn) { | |
| var first = iter.next(); | |
| if (first.done) { | |
| return ts_emptyIterator; | |
| } | |
| var currentIter = getIterator(first.value); | |
| return { | |
| next: function () { | |
| while (true) { | |
| var currentRes = currentIter.next(); | |
| if (!currentRes.done) { | |
| return currentRes; | |
| } | |
| var iterRes = iter.next(); | |
| if (iterRes.done) { | |
| return iterRes; | |
| } | |
| currentIter = getIterator(iterRes.value); | |
| } | |
| }, | |
| }; | |
| function getIterator(x) { | |
| var res = mapfn(x); | |
| return res === undefined ? ts_emptyIterator : isArray(res) ? arrayIterator(res) : res; | |
| } | |
| } | |
| ts_flatMapIterator = flatMapIterator; | |
| function sameFlatMap(array, mapfn) { | |
| var result; | |
| if (array) { | |
| for (var i = 0; i < array.length; i++) { | |
| var item = array[i]; | |
| var mapped = mapfn(item, i); | |
| if (result || item !== mapped || isArray(mapped)) { | |
| if (!result) { | |
| result = array.slice(0, i); | |
| } | |
| if (isArray(mapped)) { | |
| addRange(result, mapped); | |
| } | |
| else { | |
| result.push(mapped); | |
| } | |
| } | |
| } | |
| } | |
| return result || array; | |
| } | |
| ts_sameFlatMap = sameFlatMap; | |
| function mapAllOrFail(array, mapFn) { | |
| var result = []; | |
| for (var i = 0; i < array.length; i++) { | |
| var mapped = mapFn(array[i], i); | |
| if (mapped === undefined) { | |
| return undefined; | |
| } | |
| result.push(mapped); | |
| } | |
| return result; | |
| } | |
| ts_mapAllOrFail = mapAllOrFail; | |
| function mapDefined(array, mapFn) { | |
| var result = []; | |
| if (array) { | |
| for (var i = 0; i < array.length; i++) { | |
| var mapped = mapFn(array[i], i); | |
| if (mapped !== undefined) { | |
| result.push(mapped); | |
| } | |
| } | |
| } | |
| return result; | |
| } | |
| ts_mapDefined = mapDefined; | |
| function mapDefinedIterator(iter, mapFn) { | |
| return { | |
| next: function () { | |
| while (true) { | |
| var res = iter.next(); | |
| if (res.done) { | |
| return res; | |
| } | |
| var value = mapFn(res.value); | |
| if (value !== undefined) { | |
| return { value: value, done: false }; | |
| } | |
| } | |
| } | |
| }; | |
| } | |
| ts_mapDefinedIterator = mapDefinedIterator; | |
| function mapDefinedMap(map, mapValue, mapKey) { | |
| if (mapKey === void 0) { mapKey = identity; } | |
| var result = createMap(); | |
| map.forEach(function (value, key) { | |
| var mapped = mapValue(value, key); | |
| if (mapped !== undefined) { | |
| result.set(mapKey(key), mapped); | |
| } | |
| }); | |
| return result; | |
| } | |
| ts_mapDefinedMap = mapDefinedMap; | |
| ts_emptyIterator = { next: function () { return ({ value: undefined, done: true }); } }; | |
| function singleIterator(value) { | |
| var done = false; | |
| return { | |
| next: function () { | |
| var wasDone = done; | |
| done = true; | |
| return wasDone ? { value: undefined, done: true } : { value: value, done: false }; | |
| } | |
| }; | |
| } | |
| ts_singleIterator = singleIterator; | |
| function spanMap(array, keyfn, mapfn) { | |
| var result; | |
| if (array) { | |
| result = []; | |
| var len = array.length; | |
| var previousKey = void 0; | |
| var key = void 0; | |
| var start = 0; | |
| var pos = 0; | |
| while (start < len) { | |
| while (pos < len) { | |
| var value = array[pos]; | |
| key = keyfn(value, pos); | |
| if (pos === 0) { | |
| previousKey = key; | |
| } | |
| else if (key !== previousKey) { | |
| break; | |
| } | |
| pos++; | |
| } | |
| if (start < pos) { | |
| var v = mapfn(array.slice(start, pos), previousKey, start, pos); | |
| if (v) { | |
| result.push(v); | |
| } | |
| start = pos; | |
| } | |
| previousKey = key; | |
| pos++; | |
| } | |
| } | |
| return result; | |
| } | |
| ts_spanMap = spanMap; | |
| function mapEntries(map, f) { | |
| if (!map) { | |
| return undefined; | |
| } | |
| var result = createMap(); | |
| map.forEach(function (value, key) { | |
| var _a = f(key, value), newKey = _a[0], newValue = _a[1]; | |
| result.set(newKey, newValue); | |
| }); | |
| return result; | |
| } | |
| ts_mapEntries = mapEntries; | |
| function some(array, predicate) { | |
| if (array) { | |
| if (predicate) { | |
| for (var _i = 0, array_3 = array; _i < array_3.length; _i++) { | |
| var v = array_3[_i]; | |
| if (predicate(v)) { | |
| return true; | |
| } | |
| } | |
| } | |
| else { | |
| return array.length > 0; | |
| } | |
| } | |
| return false; | |
| } | |
| ts_some = some; | |
| function getRangesWhere(arr, pred, cb) { | |
| var start; | |
| for (var i = 0; i < arr.length; i++) { | |
| if (pred(arr[i])) { | |
| start = start === undefined ? i : start; | |
| } | |
| else { | |
| if (start !== undefined) { | |
| cb(start, i); | |
| start = undefined; | |
| } | |
| } | |
| } | |
| if (start !== undefined) | |
| cb(start, arr.length); | |
| } | |
| ts_getRangesWhere = getRangesWhere; | |
| function concatenate(array1, array2) { | |
| if (!some(array2)) | |
| return array1; | |
| if (!some(array1)) | |
| return array2; | |
| return __spreadArrays(array1, array2); | |
| } | |
| ts_concatenate = concatenate; | |
| function selectIndex(_, i) { | |
| return i; | |
| } | |
| function indicesOf(array) { | |
| return array.map(selectIndex); | |
| } | |
| ts_indicesOf = indicesOf; | |
| function deduplicateRelational(array, equalityComparer, comparer) { | |
| var indices = indicesOf(array); | |
| stableSortIndices(array, indices, comparer); | |
| var last = array[indices[0]]; | |
| var deduplicated = [indices[0]]; | |
| for (var i = 1; i < indices.length; i++) { | |
| var index = indices[i]; | |
| var item = array[index]; | |
| if (!equalityComparer(last, item)) { | |
| deduplicated.push(index); | |
| last = item; | |
| } | |
| } | |
| deduplicated.sort(); | |
| return deduplicated.map(function (i) { return array[i]; }); | |
| } | |
| function deduplicateEquality(array, equalityComparer) { | |
| var result = []; | |
| for (var _i = 0, array_4 = array; _i < array_4.length; _i++) { | |
| var item = array_4[_i]; | |
| pushIfUnique(result, item, equalityComparer); | |
| } | |
| return result; | |
| } | |
| function deduplicate(array, equalityComparer, comparer) { | |
| return array.length === 0 ? [] : | |
| array.length === 1 ? array.slice() : | |
| comparer ? deduplicateRelational(array, equalityComparer, comparer) : | |
| deduplicateEquality(array, equalityComparer); | |
| } | |
| ts_deduplicate = deduplicate; | |
| function deduplicateSorted(array, comparer) { | |
| if (array.length === 0) | |
| return ts_emptyArray; | |
| var last = array[0]; | |
| var deduplicated = [last]; | |
| for (var i = 1; i < array.length; i++) { | |
| var next = array[i]; | |
| switch (comparer(next, last)) { | |
| case true: | |
| case 0: | |
| continue; | |
| case -1: | |
| return ts_Debug.fail("Array is unsorted."); | |
| } | |
| deduplicated.push(last = next); | |
| } | |
| return deduplicated; | |
| } | |
| function insertSorted(array, insert, compare) { | |
| if (array.length === 0) { | |
| array.push(insert); | |
| return; | |
| } | |
| var insertIndex = binarySearch(array, insert, identity, compare); | |
| if (insertIndex < 0) { | |
| array.splice(~insertIndex, 0, insert); | |
| } | |
| } | |
| ts_insertSorted = insertSorted; | |
| function sortAndDeduplicate(array, comparer, equalityComparer) { | |
| return deduplicateSorted(sort(array, comparer), equalityComparer || comparer || compareStringsCaseSensitive); | |
| } | |
| ts_sortAndDeduplicate = sortAndDeduplicate; | |
| function arrayIsEqualTo(array1, array2, equalityComparer) { | |
| if (equalityComparer === void 0) { equalityComparer = equateValues; } | |
| if (!array1 || !array2) { | |
| return array1 === array2; | |
| } | |
| if (array1.length !== array2.length) { | |
| return false; | |
| } | |
| for (var i = 0; i < array1.length; i++) { | |
| if (!equalityComparer(array1[i], array2[i], i)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| ts_arrayIsEqualTo = arrayIsEqualTo; | |
| function compact(array) { | |
| var result; | |
| if (array) { | |
| for (var i = 0; i < array.length; i++) { | |
| var v = array[i]; | |
| if (result || !v) { | |
| if (!result) { | |
| result = array.slice(0, i); | |
| } | |
| if (v) { | |
| result.push(v); | |
| } | |
| } | |
| } | |
| } | |
| return result || array; | |
| } | |
| ts_compact = compact; | |
| function relativeComplement(arrayA, arrayB, comparer) { | |
| if (!arrayB || !arrayA || arrayB.length === 0 || arrayA.length === 0) | |
| return arrayB; | |
| var result = []; | |
| loopB: for (var offsetA = 0, offsetB = 0; offsetB < arrayB.length; offsetB++) { | |
| if (offsetB > 0) { | |
| ts_Debug.assertGreaterThanOrEqual(comparer(arrayB[offsetB], arrayB[offsetB - 1]), 0); | |
| } | |
| loopA: for (var startA = offsetA; offsetA < arrayA.length; offsetA++) { | |
| if (offsetA > startA) { | |
| ts_Debug.assertGreaterThanOrEqual(comparer(arrayA[offsetA], arrayA[offsetA - 1]), 0); | |
| } | |
| switch (comparer(arrayB[offsetB], arrayA[offsetA])) { | |
| case -1: | |
| result.push(arrayB[offsetB]); | |
| continue loopB; | |
| case 0: | |
| continue loopB; | |
| case 1: | |
| continue loopA; | |
| } | |
| } | |
| } | |
| return result; | |
| } | |
| ts_relativeComplement = relativeComplement; | |
| function sum(array, prop) { | |
| var result = 0; | |
| for (var _i = 0, array_5 = array; _i < array_5.length; _i++) { | |
| var v = array_5[_i]; | |
| result += v[prop]; | |
| } | |
| return result; | |
| } | |
| ts_sum = sum; | |
| function append(to, value) { | |
| if (value === undefined) | |
| return to; | |
| if (to === undefined) | |
| return [value]; | |
| to.push(value); | |
| return to; | |
| } | |
| ts_append = append; | |
| function toOffset(array, offset) { | |
| return offset < 0 ? array.length + offset : offset; | |
| } | |
| function addRange(to, from, start, end) { | |
| if (from === undefined || from.length === 0) | |
| return to; | |
| if (to === undefined) | |
| return from.slice(start, end); | |
| start = start === undefined ? 0 : toOffset(from, start); | |
| end = end === undefined ? from.length : toOffset(from, end); | |
| for (var i = start; i < end && i < from.length; i++) { | |
| if (from[i] !== undefined) { | |
| to.push(from[i]); | |
| } | |
| } | |
| return to; | |
| } | |
| ts_addRange = addRange; | |
| function pushIfUnique(array, toAdd, equalityComparer) { | |
| if (contains(array, toAdd, equalityComparer)) { | |
| return false; | |
| } | |
| else { | |
| array.push(toAdd); | |
| return true; | |
| } | |
| } | |
| ts_pushIfUnique = pushIfUnique; | |
| function appendIfUnique(array, toAdd, equalityComparer) { | |
| if (array) { | |
| pushIfUnique(array, toAdd, equalityComparer); | |
| return array; | |
| } | |
| else { | |
| return [toAdd]; | |
| } | |
| } | |
| ts_appendIfUnique = appendIfUnique; | |
| function stableSortIndices(array, indices, comparer) { | |
| indices.sort(function (x, y) { return comparer(array[x], array[y]) || compareValues(x, y); }); | |
| } | |
| function sort(array, comparer) { | |
| return (array.length === 0 ? array : array.slice().sort(comparer)); | |
| } | |
| ts_sort = sort; | |
| function arrayIterator(array) { | |
| var i = 0; | |
| return { next: function () { | |
| if (i === array.length) { | |
| return { value: undefined, done: true }; | |
| } | |
| else { | |
| i++; | |
| return { value: array[i - 1], done: false }; | |
| } | |
| } }; | |
| } | |
| ts_arrayIterator = arrayIterator; | |
| function arrayReverseIterator(array) { | |
| var i = array.length; | |
| return { | |
| next: function () { | |
| if (i === 0) { | |
| return { value: undefined, done: true }; | |
| } | |
| else { | |
| i--; | |
| return { value: array[i], done: false }; | |
| } | |
| } | |
| }; | |
| } | |
| ts_arrayReverseIterator = arrayReverseIterator; | |
| function stableSort(array, comparer) { | |
| var indices = indicesOf(array); | |
| stableSortIndices(array, indices, comparer); | |
| return indices.map(function (i) { return array[i]; }); | |
| } | |
| ts_stableSort = stableSort; | |
| function rangeEquals(array1, array2, pos, end) { | |
| while (pos < end) { | |
| if (array1[pos] !== array2[pos]) { | |
| return false; | |
| } | |
| pos++; | |
| } | |
| return true; | |
| } | |
| ts_rangeEquals = rangeEquals; | |
| function elementAt(array, offset) { | |
| if (array) { | |
| offset = toOffset(array, offset); | |
| if (offset < array.length) { | |
| return array[offset]; | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_elementAt = elementAt; | |
| function firstOrUndefined(array) { | |
| return array.length === 0 ? undefined : array[0]; | |
| } | |
| ts_firstOrUndefined = firstOrUndefined; | |
| function first(array) { | |
| ts_Debug.assert(array.length !== 0); | |
| return array[0]; | |
| } | |
| ts_first = first; | |
| function lastOrUndefined(array) { | |
| return array.length === 0 ? undefined : array[array.length - 1]; | |
| } | |
| ts_lastOrUndefined = lastOrUndefined; | |
| function last(array) { | |
| ts_Debug.assert(array.length !== 0); | |
| return array[array.length - 1]; | |
| } | |
| ts_last = last; | |
| function singleOrUndefined(array) { | |
| return array && array.length === 1 | |
| ? array[0] | |
| : undefined; | |
| } | |
| ts_singleOrUndefined = singleOrUndefined; | |
| function singleOrMany(array) { | |
| return array && array.length === 1 | |
| ? array[0] | |
| : array; | |
| } | |
| ts_singleOrMany = singleOrMany; | |
| function replaceElement(array, index, value) { | |
| var result = array.slice(0); | |
| result[index] = value; | |
| return result; | |
| } | |
| ts_replaceElement = replaceElement; | |
| function binarySearch(array, value, keySelector, keyComparer, offset) { | |
| return binarySearchKey(array, keySelector(value), keySelector, keyComparer, offset); | |
| } | |
| ts_binarySearch = binarySearch; | |
| function binarySearchKey(array, key, keySelector, keyComparer, offset) { | |
| if (!some(array)) { | |
| return -1; | |
| } | |
| var low = offset || 0; | |
| var high = array.length - 1; | |
| while (low <= high) { | |
| var middle = low + ((high - low) >> 1); | |
| var midKey = keySelector(array[middle]); | |
| switch (keyComparer(midKey, key)) { | |
| case -1: | |
| low = middle + 1; | |
| break; | |
| case 0: | |
| return middle; | |
| case 1: | |
| high = middle - 1; | |
| break; | |
| } | |
| } | |
| return ~low; | |
| } | |
| ts_binarySearchKey = binarySearchKey; | |
| function reduceLeft(array, f, initial, start, count) { | |
| if (array && array.length > 0) { | |
| var size = array.length; | |
| if (size > 0) { | |
| var pos = start === undefined || start < 0 ? 0 : start; | |
| var end = count === undefined || pos + count > size - 1 ? size - 1 : pos + count; | |
| var result = void 0; | |
| if (arguments.length <= 2) { | |
| result = array[pos]; | |
| pos++; | |
| } | |
| else { | |
| result = initial; | |
| } | |
| while (pos <= end) { | |
| result = f(result, array[pos], pos); | |
| pos++; | |
| } | |
| return result; | |
| } | |
| } | |
| return initial; | |
| } | |
| ts_reduceLeft = reduceLeft; | |
| var hasOwnProperty = Object.prototype.hasOwnProperty; | |
| function hasProperty(map, key) { | |
| return hasOwnProperty.call(map, key); | |
| } | |
| ts_hasProperty = hasProperty; | |
| function getProperty(map, key) { | |
| return hasOwnProperty.call(map, key) ? map[key] : undefined; | |
| } | |
| ts_getProperty = getProperty; | |
| function getOwnKeys(map) { | |
| var keys = []; | |
| for (var key in map) { | |
| if (hasOwnProperty.call(map, key)) { | |
| keys.push(key); | |
| } | |
| } | |
| return keys; | |
| } | |
| ts_getOwnKeys = getOwnKeys; | |
| function getAllKeys(obj) { | |
| var result = []; | |
| do { | |
| var names = Object.getOwnPropertyNames(obj); | |
| for (var _i = 0, names_1 = names; _i < names_1.length; _i++) { | |
| var name = names_1[_i]; | |
| pushIfUnique(result, name); | |
| } | |
| } while (obj = Object.getPrototypeOf(obj)); | |
| return result; | |
| } | |
| ts_getAllKeys = getAllKeys; | |
| function getOwnValues(sparseArray) { | |
| var values = []; | |
| for (var key in sparseArray) { | |
| if (hasOwnProperty.call(sparseArray, key)) { | |
| values.push(sparseArray[key]); | |
| } | |
| } | |
| return values; | |
| } | |
| ts_getOwnValues = getOwnValues; | |
| function arrayFrom(iterator, map) { | |
| var result = []; | |
| for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { | |
| result.push(map ? map(iterResult.value) : iterResult.value); | |
| } | |
| return result; | |
| } | |
| ts_arrayFrom = arrayFrom; | |
| function assign(t) { | |
| var args = []; | |
| for (var _i = 1; _i < arguments.length; _i++) { | |
| args[_i - 1] = arguments[_i]; | |
| } | |
| for (var _a = 0, args_1 = args; _a < args_1.length; _a++) { | |
| var arg = args_1[_a]; | |
| if (arg === undefined) | |
| continue; | |
| for (var p in arg) { | |
| if (hasProperty(arg, p)) { | |
| t[p] = arg[p]; | |
| } | |
| } | |
| } | |
| return t; | |
| } | |
| ts_assign = assign; | |
| function equalOwnProperties(left, right, equalityComparer) { | |
| if (equalityComparer === void 0) { equalityComparer = equateValues; } | |
| if (left === right) | |
| return true; | |
| if (!left || !right) | |
| return false; | |
| for (var key in left) { | |
| if (hasOwnProperty.call(left, key)) { | |
| if (!hasOwnProperty.call(right, key)) | |
| return false; | |
| if (!equalityComparer(left[key], right[key])) | |
| return false; | |
| } | |
| } | |
| for (var key in right) { | |
| if (hasOwnProperty.call(right, key)) { | |
| if (!hasOwnProperty.call(left, key)) | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| ts_equalOwnProperties = equalOwnProperties; | |
| function arrayToMap(array, makeKey, makeValue) { | |
| if (makeValue === void 0) { makeValue = identity; } | |
| var result = createMap(); | |
| for (var _i = 0, array_6 = array; _i < array_6.length; _i++) { | |
| var value = array_6[_i]; | |
| var key = makeKey(value); | |
| if (key !== undefined) | |
| result.set(key, makeValue(value)); | |
| } | |
| return result; | |
| } | |
| ts_arrayToMap = arrayToMap; | |
| function arrayToNumericMap(array, makeKey, makeValue) { | |
| if (makeValue === void 0) { makeValue = identity; } | |
| var result = []; | |
| for (var _i = 0, array_7 = array; _i < array_7.length; _i++) { | |
| var value = array_7[_i]; | |
| result[makeKey(value)] = makeValue(value); | |
| } | |
| return result; | |
| } | |
| ts_arrayToNumericMap = arrayToNumericMap; | |
| function arrayToMultiMap(values, makeKey, makeValue) { | |
| if (makeValue === void 0) { makeValue = identity; } | |
| var result = createMultiMap(); | |
| for (var _i = 0, values_1 = values; _i < values_1.length; _i++) { | |
| var value = values_1[_i]; | |
| result.add(makeKey(value), makeValue(value)); | |
| } | |
| return result; | |
| } | |
| ts_arrayToMultiMap = arrayToMultiMap; | |
| function group(values, getGroupId, resultSelector) { | |
| if (resultSelector === void 0) { resultSelector = identity; } | |
| return arrayFrom(arrayToMultiMap(values, getGroupId).values(), resultSelector); | |
| } | |
| ts_group = group; | |
| function clone(object) { | |
| var result = {}; | |
| for (var id in object) { | |
| if (hasOwnProperty.call(object, id)) { | |
| result[id] = object[id]; | |
| } | |
| } | |
| return result; | |
| } | |
| ts_clone = clone; | |
| function extend(first, second) { | |
| var result = {}; | |
| for (var id in second) { | |
| if (hasOwnProperty.call(second, id)) { | |
| result[id] = second[id]; | |
| } | |
| } | |
| for (var id in first) { | |
| if (hasOwnProperty.call(first, id)) { | |
| result[id] = first[id]; | |
| } | |
| } | |
| return result; | |
| } | |
| ts_extend = extend; | |
| function copyProperties(first, second) { | |
| for (var id in second) { | |
| if (hasOwnProperty.call(second, id)) { | |
| first[id] = second[id]; | |
| } | |
| } | |
| } | |
| ts_copyProperties = copyProperties; | |
| function maybeBind(obj, fn) { | |
| return fn ? fn.bind(obj) : undefined; | |
| } | |
| ts_maybeBind = maybeBind; | |
| function mapMap(map, f) { | |
| var result = createMap(); | |
| map.forEach(function (t, key) { return result.set.apply(result, (f(t, key))); }); | |
| return result; | |
| } | |
| ts_mapMap = mapMap; | |
| function createMultiMap() { | |
| var map = createMap(); | |
| map.add = multiMapAdd; | |
| map.remove = multiMapRemove; | |
| return map; | |
| } | |
| ts_createMultiMap = createMultiMap; | |
| function multiMapAdd(key, value) { | |
| var values = this.get(key); | |
| if (values) { | |
| values.push(value); | |
| } | |
| else { | |
| this.set(key, values = [value]); | |
| } | |
| return values; | |
| } | |
| function multiMapRemove(key, value) { | |
| var values = this.get(key); | |
| if (values) { | |
| unorderedRemoveItem(values, value); | |
| if (!values.length) { | |
| this.delete(key); | |
| } | |
| } | |
| } | |
| function isArray(value) { | |
| return Array.isArray ? Array.isArray(value) : value instanceof Array; | |
| } | |
| ts_isArray = isArray; | |
| function toArray(value) { | |
| return isArray(value) ? value : [value]; | |
| } | |
| ts_toArray = toArray; | |
| function isString(text) { | |
| return typeof text === "string"; | |
| } | |
| ts_isString = isString; | |
| function isNumber(x) { | |
| return typeof x === "number"; | |
| } | |
| ts_isNumber = isNumber; | |
| function tryCast(value, test) { | |
| return value !== undefined && test(value) ? value : undefined; | |
| } | |
| ts_tryCast = tryCast; | |
| function cast(value, test) { | |
| if (value !== undefined && test(value)) | |
| return value; | |
| return ts_Debug.fail("Invalid cast. The supplied value " + value + " did not pass the test '" + ts_Debug.getFunctionName(test) + "'."); | |
| } | |
| ts_cast = cast; | |
| function noop(_) { } | |
| ts_noop = noop; | |
| function returnFalse() { return false; } | |
| ts_returnFalse = returnFalse; | |
| function returnTrue() { return true; } | |
| ts_returnTrue = returnTrue; | |
| function returnUndefined() { return undefined; } | |
| ts_returnUndefined = returnUndefined; | |
| function identity(x) { return x; } | |
| ts_identity = identity; | |
| function toLowerCase(x) { return x.toLowerCase(); } | |
| ts_toLowerCase = toLowerCase; | |
| var fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g; | |
| function toFileNameLowerCase(x) { | |
| return fileNameLowerCaseRegExp.test(x) ? | |
| x.replace(fileNameLowerCaseRegExp, toLowerCase) : | |
| x; | |
| } | |
| ts_toFileNameLowerCase = toFileNameLowerCase; | |
| function notImplemented() { | |
| throw new Error("Not implemented"); | |
| } | |
| ts_notImplemented = notImplemented; | |
| function memoize(callback) { | |
| var value; | |
| return function () { | |
| if (callback) { | |
| value = callback(); | |
| callback = undefined; | |
| } | |
| return value; | |
| }; | |
| } | |
| ts_memoize = memoize; | |
| function compose(a, b, c, d, e) { | |
| if (!!e) { | |
| var args_2 = []; | |
| for (var i = 0; i < arguments.length; i++) { | |
| args_2[i] = arguments[i]; | |
| } | |
| return function (t) { return reduceLeft(args_2, function (u, f) { return f(u); }, t); }; | |
| } | |
| else if (d) { | |
| return function (t) { return d(c(b(a(t)))); }; | |
| } | |
| else if (c) { | |
| return function (t) { return c(b(a(t))); }; | |
| } | |
| else if (b) { | |
| return function (t) { return b(a(t)); }; | |
| } | |
| else if (a) { | |
| return function (t) { return a(t); }; | |
| } | |
| else { | |
| return function (t) { return t; }; | |
| } | |
| } | |
| ts_compose = compose; | |
| function equateValues(a, b) { | |
| return a === b; | |
| } | |
| ts_equateValues = equateValues; | |
| function equateStringsCaseInsensitive(a, b) { | |
| return a === b | |
| || a !== undefined | |
| && b !== undefined | |
| && a.toUpperCase() === b.toUpperCase(); | |
| } | |
| ts_equateStringsCaseInsensitive = equateStringsCaseInsensitive; | |
| function equateStringsCaseSensitive(a, b) { | |
| return equateValues(a, b); | |
| } | |
| ts_equateStringsCaseSensitive = equateStringsCaseSensitive; | |
| function compareComparableValues(a, b) { | |
| return a === b ? 0 : | |
| a === undefined ? -1 : | |
| b === undefined ? 1 : | |
| a < b ? -1 : | |
| 1; | |
| } | |
| function compareValues(a, b) { | |
| return compareComparableValues(a, b); | |
| } | |
| ts_compareValues = compareValues; | |
| function compareTextSpans(a, b) { | |
| return compareValues(a === null || a === void 0 ? void 0 : a.start, b === null || b === void 0 ? void 0 : b.start) || compareValues(a === null || a === void 0 ? void 0 : a.length, b === null || b === void 0 ? void 0 : b.length); | |
| } | |
| ts_compareTextSpans = compareTextSpans; | |
| function min(a, b, compare) { | |
| return compare(a, b) === -1 ? a : b; | |
| } | |
| ts_min = min; | |
| function compareStringsCaseInsensitive(a, b) { | |
| if (a === b) | |
| return 0; | |
| if (a === undefined) | |
| return -1; | |
| if (b === undefined) | |
| return 1; | |
| a = a.toUpperCase(); | |
| b = b.toUpperCase(); | |
| return a < b ? -1 : a > b ? 1 : 0; | |
| } | |
| ts_compareStringsCaseInsensitive = compareStringsCaseInsensitive; | |
| function compareStringsCaseSensitive(a, b) { | |
| return compareComparableValues(a, b); | |
| } | |
| ts_compareStringsCaseSensitive = compareStringsCaseSensitive; | |
| function getStringComparer(ignoreCase) { | |
| return ignoreCase ? compareStringsCaseInsensitive : compareStringsCaseSensitive; | |
| } | |
| ts_getStringComparer = getStringComparer; | |
| var createUIStringComparer = (function () { | |
| var defaultComparer; | |
| var enUSComparer; | |
| var stringComparerFactory = getStringComparerFactory(); | |
| return createStringComparer; | |
| function compareWithCallback(a, b, comparer) { | |
| if (a === b) | |
| return 0; | |
| if (a === undefined) | |
| return -1; | |
| if (b === undefined) | |
| return 1; | |
| var value = comparer(a, b); | |
| return value < 0 ? -1 : value > 0 ? 1 : 0; | |
| } | |
| function createIntlCollatorStringComparer(locale) { | |
| var comparer = new Intl.Collator(locale, { usage: "sort", sensitivity: "variant" }).compare; | |
| return function (a, b) { return compareWithCallback(a, b, comparer); }; | |
| } | |
| function createLocaleCompareStringComparer(locale) { | |
| if (locale !== undefined) | |
| return createFallbackStringComparer(); | |
| return function (a, b) { return compareWithCallback(a, b, compareStrings); }; | |
| function compareStrings(a, b) { | |
| return a.localeCompare(b); | |
| } | |
| } | |
| function createFallbackStringComparer() { | |
| return function (a, b) { return compareWithCallback(a, b, compareDictionaryOrder); }; | |
| function compareDictionaryOrder(a, b) { | |
| return compareStrings(a.toUpperCase(), b.toUpperCase()) || compareStrings(a, b); | |
| } | |
| function compareStrings(a, b) { | |
| return a < b ? -1 : a > b ? 1 : 0; | |
| } | |
| } | |
| function getStringComparerFactory() { | |
| if (typeof Intl === "object" && typeof Intl.Collator === "function") { | |
| return createIntlCollatorStringComparer; | |
| } | |
| if (typeof String.prototype.localeCompare === "function" && | |
| typeof String.prototype.toLocaleUpperCase === "function" && | |
| "a".localeCompare("B") < 0) { | |
| return createLocaleCompareStringComparer; | |
| } | |
| return createFallbackStringComparer; | |
| } | |
| function createStringComparer(locale) { | |
| if (locale === undefined) { | |
| return defaultComparer || (defaultComparer = stringComparerFactory(locale)); | |
| } | |
| else if (locale === "en-US") { | |
| return enUSComparer || (enUSComparer = stringComparerFactory(locale)); | |
| } | |
| else { | |
| return stringComparerFactory(locale); | |
| } | |
| } | |
| })(); | |
| var uiComparerCaseSensitive; | |
| var uiLocale; | |
| function getUILocale() { | |
| return uiLocale; | |
| } | |
| ts_getUILocale = getUILocale; | |
| function setUILocale(value) { | |
| if (uiLocale !== value) { | |
| uiLocale = value; | |
| uiComparerCaseSensitive = undefined; | |
| } | |
| } | |
| ts_setUILocale = setUILocale; | |
| function compareStringsCaseSensitiveUI(a, b) { | |
| var comparer = uiComparerCaseSensitive || (uiComparerCaseSensitive = createUIStringComparer(uiLocale)); | |
| return comparer(a, b); | |
| } | |
| ts_compareStringsCaseSensitiveUI = compareStringsCaseSensitiveUI; | |
| function compareProperties(a, b, key, comparer) { | |
| return a === b ? 0 : | |
| a === undefined ? -1 : | |
| b === undefined ? 1 : | |
| comparer(a[key], b[key]); | |
| } | |
| ts_compareProperties = compareProperties; | |
| function compareBooleans(a, b) { | |
| return compareValues(a ? 1 : 0, b ? 1 : 0); | |
| } | |
| ts_compareBooleans = compareBooleans; | |
| function getSpellingSuggestion(name, candidates, getName) { | |
| var maximumLengthDifference = Math.min(2, Math.floor(name.length * 0.34)); | |
| var bestDistance = Math.floor(name.length * 0.4) + 1; | |
| var bestCandidate; | |
| var justCheckExactMatches = false; | |
| var nameLowerCase = name.toLowerCase(); | |
| for (var _i = 0, candidates_1 = candidates; _i < candidates_1.length; _i++) { | |
| var candidate = candidates_1[_i]; | |
| var candidateName = getName(candidate); | |
| if (candidateName !== undefined && Math.abs(candidateName.length - nameLowerCase.length) <= maximumLengthDifference) { | |
| var candidateNameLowerCase = candidateName.toLowerCase(); | |
| if (candidateNameLowerCase === nameLowerCase) { | |
| if (candidateName === name) { | |
| continue; | |
| } | |
| return candidate; | |
| } | |
| if (justCheckExactMatches) { | |
| continue; | |
| } | |
| if (candidateName.length < 3) { | |
| continue; | |
| } | |
| var distance = levenshteinWithMax(nameLowerCase, candidateNameLowerCase, bestDistance - 1); | |
| if (distance === undefined) { | |
| continue; | |
| } | |
| if (distance < 3) { | |
| justCheckExactMatches = true; | |
| bestCandidate = candidate; | |
| } | |
| else { | |
| ts_Debug.assert(distance < bestDistance); | |
| bestDistance = distance; | |
| bestCandidate = candidate; | |
| } | |
| } | |
| } | |
| return bestCandidate; | |
| } | |
| ts_getSpellingSuggestion = getSpellingSuggestion; | |
| function levenshteinWithMax(s1, s2, max) { | |
| var previous = new Array(s2.length + 1); | |
| var current = new Array(s2.length + 1); | |
| var big = max + 1; | |
| for (var i = 0; i <= s2.length; i++) { | |
| previous[i] = i; | |
| } | |
| for (var i = 1; i <= s1.length; i++) { | |
| var c1 = s1.charCodeAt(i - 1); | |
| var minJ = i > max ? i - max : 1; | |
| var maxJ = s2.length > max + i ? max + i : s2.length; | |
| current[0] = i; | |
| var colMin = i; | |
| for (var j = 1; j < minJ; j++) { | |
| current[j] = big; | |
| } | |
| for (var j = minJ; j <= maxJ; j++) { | |
| var dist = c1 === s2.charCodeAt(j - 1) | |
| ? previous[j - 1] | |
| : Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + 2); | |
| current[j] = dist; | |
| colMin = Math.min(colMin, dist); | |
| } | |
| for (var j = maxJ + 1; j <= s2.length; j++) { | |
| current[j] = big; | |
| } | |
| if (colMin > max) { | |
| return undefined; | |
| } | |
| var temp = previous; | |
| previous = current; | |
| current = temp; | |
| } | |
| var res = previous[s2.length]; | |
| return res > max ? undefined : res; | |
| } | |
| function endsWith(str, suffix) { | |
| var expectedPos = str.length - suffix.length; | |
| return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos; | |
| } | |
| ts_endsWith = endsWith; | |
| function removeSuffix(str, suffix) { | |
| return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : str; | |
| } | |
| ts_removeSuffix = removeSuffix; | |
| function tryRemoveSuffix(str, suffix) { | |
| return endsWith(str, suffix) ? str.slice(0, str.length - suffix.length) : undefined; | |
| } | |
| ts_tryRemoveSuffix = tryRemoveSuffix; | |
| function stringContains(str, substring) { | |
| return str.indexOf(substring) !== -1; | |
| } | |
| ts_stringContains = stringContains; | |
| function removeMinAndVersionNumbers(fileName) { | |
| var trailingMinOrVersion = /[.-]((min)|(\d+(\.\d+)*))$/; | |
| return fileName.replace(trailingMinOrVersion, "").replace(trailingMinOrVersion, ""); | |
| } | |
| ts_removeMinAndVersionNumbers = removeMinAndVersionNumbers; | |
| function orderedRemoveItem(array, item) { | |
| for (var i = 0; i < array.length; i++) { | |
| if (array[i] === item) { | |
| orderedRemoveItemAt(array, i); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| ts_orderedRemoveItem = orderedRemoveItem; | |
| function orderedRemoveItemAt(array, index) { | |
| for (var i = index; i < array.length - 1; i++) { | |
| array[i] = array[i + 1]; | |
| } | |
| array.pop(); | |
| } | |
| ts_orderedRemoveItemAt = orderedRemoveItemAt; | |
| function unorderedRemoveItemAt(array, index) { | |
| array[index] = array[array.length - 1]; | |
| array.pop(); | |
| } | |
| ts_unorderedRemoveItemAt = unorderedRemoveItemAt; | |
| function unorderedRemoveItem(array, item) { | |
| return unorderedRemoveFirstItemWhere(array, function (element) { return element === item; }); | |
| } | |
| ts_unorderedRemoveItem = unorderedRemoveItem; | |
| function unorderedRemoveFirstItemWhere(array, predicate) { | |
| for (var i = 0; i < array.length; i++) { | |
| if (predicate(array[i])) { | |
| unorderedRemoveItemAt(array, i); | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| function createGetCanonicalFileName(useCaseSensitiveFileNames) { | |
| return useCaseSensitiveFileNames ? identity : toFileNameLowerCase; | |
| } | |
| ts_createGetCanonicalFileName = createGetCanonicalFileName; | |
| function patternText(_a) { | |
| var prefix = _a.prefix, suffix = _a.suffix; | |
| return prefix + "*" + suffix; | |
| } | |
| ts_patternText = patternText; | |
| function matchedText(pattern, candidate) { | |
| ts_Debug.assert(isPatternMatch(pattern, candidate)); | |
| return candidate.substring(pattern.prefix.length, candidate.length - pattern.suffix.length); | |
| } | |
| ts_matchedText = matchedText; | |
| function findBestPatternMatch(values, getPattern, candidate) { | |
| var matchedValue; | |
| var longestMatchPrefixLength = -1; | |
| for (var _i = 0, values_2 = values; _i < values_2.length; _i++) { | |
| var v = values_2[_i]; | |
| var pattern = getPattern(v); | |
| if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) { | |
| longestMatchPrefixLength = pattern.prefix.length; | |
| matchedValue = v; | |
| } | |
| } | |
| return matchedValue; | |
| } | |
| ts_findBestPatternMatch = findBestPatternMatch; | |
| function startsWith(str, prefix) { | |
| return str.lastIndexOf(prefix, 0) === 0; | |
| } | |
| ts_startsWith = startsWith; | |
| function removePrefix(str, prefix) { | |
| return startsWith(str, prefix) ? str.substr(prefix.length) : str; | |
| } | |
| ts_removePrefix = removePrefix; | |
| function tryRemovePrefix(str, prefix, getCanonicalFileName) { | |
| if (getCanonicalFileName === void 0) { getCanonicalFileName = identity; } | |
| return startsWith(getCanonicalFileName(str), getCanonicalFileName(prefix)) ? str.substring(prefix.length) : undefined; | |
| } | |
| ts_tryRemovePrefix = tryRemovePrefix; | |
| function isPatternMatch(_a, candidate) { | |
| var prefix = _a.prefix, suffix = _a.suffix; | |
| return candidate.length >= prefix.length + suffix.length && | |
| startsWith(candidate, prefix) && | |
| endsWith(candidate, suffix); | |
| } | |
| function and(f, g) { | |
| return function (arg) { return f(arg) && g(arg); }; | |
| } | |
| ts_and = and; | |
| function or() { | |
| var fs = []; | |
| for (var _i = 0; _i < arguments.length; _i++) { | |
| fs[_i] = arguments[_i]; | |
| } | |
| return function () { | |
| var args = []; | |
| for (var _i = 0; _i < arguments.length; _i++) { | |
| args[_i] = arguments[_i]; | |
| } | |
| for (var _a = 0, fs_1 = fs; _a < fs_1.length; _a++) { | |
| var f = fs_1[_a]; | |
| if (f.apply(void 0, args)) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| }; | |
| } | |
| ts_or = or; | |
| function not(fn) { | |
| return function () { | |
| var args = []; | |
| for (var _i = 0; _i < arguments.length; _i++) { | |
| args[_i] = arguments[_i]; | |
| } | |
| return !fn.apply(void 0, args); | |
| }; | |
| } | |
| ts_not = not; | |
| function assertType(_) { } | |
| ts_assertType = assertType; | |
| function singleElementArray(t) { | |
| return t === undefined ? undefined : [t]; | |
| } | |
| ts_singleElementArray = singleElementArray; | |
| function enumerateInsertsAndDeletes(newItems, oldItems, comparer, inserted, deleted, unchanged) { | |
| unchanged = unchanged || noop; | |
| var newIndex = 0; | |
| var oldIndex = 0; | |
| var newLen = newItems.length; | |
| var oldLen = oldItems.length; | |
| while (newIndex < newLen && oldIndex < oldLen) { | |
| var newItem = newItems[newIndex]; | |
| var oldItem = oldItems[oldIndex]; | |
| var compareResult = comparer(newItem, oldItem); | |
| if (compareResult === -1) { | |
| inserted(newItem); | |
| newIndex++; | |
| } | |
| else if (compareResult === 1) { | |
| deleted(oldItem); | |
| oldIndex++; | |
| } | |
| else { | |
| unchanged(oldItem, newItem); | |
| newIndex++; | |
| oldIndex++; | |
| } | |
| } | |
| while (newIndex < newLen) { | |
| inserted(newItems[newIndex++]); | |
| } | |
| while (oldIndex < oldLen) { | |
| deleted(oldItems[oldIndex++]); | |
| } | |
| } | |
| ts_enumerateInsertsAndDeletes = enumerateInsertsAndDeletes; | |
| function fill(length, cb) { | |
| var result = Array(length); | |
| for (var i = 0; i < length; i++) { | |
| result[i] = cb(i); | |
| } | |
| return result; | |
| } | |
| ts_fill = fill; | |
| function cartesianProduct(arrays) { | |
| var result = []; | |
| cartesianProductWorker(arrays, result, undefined, 0); | |
| return result; | |
| } | |
| ts_cartesianProduct = cartesianProduct; | |
| function cartesianProductWorker(arrays, result, outer, index) { | |
| for (var _i = 0, _a = arrays[index]; _i < _a.length; _i++) { | |
| var element = _a[_i]; | |
| var inner = void 0; | |
| if (outer) { | |
| inner = outer.slice(); | |
| inner.push(element); | |
| } | |
| else { | |
| inner = [element]; | |
| } | |
| if (index === arrays.length - 1) { | |
| result.push(inner); | |
| } | |
| else { | |
| cartesianProductWorker(arrays, result, inner, index + 1); | |
| } | |
| } | |
| } | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| var Debug; | |
| (function (Debug) { | |
| Debug.currentAssertionLevel = 0; | |
| Debug.isDebugging = false; | |
| function shouldAssert(level) { | |
| return Debug.currentAssertionLevel >= level; | |
| } | |
| Debug.shouldAssert = shouldAssert; | |
| function assert(expression, message, verboseDebugInfo, stackCrawlMark) { | |
| if (!expression) { | |
| if (verboseDebugInfo) { | |
| message += "\r\nVerbose Debug Information: " + (typeof verboseDebugInfo === "string" ? verboseDebugInfo : verboseDebugInfo()); | |
| } | |
| fail(message ? "False expression: " + message : "False expression.", stackCrawlMark || assert); | |
| } | |
| } | |
| Debug.assert = assert; | |
| function assertEqual(a, b, msg, msg2) { | |
| if (a !== b) { | |
| var message = msg ? msg2 ? msg + " " + msg2 : msg : ""; | |
| fail("Expected " + a + " === " + b + ". " + message); | |
| } | |
| } | |
| Debug.assertEqual = assertEqual; | |
| function assertLessThan(a, b, msg) { | |
| if (a >= b) { | |
| fail("Expected " + a + " < " + b + ". " + (msg || "")); | |
| } | |
| } | |
| Debug.assertLessThan = assertLessThan; | |
| function assertLessThanOrEqual(a, b) { | |
| if (a > b) { | |
| fail("Expected " + a + " <= " + b); | |
| } | |
| } | |
| Debug.assertLessThanOrEqual = assertLessThanOrEqual; | |
| function assertGreaterThanOrEqual(a, b) { | |
| if (a < b) { | |
| fail("Expected " + a + " >= " + b); | |
| } | |
| } | |
| Debug.assertGreaterThanOrEqual = assertGreaterThanOrEqual; | |
| function fail(message, stackCrawlMark) { | |
| debugger; | |
| var e = new Error(message ? "Debug Failure. " + message : "Debug Failure."); | |
| if (Error.captureStackTrace) { | |
| Error.captureStackTrace(e, stackCrawlMark || fail); | |
| } | |
| throw e; | |
| } | |
| Debug.fail = fail; | |
| function assertDefined(value, message) { | |
| if (value === undefined || value === null) | |
| return fail(message); | |
| return value; | |
| } | |
| Debug.assertDefined = assertDefined; | |
| function assertEachDefined(value, message) { | |
| for (var _i = 0, value_1 = value; _i < value_1.length; _i++) { | |
| var v = value_1[_i]; | |
| assertDefined(v, message); | |
| } | |
| return value; | |
| } | |
| Debug.assertEachDefined = assertEachDefined; | |
| function assertNever(member, message, stackCrawlMark) { | |
| if (message === void 0) { message = "Illegal value:"; } | |
| var detail = typeof member === "object" && ts_hasProperty(member, "kind") && ts_hasProperty(member, "pos") && formatSyntaxKind ? "SyntaxKind: " + formatSyntaxKind(member.kind) : JSON.stringify(member); | |
| return fail(message + " " + detail, stackCrawlMark || assertNever); | |
| } | |
| Debug.assertNever = assertNever; | |
| function getFunctionName(func) { | |
| if (typeof func !== "function") { | |
| return ""; | |
| } | |
| else if (func.hasOwnProperty("name")) { | |
| return func.name; | |
| } | |
| else { | |
| var text = Function.prototype.toString.call(func); | |
| var match = /^function\s+([\w\$]+)\s*\(/.exec(text); | |
| return match ? match[1] : ""; | |
| } | |
| } | |
| Debug.getFunctionName = getFunctionName; | |
| function formatSymbol(symbol) { | |
| return "{ name: " + ts_unescapeLeadingUnderscores(symbol.escapedName) + "; flags: " + formatSymbolFlags(symbol.flags) + "; declarations: " + ts_map(symbol.declarations, function (node) { return formatSyntaxKind(node.kind); }) + " }"; | |
| } | |
| Debug.formatSymbol = formatSymbol; | |
| function formatEnum(value, enumObject, isFlags) { | |
| if (value === void 0) { value = 0; } | |
| var members = getEnumMembers(enumObject); | |
| if (value === 0) { | |
| return members.length > 0 && members[0][0] === 0 ? members[0][1] : "0"; | |
| } | |
| if (isFlags) { | |
| var result = ""; | |
| var remainingFlags = value; | |
| for (var _i = 0, members_1 = members; _i < members_1.length; _i++) { | |
| var _a = members_1[_i], enumValue = _a[0], enumName = _a[1]; | |
| if (enumValue > value) { | |
| break; | |
| } | |
| if (enumValue !== 0 && enumValue & value) { | |
| result = "" + result + (result ? "|" : "") + enumName; | |
| remainingFlags &= ~enumValue; | |
| } | |
| } | |
| if (remainingFlags === 0) { | |
| return result; | |
| } | |
| } | |
| else { | |
| for (var _b = 0, members_2 = members; _b < members_2.length; _b++) { | |
| var _c = members_2[_b], enumValue = _c[0], enumName = _c[1]; | |
| if (enumValue === value) { | |
| return enumName; | |
| } | |
| } | |
| } | |
| return value.toString(); | |
| } | |
| Debug.formatEnum = formatEnum; | |
| function getEnumMembers(enumObject) { | |
| var result = []; | |
| for (var name in enumObject) { | |
| var value = enumObject[name]; | |
| if (typeof value === "number") { | |
| result.push([value, name]); | |
| } | |
| } | |
| return ts_stableSort(result, function (x, y) { return ts_compareValues(x[0], y[0]); }); | |
| } | |
| function formatSyntaxKind(kind) { | |
| return formatEnum(kind, ts_SyntaxKind, false); | |
| } | |
| Debug.formatSyntaxKind = formatSyntaxKind; | |
| function formatNodeFlags(flags) { | |
| return formatEnum(flags, ts_NodeFlags, true); | |
| } | |
| Debug.formatNodeFlags = formatNodeFlags; | |
| function formatModifierFlags(flags) { | |
| return formatEnum(flags, ts_ModifierFlags, true); | |
| } | |
| Debug.formatModifierFlags = formatModifierFlags; | |
| function formatTransformFlags(flags) { | |
| return formatEnum(flags, ts_TransformFlags, true); | |
| } | |
| Debug.formatTransformFlags = formatTransformFlags; | |
| function formatEmitFlags(flags) { | |
| return formatEnum(flags, ts_EmitFlags, true); | |
| } | |
| Debug.formatEmitFlags = formatEmitFlags; | |
| function formatSymbolFlags(flags) { | |
| return formatEnum(flags, ts_SymbolFlags, true); | |
| } | |
| Debug.formatSymbolFlags = formatSymbolFlags; | |
| function formatTypeFlags(flags) { | |
| return formatEnum(flags, ts_TypeFlags, true); | |
| } | |
| Debug.formatTypeFlags = formatTypeFlags; | |
| function formatObjectFlags(flags) { | |
| return formatEnum(flags, ts_ObjectFlags, true); | |
| } | |
| Debug.formatObjectFlags = formatObjectFlags; | |
| function failBadSyntaxKind(node, message) { | |
| return fail((message || "Unexpected node.") + "\r\nNode " + formatSyntaxKind(node.kind) + " was unexpected.", failBadSyntaxKind); | |
| } | |
| Debug.failBadSyntaxKind = failBadSyntaxKind; | |
| Debug.assertEachNode = shouldAssert(1) | |
| ? function (nodes, test, message) { return assert(test === undefined || ts_every(nodes, test), message || "Unexpected node.", function () { return "Node array did not pass test '" + getFunctionName(test) + "'."; }, Debug.assertEachNode); } | |
| : ts_noop; | |
| Debug.assertNode = shouldAssert(1) | |
| ? function (node, test, message) { return assert(test === undefined || test(node), message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " did not pass test '" + getFunctionName(test) + "'."; }, Debug.assertNode); } | |
| : ts_noop; | |
| Debug.assertNotNode = shouldAssert(1) | |
| ? function (node, test, message) { return assert(test === undefined || !test(node), message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " should not have passed test '" + getFunctionName(test) + "'."; }, Debug.assertNode); } | |
| : ts_noop; | |
| Debug.assertOptionalNode = shouldAssert(1) | |
| ? function (node, test, message) { return assert(test === undefined || node === undefined || test(node), message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " did not pass test '" + getFunctionName(test) + "'."; }, Debug.assertOptionalNode); } | |
| : ts_noop; | |
| Debug.assertOptionalToken = shouldAssert(1) | |
| ? function (node, kind, message) { return assert(kind === undefined || node === undefined || node.kind === kind, message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " was not a '" + formatSyntaxKind(kind) + "' token."; }, Debug.assertOptionalToken); } | |
| : ts_noop; | |
| Debug.assertMissingNode = shouldAssert(1) | |
| ? function (node, message) { return assert(node === undefined, message || "Unexpected node.", function () { return "Node " + formatSyntaxKind(node.kind) + " was unexpected'."; }, Debug.assertMissingNode); } | |
| : ts_noop; | |
| var isDebugInfoEnabled = false; | |
| var extendedDebugModule; | |
| function extendedDebug() { | |
| enableDebugInfo(); | |
| if (!extendedDebugModule) { | |
| throw new Error("Debugging helpers could not be loaded."); | |
| } | |
| return extendedDebugModule; | |
| } | |
| function printControlFlowGraph(flowNode) { | |
| return console.log(formatControlFlowGraph(flowNode)); | |
| } | |
| Debug.printControlFlowGraph = printControlFlowGraph; | |
| function formatControlFlowGraph(flowNode) { | |
| return extendedDebug().formatControlFlowGraph(flowNode); | |
| } | |
| Debug.formatControlFlowGraph = formatControlFlowGraph; | |
| function attachFlowNodeDebugInfo(flowNode) { | |
| if (isDebugInfoEnabled) { | |
| if (!("__debugFlowFlags" in flowNode)) { | |
| Object.defineProperties(flowNode, { | |
| __debugFlowFlags: { get: function () { return formatEnum(this.flags, ts_FlowFlags, true); } }, | |
| __debugToString: { value: function () { return formatControlFlowGraph(this); } } | |
| }); | |
| } | |
| } | |
| } | |
| Debug.attachFlowNodeDebugInfo = attachFlowNodeDebugInfo; | |
| function enableDebugInfo() { | |
| if (isDebugInfoEnabled) | |
| return; | |
| Object.defineProperties(ts_objectAllocator.getSymbolConstructor().prototype, { | |
| __debugFlags: { get: function () { return formatSymbolFlags(this.flags); } } | |
| }); | |
| Object.defineProperties(ts_objectAllocator.getTypeConstructor().prototype, { | |
| __debugFlags: { get: function () { return formatTypeFlags(this.flags); } }, | |
| __debugObjectFlags: { get: function () { return this.flags & 524288 ? formatObjectFlags(this.objectFlags) : ""; } }, | |
| __debugTypeToString: { value: function () { return this.checker.typeToString(this); } }, | |
| }); | |
| var nodeConstructors = [ | |
| ts_objectAllocator.getNodeConstructor(), | |
| ts_objectAllocator.getIdentifierConstructor(), | |
| ts_objectAllocator.getTokenConstructor(), | |
| ts_objectAllocator.getSourceFileConstructor() | |
| ]; | |
| for (var _i = 0, nodeConstructors_1 = nodeConstructors; _i < nodeConstructors_1.length; _i++) { | |
| var ctor = nodeConstructors_1[_i]; | |
| if (!ctor.prototype.hasOwnProperty("__debugKind")) { | |
| Object.defineProperties(ctor.prototype, { | |
| __debugKind: { get: function () { return formatSyntaxKind(this.kind); } }, | |
| __debugNodeFlags: { get: function () { return formatNodeFlags(this.flags); } }, | |
| __debugModifierFlags: { get: function () { return formatModifierFlags(ts_getModifierFlagsNoCache(this)); } }, | |
| __debugTransformFlags: { get: function () { return formatTransformFlags(this.transformFlags); } }, | |
| __debugIsParseTreeNode: { get: function () { return ts_isParseTreeNode(this); } }, | |
| __debugEmitFlags: { get: function () { return formatEmitFlags(ts_getEmitFlags(this)); } }, | |
| __debugGetText: { | |
| value: function (includeTrivia) { | |
| if (ts_nodeIsSynthesized(this)) | |
| return ""; | |
| var parseNode = ts_getParseTreeNode(this); | |
| var sourceFile = parseNode && ts_getSourceFileOfNode(parseNode); | |
| return sourceFile ? ts_getSourceTextOfNodeFromSourceFile(sourceFile, parseNode, includeTrivia) : ""; | |
| } | |
| } | |
| }); | |
| } | |
| } | |
| try { | |
| if (ts_sys && ts_sys.require) { | |
| var basePath = ts_getDirectoryPath(ts_resolvePath(ts_sys.getExecutingFilePath())); | |
| var result = ts_sys.require(basePath, "./compiler-debug"); | |
| if (!result.error) { | |
| result.module.init(ts); | |
| extendedDebugModule = result.module; | |
| } | |
| } | |
| } | |
| catch (_a) { | |
| } | |
| isDebugInfoEnabled = true; | |
| } | |
| Debug.enableDebugInfo = enableDebugInfo; | |
| })(Debug = ts_Debug || (ts_Debug = {})); | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| ts_timestamp = typeof performance !== "undefined" && performance.now ? function () { return performance.now(); } : Date.now ? Date.now : function () { return +(new Date()); }; | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| var performance; | |
| (function (performance) { | |
| var profilerEvent = typeof onProfilerEvent === "function" && onProfilerEvent.profiler === true ? onProfilerEvent : function () { }; | |
| var enabled = false; | |
| var profilerStart = 0; | |
| var counts; | |
| var marks; | |
| var measures; | |
| function createTimerIf(condition, measureName, startMarkName, endMarkName) { | |
| return condition ? createTimer(measureName, startMarkName, endMarkName) : performance.nullTimer; | |
| } | |
| performance.createTimerIf = createTimerIf; | |
| function createTimer(measureName, startMarkName, endMarkName) { | |
| var enterCount = 0; | |
| return { | |
| enter: enter, | |
| exit: exit | |
| }; | |
| function enter() { | |
| if (++enterCount === 1) { | |
| mark(startMarkName); | |
| } | |
| } | |
| function exit() { | |
| if (--enterCount === 0) { | |
| mark(endMarkName); | |
| measure(measureName, startMarkName, endMarkName); | |
| } | |
| else if (enterCount < 0) { | |
| ts_Debug.fail("enter/exit count does not match."); | |
| } | |
| } | |
| } | |
| performance.createTimer = createTimer; | |
| performance.nullTimer = { enter: ts_noop, exit: ts_noop }; | |
| function mark(markName) { | |
| if (enabled) { | |
| marks.set(markName, ts_timestamp()); | |
| counts.set(markName, (counts.get(markName) || 0) + 1); | |
| profilerEvent(markName); | |
| } | |
| } | |
| performance.mark = mark; | |
| function measure(measureName, startMarkName, endMarkName) { | |
| if (enabled) { | |
| var end = endMarkName && marks.get(endMarkName) || ts_timestamp(); | |
| var start = startMarkName && marks.get(startMarkName) || profilerStart; | |
| measures.set(measureName, (measures.get(measureName) || 0) + (end - start)); | |
| } | |
| } | |
| performance.measure = measure; | |
| function getCount(markName) { | |
| return counts && counts.get(markName) || 0; | |
| } | |
| performance.getCount = getCount; | |
| function getDuration(measureName) { | |
| return measures && measures.get(measureName) || 0; | |
| } | |
| performance.getDuration = getDuration; | |
| function forEachMeasure(cb) { | |
| measures.forEach(function (measure, key) { | |
| cb(key, measure); | |
| }); | |
| } | |
| performance.forEachMeasure = forEachMeasure; | |
| function enable() { | |
| counts = ts_createMap(); | |
| marks = ts_createMap(); | |
| measures = ts_createMap(); | |
| enabled = true; | |
| profilerStart = ts_timestamp(); | |
| } | |
| performance.enable = enable; | |
| function disable() { | |
| enabled = false; | |
| } | |
| performance.disable = disable; | |
| })(performance = ts_performance || (ts_performance = {})); | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| var nullLogger = { | |
| logEvent: ts_noop, | |
| logErrEvent: ts_noop, | |
| logPerfEvent: ts_noop, | |
| logInfoEvent: ts_noop, | |
| logStartCommand: ts_noop, | |
| logStopCommand: ts_noop, | |
| logStartUpdateProgram: ts_noop, | |
| logStopUpdateProgram: ts_noop, | |
| logStartUpdateGraph: ts_noop, | |
| logStopUpdateGraph: ts_noop, | |
| logStartResolveModule: ts_noop, | |
| logStopResolveModule: ts_noop, | |
| logStartParseSourceFile: ts_noop, | |
| logStopParseSourceFile: ts_noop, | |
| logStartReadFile: ts_noop, | |
| logStopReadFile: ts_noop, | |
| logStartBindFile: ts_noop, | |
| logStopBindFile: ts_noop, | |
| logStartScheduledOperation: ts_noop, | |
| logStopScheduledOperation: ts_noop, | |
| }; | |
| var etwModule; | |
| try { | |
| etwModule = require("@microsoft/typescript-etw"); | |
| } | |
| catch (e) { | |
| etwModule = undefined; | |
| } | |
| ts_perfLogger = etwModule && etwModule.logEvent ? etwModule : nullLogger; | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| var versionRegExp = /^(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\.(0|[1-9]\d*)(?:\-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i; | |
| var prereleaseRegExp = /^(?:0|[1-9]\d*|[a-z-][a-z0-9-]*)(?:\.(?:0|[1-9]\d*|[a-z-][a-z0-9-]*))*$/i; | |
| var buildRegExp = /^[a-z0-9-]+(?:\.[a-z0-9-]+)*$/i; | |
| var numericIdentifierRegExp = /^(0|[1-9]\d*)$/; | |
| var Version = (function () { | |
| function Version(major, minor, patch, prerelease, build) { | |
| if (minor === void 0) { minor = 0; } | |
| if (patch === void 0) { patch = 0; } | |
| if (prerelease === void 0) { prerelease = ""; } | |
| if (build === void 0) { build = ""; } | |
| if (typeof major === "string") { | |
| var result = ts_Debug.assertDefined(tryParseComponents(major), "Invalid version"); | |
| (major = result.major, minor = result.minor, patch = result.patch, prerelease = result.prerelease, build = result.build); | |
| } | |
| ts_Debug.assert(major >= 0, "Invalid argument: major"); | |
| ts_Debug.assert(minor >= 0, "Invalid argument: minor"); | |
| ts_Debug.assert(patch >= 0, "Invalid argument: patch"); | |
| ts_Debug.assert(!prerelease || prereleaseRegExp.test(prerelease), "Invalid argument: prerelease"); | |
| ts_Debug.assert(!build || buildRegExp.test(build), "Invalid argument: build"); | |
| this.major = major; | |
| this.minor = minor; | |
| this.patch = patch; | |
| this.prerelease = prerelease ? prerelease.split(".") : ts_emptyArray; | |
| this.build = build ? build.split(".") : ts_emptyArray; | |
| } | |
| Version.tryParse = function (text) { | |
| var result = tryParseComponents(text); | |
| if (!result) | |
| return undefined; | |
| var major = result.major, minor = result.minor, patch = result.patch, prerelease = result.prerelease, build = result.build; | |
| return new Version(major, minor, patch, prerelease, build); | |
| }; | |
| Version.prototype.compareTo = function (other) { | |
| if (this === other) | |
| return 0; | |
| if (other === undefined) | |
| return 1; | |
| return ts_compareValues(this.major, other.major) | |
| || ts_compareValues(this.minor, other.minor) | |
| || ts_compareValues(this.patch, other.patch) | |
| || comparePrerelaseIdentifiers(this.prerelease, other.prerelease); | |
| }; | |
| Version.prototype.increment = function (field) { | |
| switch (field) { | |
| case "major": return new Version(this.major + 1, 0, 0); | |
| case "minor": return new Version(this.major, this.minor + 1, 0); | |
| case "patch": return new Version(this.major, this.minor, this.patch + 1); | |
| default: return ts_Debug.assertNever(field); | |
| } | |
| }; | |
| Version.prototype.toString = function () { | |
| var result = this.major + "." + this.minor + "." + this.patch; | |
| if (ts_some(this.prerelease)) | |
| result += "-" + this.prerelease.join("."); | |
| if (ts_some(this.build)) | |
| result += "+" + this.build.join("."); | |
| return result; | |
| }; | |
| Version.zero = new Version(0, 0, 0); | |
| return Version; | |
| }()); | |
| ts_Version = Version; | |
| function tryParseComponents(text) { | |
| var match = versionRegExp.exec(text); | |
| if (!match) | |
| return undefined; | |
| var major = match[1], _a = match[2], minor = _a === void 0 ? "0" : _a, _b = match[3], patch = _b === void 0 ? "0" : _b, _c = match[4], prerelease = _c === void 0 ? "" : _c, _d = match[5], build = _d === void 0 ? "" : _d; | |
| if (prerelease && !prereleaseRegExp.test(prerelease)) | |
| return undefined; | |
| if (build && !buildRegExp.test(build)) | |
| return undefined; | |
| return { | |
| major: parseInt(major, 10), | |
| minor: parseInt(minor, 10), | |
| patch: parseInt(patch, 10), | |
| prerelease: prerelease, | |
| build: build | |
| }; | |
| } | |
| function comparePrerelaseIdentifiers(left, right) { | |
| if (left === right) | |
| return 0; | |
| if (left.length === 0) | |
| return right.length === 0 ? 0 : 1; | |
| if (right.length === 0) | |
| return -1; | |
| var length = Math.min(left.length, right.length); | |
| for (var i = 0; i < length; i++) { | |
| var leftIdentifier = left[i]; | |
| var rightIdentifier = right[i]; | |
| if (leftIdentifier === rightIdentifier) | |
| continue; | |
| var leftIsNumeric = numericIdentifierRegExp.test(leftIdentifier); | |
| var rightIsNumeric = numericIdentifierRegExp.test(rightIdentifier); | |
| if (leftIsNumeric || rightIsNumeric) { | |
| if (leftIsNumeric !== rightIsNumeric) | |
| return leftIsNumeric ? -1 : 1; | |
| var result = ts_compareValues(+leftIdentifier, +rightIdentifier); | |
| if (result) | |
| return result; | |
| } | |
| else { | |
| var result = ts_compareStringsCaseSensitive(leftIdentifier, rightIdentifier); | |
| if (result) | |
| return result; | |
| } | |
| } | |
| return ts_compareValues(left.length, right.length); | |
| } | |
| var VersionRange = (function () { | |
| function VersionRange(spec) { | |
| this._alternatives = spec ? ts_Debug.assertDefined(parseRange(spec), "Invalid range spec.") : ts_emptyArray; | |
| } | |
| VersionRange.tryParse = function (text) { | |
| var sets = parseRange(text); | |
| if (sets) { | |
| var range = new VersionRange(""); | |
| range._alternatives = sets; | |
| return range; | |
| } | |
| return undefined; | |
| }; | |
| VersionRange.prototype.test = function (version) { | |
| if (typeof version === "string") | |
| version = new Version(version); | |
| return testDisjunction(version, this._alternatives); | |
| }; | |
| VersionRange.prototype.toString = function () { | |
| return formatDisjunction(this._alternatives); | |
| }; | |
| return VersionRange; | |
| }()); | |
| ts_VersionRange = VersionRange; | |
| var logicalOrRegExp = /\s*\|\|\s*/g; | |
| var whitespaceRegExp = /\s+/g; | |
| var partialRegExp = /^([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:\.([xX*0]|[1-9]\d*)(?:-([a-z0-9-.]+))?(?:\+([a-z0-9-.]+))?)?)?$/i; | |
| var hyphenRegExp = /^\s*([a-z0-9-+.*]+)\s+-\s+([a-z0-9-+.*]+)\s*$/i; | |
| var rangeRegExp = /^\s*(~|\^|<|<=|>|>=|=)?\s*([a-z0-9-+.*]+)$/i; | |
| function parseRange(text) { | |
| var alternatives = []; | |
| for (var _i = 0, _a = text.trim().split(logicalOrRegExp); _i < _a.length; _i++) { | |
| var range = _a[_i]; | |
| if (!range) | |
| continue; | |
| var comparators = []; | |
| var match = hyphenRegExp.exec(range); | |
| if (match) { | |
| if (!parseHyphen(match[1], match[2], comparators)) | |
| return undefined; | |
| } | |
| else { | |
| for (var _b = 0, _c = range.split(whitespaceRegExp); _b < _c.length; _b++) { | |
| var simple = _c[_b]; | |
| var match_1 = rangeRegExp.exec(simple); | |
| if (!match_1 || !parseComparator(match_1[1], match_1[2], comparators)) | |
| return undefined; | |
| } | |
| } | |
| alternatives.push(comparators); | |
| } | |
| return alternatives; | |
| } | |
| function parsePartial(text) { | |
| var match = partialRegExp.exec(text); | |
| if (!match) | |
| return undefined; | |
| var major = match[1], _a = match[2], minor = _a === void 0 ? "*" : _a, _b = match[3], patch = _b === void 0 ? "*" : _b, prerelease = match[4], build = match[5]; | |
| var version = new Version(isWildcard(major) ? 0 : parseInt(major, 10), isWildcard(major) || isWildcard(minor) ? 0 : parseInt(minor, 10), isWildcard(major) || isWildcard(minor) || isWildcard(patch) ? 0 : parseInt(patch, 10), prerelease, build); | |
| return { version: version, major: major, minor: minor, patch: patch }; | |
| } | |
| function parseHyphen(left, right, comparators) { | |
| var leftResult = parsePartial(left); | |
| if (!leftResult) | |
| return false; | |
| var rightResult = parsePartial(right); | |
| if (!rightResult) | |
| return false; | |
| if (!isWildcard(leftResult.major)) { | |
| comparators.push(createComparator(">=", leftResult.version)); | |
| } | |
| if (!isWildcard(rightResult.major)) { | |
| comparators.push(isWildcard(rightResult.minor) ? createComparator("<", rightResult.version.increment("major")) : | |
| isWildcard(rightResult.patch) ? createComparator("<", rightResult.version.increment("minor")) : | |
| createComparator("<=", rightResult.version)); | |
| } | |
| return true; | |
| } | |
| function parseComparator(operator, text, comparators) { | |
| var result = parsePartial(text); | |
| if (!result) | |
| return false; | |
| var version = result.version, major = result.major, minor = result.minor, patch = result.patch; | |
| if (!isWildcard(major)) { | |
| switch (operator) { | |
| case "~": | |
| comparators.push(createComparator(">=", version)); | |
| comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : | |
| "minor"))); | |
| break; | |
| case "^": | |
| comparators.push(createComparator(">=", version)); | |
| comparators.push(createComparator("<", version.increment(version.major > 0 || isWildcard(minor) ? "major" : | |
| version.minor > 0 || isWildcard(patch) ? "minor" : | |
| "patch"))); | |
| break; | |
| case "<": | |
| case ">=": | |
| comparators.push(createComparator(operator, version)); | |
| break; | |
| case "<=": | |
| case ">": | |
| comparators.push(isWildcard(minor) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("major")) : | |
| isWildcard(patch) ? createComparator(operator === "<=" ? "<" : ">=", version.increment("minor")) : | |
| createComparator(operator, version)); | |
| break; | |
| case "=": | |
| case undefined: | |
| if (isWildcard(minor) || isWildcard(patch)) { | |
| comparators.push(createComparator(">=", version)); | |
| comparators.push(createComparator("<", version.increment(isWildcard(minor) ? "major" : "minor"))); | |
| } | |
| else { | |
| comparators.push(createComparator("=", version)); | |
| } | |
| break; | |
| default: | |
| return false; | |
| } | |
| } | |
| else if (operator === "<" || operator === ">") { | |
| comparators.push(createComparator("<", Version.zero)); | |
| } | |
| return true; | |
| } | |
| function isWildcard(part) { | |
| return part === "*" || part === "x" || part === "X"; | |
| } | |
| function createComparator(operator, operand) { | |
| return { operator: operator, operand: operand }; | |
| } | |
| function testDisjunction(version, alternatives) { | |
| if (alternatives.length === 0) | |
| return true; | |
| for (var _i = 0, alternatives_1 = alternatives; _i < alternatives_1.length; _i++) { | |
| var alternative = alternatives_1[_i]; | |
| if (testAlternative(version, alternative)) | |
| return true; | |
| } | |
| return false; | |
| } | |
| function testAlternative(version, comparators) { | |
| for (var _i = 0, comparators_1 = comparators; _i < comparators_1.length; _i++) { | |
| var comparator = comparators_1[_i]; | |
| if (!testComparator(version, comparator.operator, comparator.operand)) | |
| return false; | |
| } | |
| return true; | |
| } | |
| function testComparator(version, operator, operand) { | |
| var cmp = version.compareTo(operand); | |
| switch (operator) { | |
| case "<": return cmp < 0; | |
| case "<=": return cmp <= 0; | |
| case ">": return cmp > 0; | |
| case ">=": return cmp >= 0; | |
| case "=": return cmp === 0; | |
| default: return ts_Debug.assertNever(operator); | |
| } | |
| } | |
| function formatDisjunction(alternatives) { | |
| return ts_map(alternatives, formatAlternative).join(" || ") || "*"; | |
| } | |
| function formatAlternative(comparators) { | |
| return ts_map(comparators, formatComparator).join(" "); | |
| } | |
| function formatComparator(comparator) { | |
| return "" + comparator.operator + comparator.operand; | |
| } | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| var OperationCanceledException = (function () { | |
| function OperationCanceledException() { | |
| } | |
| return OperationCanceledException; | |
| }()); | |
| ts_OperationCanceledException = OperationCanceledException; | |
| var RefFileKind; | |
| (function (RefFileKind) { | |
| RefFileKind[RefFileKind["Import"] = 0] = "Import"; | |
| RefFileKind[RefFileKind["ReferenceFile"] = 1] = "ReferenceFile"; | |
| RefFileKind[RefFileKind["TypeReferenceDirective"] = 2] = "TypeReferenceDirective"; | |
| })(RefFileKind = ts_RefFileKind || (ts_RefFileKind = {})); | |
| var ExitStatus; | |
| (function (ExitStatus) { | |
| ExitStatus[ExitStatus["Success"] = 0] = "Success"; | |
| ExitStatus[ExitStatus["DiagnosticsPresent_OutputsSkipped"] = 1] = "DiagnosticsPresent_OutputsSkipped"; | |
| ExitStatus[ExitStatus["DiagnosticsPresent_OutputsGenerated"] = 2] = "DiagnosticsPresent_OutputsGenerated"; | |
| ExitStatus[ExitStatus["InvalidProject_OutputsSkipped"] = 3] = "InvalidProject_OutputsSkipped"; | |
| ExitStatus[ExitStatus["ProjectReferenceCycle_OutputsSkipped"] = 4] = "ProjectReferenceCycle_OutputsSkipped"; | |
| ExitStatus[ExitStatus["ProjectReferenceCycle_OutputsSkupped"] = 4] = "ProjectReferenceCycle_OutputsSkupped"; | |
| })(ExitStatus = ts_ExitStatus || (ts_ExitStatus = {})); | |
| var TypeReferenceSerializationKind; | |
| (function (TypeReferenceSerializationKind) { | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["Unknown"] = 0] = "Unknown"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithConstructSignatureAndValue"] = 1] = "TypeWithConstructSignatureAndValue"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["VoidNullableOrNeverType"] = 2] = "VoidNullableOrNeverType"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["NumberLikeType"] = 3] = "NumberLikeType"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["BigIntLikeType"] = 4] = "BigIntLikeType"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["StringLikeType"] = 5] = "StringLikeType"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["BooleanType"] = 6] = "BooleanType"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["ArrayLikeType"] = 7] = "ArrayLikeType"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["ESSymbolType"] = 8] = "ESSymbolType"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["Promise"] = 9] = "Promise"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["TypeWithCallSignature"] = 10] = "TypeWithCallSignature"; | |
| TypeReferenceSerializationKind[TypeReferenceSerializationKind["ObjectType"] = 11] = "ObjectType"; | |
| })(TypeReferenceSerializationKind = ts_TypeReferenceSerializationKind || (ts_TypeReferenceSerializationKind = {})); | |
| var DiagnosticCategory; | |
| (function (DiagnosticCategory) { | |
| DiagnosticCategory[DiagnosticCategory["Warning"] = 0] = "Warning"; | |
| DiagnosticCategory[DiagnosticCategory["Error"] = 1] = "Error"; | |
| DiagnosticCategory[DiagnosticCategory["Suggestion"] = 2] = "Suggestion"; | |
| DiagnosticCategory[DiagnosticCategory["Message"] = 3] = "Message"; | |
| })(DiagnosticCategory = ts_DiagnosticCategory || (ts_DiagnosticCategory = {})); | |
| function diagnosticCategoryName(d, lowerCase) { | |
| if (lowerCase === void 0) { lowerCase = true; } | |
| var name = DiagnosticCategory[d.category]; | |
| return lowerCase ? name.toLowerCase() : name; | |
| } | |
| ts_diagnosticCategoryName = diagnosticCategoryName; | |
| var ModuleResolutionKind; | |
| (function (ModuleResolutionKind) { | |
| ModuleResolutionKind[ModuleResolutionKind["Classic"] = 1] = "Classic"; | |
| ModuleResolutionKind[ModuleResolutionKind["NodeJs"] = 2] = "NodeJs"; | |
| })(ModuleResolutionKind = ts_ModuleResolutionKind || (ts_ModuleResolutionKind = {})); | |
| var WatchFileKind; | |
| (function (WatchFileKind) { | |
| WatchFileKind[WatchFileKind["FixedPollingInterval"] = 0] = "FixedPollingInterval"; | |
| WatchFileKind[WatchFileKind["PriorityPollingInterval"] = 1] = "PriorityPollingInterval"; | |
| WatchFileKind[WatchFileKind["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling"; | |
| WatchFileKind[WatchFileKind["UseFsEvents"] = 3] = "UseFsEvents"; | |
| WatchFileKind[WatchFileKind["UseFsEventsOnParentDirectory"] = 4] = "UseFsEventsOnParentDirectory"; | |
| })(WatchFileKind = ts_WatchFileKind || (ts_WatchFileKind = {})); | |
| var WatchDirectoryKind; | |
| (function (WatchDirectoryKind) { | |
| WatchDirectoryKind[WatchDirectoryKind["UseFsEvents"] = 0] = "UseFsEvents"; | |
| WatchDirectoryKind[WatchDirectoryKind["FixedPollingInterval"] = 1] = "FixedPollingInterval"; | |
| WatchDirectoryKind[WatchDirectoryKind["DynamicPriorityPolling"] = 2] = "DynamicPriorityPolling"; | |
| })(WatchDirectoryKind = ts_WatchDirectoryKind || (ts_WatchDirectoryKind = {})); | |
| var PollingWatchKind; | |
| (function (PollingWatchKind) { | |
| PollingWatchKind[PollingWatchKind["FixedInterval"] = 0] = "FixedInterval"; | |
| PollingWatchKind[PollingWatchKind["PriorityInterval"] = 1] = "PriorityInterval"; | |
| PollingWatchKind[PollingWatchKind["DynamicPriority"] = 2] = "DynamicPriority"; | |
| })(PollingWatchKind = ts_PollingWatchKind || (ts_PollingWatchKind = {})); | |
| var ModuleKind; | |
| (function (ModuleKind) { | |
| ModuleKind[ModuleKind["None"] = 0] = "None"; | |
| ModuleKind[ModuleKind["CommonJS"] = 1] = "CommonJS"; | |
| ModuleKind[ModuleKind["AMD"] = 2] = "AMD"; | |
| ModuleKind[ModuleKind["UMD"] = 3] = "UMD"; | |
| ModuleKind[ModuleKind["System"] = 4] = "System"; | |
| ModuleKind[ModuleKind["ES2015"] = 5] = "ES2015"; | |
| ModuleKind[ModuleKind["ES2020"] = 6] = "ES2020"; | |
| ModuleKind[ModuleKind["ESNext"] = 99] = "ESNext"; | |
| })(ModuleKind = ts_ModuleKind || (ts_ModuleKind = {})); | |
| ts_commentPragmas = { | |
| "reference": { | |
| args: [ | |
| { name: "types", optional: true, captureSpan: true }, | |
| { name: "lib", optional: true, captureSpan: true }, | |
| { name: "path", optional: true, captureSpan: true }, | |
| { name: "no-default-lib", optional: true } | |
| ], | |
| kind: 1 | |
| }, | |
| "amd-dependency": { | |
| args: [{ name: "path" }, { name: "name", optional: true }], | |
| kind: 1 | |
| }, | |
| "amd-module": { | |
| args: [{ name: "name" }], | |
| kind: 1 | |
| }, | |
| "ts-check": { | |
| kind: 2 | |
| }, | |
| "ts-nocheck": { | |
| kind: 2 | |
| }, | |
| "jsx": { | |
| args: [{ name: "factory" }], | |
| kind: 4 | |
| }, | |
| }; | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| function generateDjb2Hash(data) { | |
| var acc = 5381; | |
| for (var i = 0; i < data.length; i++) { | |
| acc = ((acc << 5) + acc) + data.charCodeAt(i); | |
| } | |
| return acc.toString(); | |
| } | |
| ts_generateDjb2Hash = generateDjb2Hash; | |
| function setStackTraceLimit() { | |
| if (Error.stackTraceLimit < 100) { | |
| Error.stackTraceLimit = 100; | |
| } | |
| } | |
| ts_setStackTraceLimit = setStackTraceLimit; | |
| var FileWatcherEventKind; | |
| (function (FileWatcherEventKind) { | |
| FileWatcherEventKind[FileWatcherEventKind["Created"] = 0] = "Created"; | |
| FileWatcherEventKind[FileWatcherEventKind["Changed"] = 1] = "Changed"; | |
| FileWatcherEventKind[FileWatcherEventKind["Deleted"] = 2] = "Deleted"; | |
| })(FileWatcherEventKind = ts_FileWatcherEventKind || (ts_FileWatcherEventKind = {})); | |
| var PollingInterval; | |
| (function (PollingInterval) { | |
| PollingInterval[PollingInterval["High"] = 2000] = "High"; | |
| PollingInterval[PollingInterval["Medium"] = 500] = "Medium"; | |
| PollingInterval[PollingInterval["Low"] = 250] = "Low"; | |
| })(PollingInterval = ts_PollingInterval || (ts_PollingInterval = {})); | |
| ts_missingFileModifiedTime = new Date(0); | |
| function createPollingIntervalBasedLevels(levels) { | |
| var _a; | |
| return _a = {}, | |
| _a[PollingInterval.Low] = levels.Low, | |
| _a[PollingInterval.Medium] = levels.Medium, | |
| _a[PollingInterval.High] = levels.High, | |
| _a; | |
| } | |
| var defaultChunkLevels = { Low: 32, Medium: 64, High: 256 }; | |
| var pollingChunkSize = createPollingIntervalBasedLevels(defaultChunkLevels); | |
| ts_unchangedPollThresholds = createPollingIntervalBasedLevels(defaultChunkLevels); | |
| function setCustomPollingValues(system) { | |
| if (!system.getEnvironmentVariable) { | |
| return; | |
| } | |
| var pollingIntervalChanged = setCustomLevels("TSC_WATCH_POLLINGINTERVAL", PollingInterval); | |
| pollingChunkSize = getCustomPollingBasedLevels("TSC_WATCH_POLLINGCHUNKSIZE", defaultChunkLevels) || pollingChunkSize; | |
| ts_unchangedPollThresholds = getCustomPollingBasedLevels("TSC_WATCH_UNCHANGEDPOLLTHRESHOLDS", defaultChunkLevels) || ts_unchangedPollThresholds; | |
| function getLevel(envVar, level) { | |
| return system.getEnvironmentVariable(envVar + "_" + level.toUpperCase()); | |
| } | |
| function getCustomLevels(baseVariable) { | |
| var customLevels; | |
| setCustomLevel("Low"); | |
| setCustomLevel("Medium"); | |
| setCustomLevel("High"); | |
| return customLevels; | |
| function setCustomLevel(level) { | |
| var customLevel = getLevel(baseVariable, level); | |
| if (customLevel) { | |
| (customLevels || (customLevels = {}))[level] = Number(customLevel); | |
| } | |
| } | |
| } | |
| function setCustomLevels(baseVariable, levels) { | |
| var customLevels = getCustomLevels(baseVariable); | |
| if (customLevels) { | |
| setLevel("Low"); | |
| setLevel("Medium"); | |
| setLevel("High"); | |
| return true; | |
| } | |
| return false; | |
| function setLevel(level) { | |
| levels[level] = customLevels[level] || levels[level]; | |
| } | |
| } | |
| function getCustomPollingBasedLevels(baseVariable, defaultLevels) { | |
| var customLevels = getCustomLevels(baseVariable); | |
| return (pollingIntervalChanged || customLevels) && | |
| createPollingIntervalBasedLevels(customLevels ? __assign(__assign({}, defaultLevels), customLevels) : defaultLevels); | |
| } | |
| } | |
| ts_setCustomPollingValues = setCustomPollingValues; | |
| function createDynamicPriorityPollingWatchFile(host) { | |
| var watchedFiles = []; | |
| var changedFilesInLastPoll = []; | |
| var lowPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Low); | |
| var mediumPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.Medium); | |
| var highPollingIntervalQueue = createPollingIntervalQueue(PollingInterval.High); | |
| return watchFile; | |
| function watchFile(fileName, callback, defaultPollingInterval) { | |
| var file = { | |
| fileName: fileName, | |
| callback: callback, | |
| unchangedPolls: 0, | |
| mtime: getModifiedTime(fileName) | |
| }; | |
| watchedFiles.push(file); | |
| addToPollingIntervalQueue(file, defaultPollingInterval); | |
| return { | |
| close: function () { | |
| file.isClosed = true; | |
| ts_unorderedRemoveItem(watchedFiles, file); | |
| } | |
| }; | |
| } | |
| function createPollingIntervalQueue(pollingInterval) { | |
| var queue = []; | |
| queue.pollingInterval = pollingInterval; | |
| queue.pollIndex = 0; | |
| queue.pollScheduled = false; | |
| return queue; | |
| } | |
| function pollPollingIntervalQueue(queue) { | |
| queue.pollIndex = pollQueue(queue, queue.pollingInterval, queue.pollIndex, pollingChunkSize[queue.pollingInterval]); | |
| if (queue.length) { | |
| scheduleNextPoll(queue.pollingInterval); | |
| } | |
| else { | |
| ts_Debug.assert(queue.pollIndex === 0); | |
| queue.pollScheduled = false; | |
| } | |
| } | |
| function pollLowPollingIntervalQueue(queue) { | |
| pollQueue(changedFilesInLastPoll, PollingInterval.Low, 0, changedFilesInLastPoll.length); | |
| pollPollingIntervalQueue(queue); | |
| if (!queue.pollScheduled && changedFilesInLastPoll.length) { | |
| scheduleNextPoll(PollingInterval.Low); | |
| } | |
| } | |
| function pollQueue(queue, pollingInterval, pollIndex, chunkSize) { | |
| var needsVisit = queue.length; | |
| var definedValueCopyToIndex = pollIndex; | |
| for (var polled = 0; polled < chunkSize && needsVisit > 0; nextPollIndex(), needsVisit--) { | |
| var watchedFile = queue[pollIndex]; | |
| if (!watchedFile) { | |
| continue; | |
| } | |
| else if (watchedFile.isClosed) { | |
| queue[pollIndex] = undefined; | |
| continue; | |
| } | |
| polled++; | |
| var fileChanged = onWatchedFileStat(watchedFile, getModifiedTime(watchedFile.fileName)); | |
| if (watchedFile.isClosed) { | |
| queue[pollIndex] = undefined; | |
| } | |
| else if (fileChanged) { | |
| watchedFile.unchangedPolls = 0; | |
| if (queue !== changedFilesInLastPoll) { | |
| queue[pollIndex] = undefined; | |
| addChangedFileToLowPollingIntervalQueue(watchedFile); | |
| } | |
| } | |
| else if (watchedFile.unchangedPolls !== ts_unchangedPollThresholds[pollingInterval]) { | |
| watchedFile.unchangedPolls++; | |
| } | |
| else if (queue === changedFilesInLastPoll) { | |
| watchedFile.unchangedPolls = 1; | |
| queue[pollIndex] = undefined; | |
| addToPollingIntervalQueue(watchedFile, PollingInterval.Low); | |
| } | |
| else if (pollingInterval !== PollingInterval.High) { | |
| watchedFile.unchangedPolls++; | |
| queue[pollIndex] = undefined; | |
| addToPollingIntervalQueue(watchedFile, pollingInterval === PollingInterval.Low ? PollingInterval.Medium : PollingInterval.High); | |
| } | |
| if (queue[pollIndex]) { | |
| if (definedValueCopyToIndex < pollIndex) { | |
| queue[definedValueCopyToIndex] = watchedFile; | |
| queue[pollIndex] = undefined; | |
| } | |
| definedValueCopyToIndex++; | |
| } | |
| } | |
| return pollIndex; | |
| function nextPollIndex() { | |
| pollIndex++; | |
| if (pollIndex === queue.length) { | |
| if (definedValueCopyToIndex < pollIndex) { | |
| queue.length = definedValueCopyToIndex; | |
| } | |
| pollIndex = 0; | |
| definedValueCopyToIndex = 0; | |
| } | |
| } | |
| } | |
| function pollingIntervalQueue(pollingInterval) { | |
| switch (pollingInterval) { | |
| case PollingInterval.Low: | |
| return lowPollingIntervalQueue; | |
| case PollingInterval.Medium: | |
| return mediumPollingIntervalQueue; | |
| case PollingInterval.High: | |
| return highPollingIntervalQueue; | |
| } | |
| } | |
| function addToPollingIntervalQueue(file, pollingInterval) { | |
| pollingIntervalQueue(pollingInterval).push(file); | |
| scheduleNextPollIfNotAlreadyScheduled(pollingInterval); | |
| } | |
| function addChangedFileToLowPollingIntervalQueue(file) { | |
| changedFilesInLastPoll.push(file); | |
| scheduleNextPollIfNotAlreadyScheduled(PollingInterval.Low); | |
| } | |
| function scheduleNextPollIfNotAlreadyScheduled(pollingInterval) { | |
| if (!pollingIntervalQueue(pollingInterval).pollScheduled) { | |
| scheduleNextPoll(pollingInterval); | |
| } | |
| } | |
| function scheduleNextPoll(pollingInterval) { | |
| pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === PollingInterval.Low ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingIntervalQueue(pollingInterval)); | |
| } | |
| function getModifiedTime(fileName) { | |
| return host.getModifiedTime(fileName) || ts_missingFileModifiedTime; | |
| } | |
| } | |
| ts_createDynamicPriorityPollingWatchFile = createDynamicPriorityPollingWatchFile; | |
| function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames) { | |
| var fileWatcherCallbacks = ts_createMultiMap(); | |
| var dirWatchers = ts_createMap(); | |
| var toCanonicalName = ts_createGetCanonicalFileName(useCaseSensitiveFileNames); | |
| return nonPollingWatchFile; | |
| function nonPollingWatchFile(fileName, callback, _pollingInterval, fallbackOptions) { | |
| var filePath = toCanonicalName(fileName); | |
| fileWatcherCallbacks.add(filePath, callback); | |
| var dirPath = ts_getDirectoryPath(filePath) || "."; | |
| var watcher = dirWatchers.get(dirPath) || | |
| createDirectoryWatcher(ts_getDirectoryPath(fileName) || ".", dirPath, fallbackOptions); | |
| watcher.referenceCount++; | |
| return { | |
| close: function () { | |
| if (watcher.referenceCount === 1) { | |
| watcher.close(); | |
| dirWatchers.delete(dirPath); | |
| } | |
| else { | |
| watcher.referenceCount--; | |
| } | |
| fileWatcherCallbacks.remove(filePath, callback); | |
| } | |
| }; | |
| } | |
| function createDirectoryWatcher(dirName, dirPath, fallbackOptions) { | |
| var watcher = fsWatch(dirName, 1, function (_eventName, relativeFileName) { | |
| if (!ts_isString(relativeFileName)) { | |
| return; | |
| } | |
| var fileName = ts_getNormalizedAbsolutePath(relativeFileName, dirName); | |
| var callbacks = fileName && fileWatcherCallbacks.get(toCanonicalName(fileName)); | |
| if (callbacks) { | |
| for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) { | |
| var fileCallback = callbacks_1[_i]; | |
| fileCallback(fileName, FileWatcherEventKind.Changed); | |
| } | |
| } | |
| }, false, PollingInterval.Medium, fallbackOptions); | |
| watcher.referenceCount = 0; | |
| dirWatchers.set(dirPath, watcher); | |
| return watcher; | |
| } | |
| } | |
| function createSingleFileWatcherPerName(watchFile, useCaseSensitiveFileNames) { | |
| var cache = ts_createMap(); | |
| var callbacksCache = ts_createMultiMap(); | |
| var toCanonicalFileName = ts_createGetCanonicalFileName(useCaseSensitiveFileNames); | |
| return function (fileName, callback, pollingInterval, options) { | |
| var path = toCanonicalFileName(fileName); | |
| var existing = cache.get(path); | |
| if (existing) { | |
| existing.refCount++; | |
| } | |
| else { | |
| cache.set(path, { | |
| watcher: watchFile(fileName, function (fileName, eventKind) { return ts_forEach(callbacksCache.get(path), function (cb) { return cb(fileName, eventKind); }); }, pollingInterval, options), | |
| refCount: 1 | |
| }); | |
| } | |
| callbacksCache.add(path, callback); | |
| return { | |
| close: function () { | |
| var watcher = ts_Debug.assertDefined(cache.get(path)); | |
| callbacksCache.remove(path, callback); | |
| watcher.refCount--; | |
| if (watcher.refCount) | |
| return; | |
| cache.delete(path); | |
| ts_closeFileWatcherOf(watcher); | |
| } | |
| }; | |
| }; | |
| } | |
| ts_createSingleFileWatcherPerName = createSingleFileWatcherPerName; | |
| function onWatchedFileStat(watchedFile, modifiedTime) { | |
| var oldTime = watchedFile.mtime.getTime(); | |
| var newTime = modifiedTime.getTime(); | |
| if (oldTime !== newTime) { | |
| watchedFile.mtime = modifiedTime; | |
| watchedFile.callback(watchedFile.fileName, getFileWatcherEventKind(oldTime, newTime)); | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_onWatchedFileStat = onWatchedFileStat; | |
| function getFileWatcherEventKind(oldTime, newTime) { | |
| return oldTime === 0 | |
| ? FileWatcherEventKind.Created | |
| : newTime === 0 | |
| ? FileWatcherEventKind.Deleted | |
| : FileWatcherEventKind.Changed; | |
| } | |
| ts_getFileWatcherEventKind = getFileWatcherEventKind; | |
| ts_ignoredPaths = ["/node_modules/.", "/.git", "/.#"]; | |
| ts_sysLog = ts_noop; | |
| function setSysLog(logger) { | |
| ts_sysLog = logger; | |
| } | |
| ts_setSysLog = setSysLog; | |
| function createDirectoryWatcherSupportingRecursive(host) { | |
| var cache = ts_createMap(); | |
| var callbackCache = ts_createMultiMap(); | |
| var cacheToUpdateChildWatches = ts_createMap(); | |
| var timerToUpdateChildWatches; | |
| var filePathComparer = ts_getStringComparer(!host.useCaseSensitiveFileNames); | |
| var toCanonicalFilePath = ts_createGetCanonicalFileName(host.useCaseSensitiveFileNames); | |
| return function (dirName, callback, recursive, options) { return recursive ? | |
| createDirectoryWatcher(dirName, options, callback) : | |
| host.watchDirectory(dirName, callback, recursive, options); }; | |
| function createDirectoryWatcher(dirName, options, callback) { | |
| var dirPath = toCanonicalFilePath(dirName); | |
| var directoryWatcher = cache.get(dirPath); | |
| if (directoryWatcher) { | |
| directoryWatcher.refCount++; | |
| } | |
| else { | |
| directoryWatcher = { | |
| watcher: host.watchDirectory(dirName, function (fileName) { | |
| if (isIgnoredPath(fileName)) | |
| return; | |
| if (options === null || options === void 0 ? void 0 : options.synchronousWatchDirectory) { | |
| invokeCallbacks(dirPath, fileName); | |
| updateChildWatches(dirName, dirPath, options); | |
| } | |
| else { | |
| nonSyncUpdateChildWatches(dirName, dirPath, fileName, options); | |
| } | |
| }, false, options), | |
| refCount: 1, | |
| childWatches: ts_emptyArray | |
| }; | |
| cache.set(dirPath, directoryWatcher); | |
| updateChildWatches(dirName, dirPath, options); | |
| } | |
| var callbackToAdd = callback && { dirName: dirName, callback: callback }; | |
| if (callbackToAdd) { | |
| callbackCache.add(dirPath, callbackToAdd); | |
| } | |
| return { | |
| dirName: dirName, | |
| close: function () { | |
| var directoryWatcher = ts_Debug.assertDefined(cache.get(dirPath)); | |
| if (callbackToAdd) | |
| callbackCache.remove(dirPath, callbackToAdd); | |
| directoryWatcher.refCount--; | |
| if (directoryWatcher.refCount) | |
| return; | |
| cache.delete(dirPath); | |
| ts_closeFileWatcherOf(directoryWatcher); | |
| directoryWatcher.childWatches.forEach(ts_closeFileWatcher); | |
| } | |
| }; | |
| } | |
| function invokeCallbacks(dirPath, fileNameOrInvokeMap) { | |
| var fileName; | |
| var invokeMap; | |
| if (ts_isString(fileNameOrInvokeMap)) { | |
| fileName = fileNameOrInvokeMap; | |
| } | |
| else { | |
| invokeMap = fileNameOrInvokeMap; | |
| } | |
| callbackCache.forEach(function (callbacks, rootDirName) { | |
| if (invokeMap && invokeMap.has(rootDirName)) | |
| return; | |
| if (rootDirName === dirPath || (ts_startsWith(dirPath, rootDirName) && dirPath[rootDirName.length] === ts_directorySeparator)) { | |
| if (invokeMap) { | |
| invokeMap.set(rootDirName, true); | |
| } | |
| else { | |
| callbacks.forEach(function (_a) { | |
| var callback = _a.callback; | |
| return callback(fileName); | |
| }); | |
| } | |
| } | |
| }); | |
| } | |
| function nonSyncUpdateChildWatches(dirName, dirPath, fileName, options) { | |
| var parentWatcher = cache.get(dirPath); | |
| if (parentWatcher && host.directoryExists(dirName)) { | |
| scheduleUpdateChildWatches(dirName, dirPath, options); | |
| return; | |
| } | |
| invokeCallbacks(dirPath, fileName); | |
| removeChildWatches(parentWatcher); | |
| } | |
| function scheduleUpdateChildWatches(dirName, dirPath, options) { | |
| if (!cacheToUpdateChildWatches.has(dirPath)) { | |
| cacheToUpdateChildWatches.set(dirPath, { dirName: dirName, options: options }); | |
| } | |
| if (timerToUpdateChildWatches) { | |
| host.clearTimeout(timerToUpdateChildWatches); | |
| timerToUpdateChildWatches = undefined; | |
| } | |
| timerToUpdateChildWatches = host.setTimeout(onTimerToUpdateChildWatches, 1000); | |
| } | |
| function onTimerToUpdateChildWatches() { | |
| timerToUpdateChildWatches = undefined; | |
| ts_sysLog("sysLog:: onTimerToUpdateChildWatches:: " + cacheToUpdateChildWatches.size); | |
| var start = ts_timestamp(); | |
| var invokeMap = ts_createMap(); | |
| while (!timerToUpdateChildWatches && cacheToUpdateChildWatches.size) { | |
| var _a = cacheToUpdateChildWatches.entries().next(), _b = _a.value, dirPath = _b[0], _c = _b[1], dirName = _c.dirName, options = _c.options, done = _a.done; | |
| ts_Debug.assert(!done); | |
| cacheToUpdateChildWatches.delete(dirPath); | |
| invokeCallbacks(dirPath, invokeMap); | |
| updateChildWatches(dirName, dirPath, options); | |
| } | |
| ts_sysLog("sysLog:: invokingWatchers:: " + (ts_timestamp() - start) + "ms:: " + cacheToUpdateChildWatches.size); | |
| callbackCache.forEach(function (callbacks, rootDirName) { | |
| if (invokeMap.has(rootDirName)) { | |
| callbacks.forEach(function (_a) { | |
| var callback = _a.callback, dirName = _a.dirName; | |
| return callback(dirName); | |
| }); | |
| } | |
| }); | |
| var elapsed = ts_timestamp() - start; | |
| ts_sysLog("sysLog:: Elapsed " + elapsed + "ms:: onTimerToUpdateChildWatches:: " + cacheToUpdateChildWatches.size + " " + timerToUpdateChildWatches); | |
| } | |
| function removeChildWatches(parentWatcher) { | |
| if (!parentWatcher) | |
| return; | |
| var existingChildWatches = parentWatcher.childWatches; | |
| parentWatcher.childWatches = ts_emptyArray; | |
| for (var _i = 0, existingChildWatches_1 = existingChildWatches; _i < existingChildWatches_1.length; _i++) { | |
| var childWatcher = existingChildWatches_1[_i]; | |
| childWatcher.close(); | |
| removeChildWatches(cache.get(toCanonicalFilePath(childWatcher.dirName))); | |
| } | |
| } | |
| function updateChildWatches(dirName, dirPath, options) { | |
| var parentWatcher = cache.get(dirPath); | |
| if (parentWatcher) { | |
| parentWatcher.childWatches = watchChildDirectories(dirName, parentWatcher.childWatches, options); | |
| } | |
| } | |
| function watchChildDirectories(parentDir, existingChildWatches, options) { | |
| var newChildWatches; | |
| ts_enumerateInsertsAndDeletes(host.directoryExists(parentDir) ? ts_mapDefined(host.getAccessibleSortedChildDirectories(parentDir), function (child) { | |
| var childFullName = ts_getNormalizedAbsolutePath(child, parentDir); | |
| return !isIgnoredPath(childFullName) && filePathComparer(childFullName, ts_normalizePath(host.realpath(childFullName))) === 0 ? childFullName : undefined; | |
| }) : ts_emptyArray, existingChildWatches, function (child, childWatcher) { return filePathComparer(child, childWatcher.dirName); }, createAndAddChildDirectoryWatcher, ts_closeFileWatcher, addChildDirectoryWatcher); | |
| return newChildWatches || ts_emptyArray; | |
| function createAndAddChildDirectoryWatcher(childName) { | |
| var result = createDirectoryWatcher(childName, options); | |
| addChildDirectoryWatcher(result); | |
| } | |
| function addChildDirectoryWatcher(childWatcher) { | |
| (newChildWatches || (newChildWatches = [])).push(childWatcher); | |
| } | |
| } | |
| function isIgnoredPath(path) { | |
| return ts_some(ts_ignoredPaths, function (searchPath) { return isInPath(path, searchPath); }); | |
| } | |
| function isInPath(path, searchPath) { | |
| if (ts_stringContains(path, searchPath)) | |
| return true; | |
| if (host.useCaseSensitiveFileNames) | |
| return false; | |
| return ts_stringContains(toCanonicalFilePath(path), searchPath); | |
| } | |
| } | |
| ts_createDirectoryWatcherSupportingRecursive = createDirectoryWatcherSupportingRecursive; | |
| function createFileWatcherCallback(callback) { | |
| return function (_fileName, eventKind) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", ""); }; | |
| } | |
| ts_createFileWatcherCallback = createFileWatcherCallback; | |
| function createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists) { | |
| return function (eventName) { | |
| if (eventName === "rename") { | |
| callback(fileName, fileExists(fileName) ? FileWatcherEventKind.Created : FileWatcherEventKind.Deleted); | |
| } | |
| else { | |
| callback(fileName, FileWatcherEventKind.Changed); | |
| } | |
| }; | |
| } | |
| function createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback) { | |
| return function (eventName, relativeFileName) { | |
| if (eventName === "rename") { | |
| callback(!relativeFileName ? directoryName : ts_normalizePath(ts_combinePaths(directoryName, relativeFileName))); | |
| } | |
| }; | |
| } | |
| function createSystemWatchFunctions(_a) { | |
| var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatch = _a.fsWatch, fileExists = _a.fileExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, directoryExists = _a.directoryExists, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory; | |
| var dynamicPollingWatchFile; | |
| var nonPollingWatchFile; | |
| var hostRecursiveDirectoryWatcher; | |
| return { | |
| watchFile: watchFile, | |
| watchDirectory: watchDirectory | |
| }; | |
| function watchFile(fileName, callback, pollingInterval, options) { | |
| options = updateOptionsForWatchFile(options, useNonPollingWatchers); | |
| var watchFileKind = ts_Debug.assertDefined(options.watchFile); | |
| switch (watchFileKind) { | |
| case ts_WatchFileKind.FixedPollingInterval: | |
| return pollingWatchFile(fileName, callback, PollingInterval.Low, undefined); | |
| case ts_WatchFileKind.PriorityPollingInterval: | |
| return pollingWatchFile(fileName, callback, pollingInterval, undefined); | |
| case ts_WatchFileKind.DynamicPriorityPolling: | |
| return ensureDynamicPollingWatchFile()(fileName, callback, pollingInterval, undefined); | |
| case ts_WatchFileKind.UseFsEvents: | |
| return fsWatch(fileName, 0, createFsWatchCallbackForFileWatcherCallback(fileName, callback, fileExists), false, pollingInterval, ts_getFallbackOptions(options)); | |
| case ts_WatchFileKind.UseFsEventsOnParentDirectory: | |
| if (!nonPollingWatchFile) { | |
| nonPollingWatchFile = createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames); | |
| } | |
| return nonPollingWatchFile(fileName, callback, pollingInterval, ts_getFallbackOptions(options)); | |
| default: | |
| ts_Debug.assertNever(watchFileKind); | |
| } | |
| } | |
| function ensureDynamicPollingWatchFile() { | |
| return dynamicPollingWatchFile || | |
| (dynamicPollingWatchFile = createDynamicPriorityPollingWatchFile({ getModifiedTime: getModifiedTime, setTimeout: setTimeout })); | |
| } | |
| function updateOptionsForWatchFile(options, useNonPollingWatchers) { | |
| if (options && options.watchFile !== undefined) | |
| return options; | |
| switch (tscWatchFile) { | |
| case "PriorityPollingInterval": | |
| return { watchFile: ts_WatchFileKind.PriorityPollingInterval }; | |
| case "DynamicPriorityPolling": | |
| return { watchFile: ts_WatchFileKind.DynamicPriorityPolling }; | |
| case "UseFsEvents": | |
| return generateWatchFileOptions(ts_WatchFileKind.UseFsEvents, ts_PollingWatchKind.PriorityInterval, options); | |
| case "UseFsEventsWithFallbackDynamicPolling": | |
| return generateWatchFileOptions(ts_WatchFileKind.UseFsEvents, ts_PollingWatchKind.DynamicPriority, options); | |
| case "UseFsEventsOnParentDirectory": | |
| useNonPollingWatchers = true; | |
| default: | |
| return useNonPollingWatchers ? | |
| generateWatchFileOptions(ts_WatchFileKind.UseFsEventsOnParentDirectory, ts_PollingWatchKind.PriorityInterval, options) : | |
| { watchFile: ts_WatchFileKind.FixedPollingInterval }; | |
| } | |
| } | |
| function generateWatchFileOptions(watchFile, fallbackPolling, options) { | |
| var defaultFallbackPolling = options === null || options === void 0 ? void 0 : options.fallbackPolling; | |
| return { | |
| watchFile: watchFile, | |
| fallbackPolling: defaultFallbackPolling === undefined ? | |
| fallbackPolling : | |
| defaultFallbackPolling | |
| }; | |
| } | |
| function watchDirectory(directoryName, callback, recursive, options) { | |
| if (fsSupportsRecursiveFsWatch) { | |
| return fsWatch(directoryName, 1, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback), recursive, PollingInterval.Medium, ts_getFallbackOptions(options)); | |
| } | |
| if (!hostRecursiveDirectoryWatcher) { | |
| hostRecursiveDirectoryWatcher = createDirectoryWatcherSupportingRecursive({ | |
| useCaseSensitiveFileNames: useCaseSensitiveFileNames, | |
| directoryExists: directoryExists, | |
| getAccessibleSortedChildDirectories: getAccessibleSortedChildDirectories, | |
| watchDirectory: nonRecursiveWatchDirectory, | |
| realpath: realpath, | |
| setTimeout: setTimeout, | |
| clearTimeout: clearTimeout | |
| }); | |
| } | |
| return hostRecursiveDirectoryWatcher(directoryName, callback, recursive, options); | |
| } | |
| function nonRecursiveWatchDirectory(directoryName, callback, recursive, options) { | |
| ts_Debug.assert(!recursive); | |
| options = updateOptionsForWatchDirectory(options); | |
| var watchDirectoryKind = ts_Debug.assertDefined(options.watchDirectory); | |
| switch (watchDirectoryKind) { | |
| case ts_WatchDirectoryKind.FixedPollingInterval: | |
| return pollingWatchFile(directoryName, function () { return callback(directoryName); }, PollingInterval.Medium, undefined); | |
| case ts_WatchDirectoryKind.DynamicPriorityPolling: | |
| return ensureDynamicPollingWatchFile()(directoryName, function () { return callback(directoryName); }, PollingInterval.Medium, undefined); | |
| case ts_WatchDirectoryKind.UseFsEvents: | |
| return fsWatch(directoryName, 1, createFsWatchCallbackForDirectoryWatcherCallback(directoryName, callback), recursive, PollingInterval.Medium, ts_getFallbackOptions(options)); | |
| default: | |
| ts_Debug.assertNever(watchDirectoryKind); | |
| } | |
| } | |
| function updateOptionsForWatchDirectory(options) { | |
| if (options && options.watchDirectory !== undefined) | |
| return options; | |
| switch (tscWatchDirectory) { | |
| case "RecursiveDirectoryUsingFsWatchFile": | |
| return { watchDirectory: ts_WatchDirectoryKind.FixedPollingInterval }; | |
| case "RecursiveDirectoryUsingDynamicPriorityPolling": | |
| return { watchDirectory: ts_WatchDirectoryKind.DynamicPriorityPolling }; | |
| default: | |
| var defaultFallbackPolling = options === null || options === void 0 ? void 0 : options.fallbackPolling; | |
| return { | |
| watchDirectory: ts_WatchDirectoryKind.UseFsEvents, | |
| fallbackPolling: defaultFallbackPolling !== undefined ? | |
| defaultFallbackPolling : | |
| undefined | |
| }; | |
| } | |
| } | |
| } | |
| ts_createSystemWatchFunctions = createSystemWatchFunctions; | |
| function patchWriteFileEnsuringDirectory(sys) { | |
| var originalWriteFile = sys.writeFile; | |
| sys.writeFile = function (path, data, writeBom) { | |
| return ts_writeFileEnsuringDirectories(path, data, !!writeBom, function (path, data, writeByteOrderMark) { return originalWriteFile.call(sys, path, data, writeByteOrderMark); }, function (path) { return sys.createDirectory(path); }, function (path) { return sys.directoryExists(path); }); | |
| }; | |
| } | |
| ts_patchWriteFileEnsuringDirectory = patchWriteFileEnsuringDirectory; | |
| function getNodeMajorVersion() { | |
| if (typeof process === "undefined") { | |
| return undefined; | |
| } | |
| var version = process.version; | |
| if (!version) { | |
| return undefined; | |
| } | |
| var dot = version.indexOf("."); | |
| if (dot === -1) { | |
| return undefined; | |
| } | |
| return parseInt(version.substring(1, dot)); | |
| } | |
| ts_getNodeMajorVersion = getNodeMajorVersion; | |
| ts_sys = (function () { | |
| var byteOrderMarkIndicator = "\uFEFF"; | |
| function getNodeSystem() { | |
| var nativePattern = /^native |^\([^)]+\)$|^(internal[\\/]|[a-zA-Z0-9_\s]+(\.js)?$)/; | |
| var _fs = require("fs"); | |
| var _path = require("path"); | |
| var _os = require("os"); | |
| var _crypto; | |
| try { | |
| _crypto = require("crypto"); | |
| } | |
| catch (_a) { | |
| _crypto = undefined; | |
| } | |
| var activeSession; | |
| var profilePath = "./profile.cpuprofile"; | |
| var Buffer = require("buffer").Buffer; | |
| var nodeVersion = getNodeMajorVersion(); | |
| var isNode4OrLater = nodeVersion >= 4; | |
| var isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin"; | |
| var platform = _os.platform(); | |
| var useCaseSensitiveFileNames = isFileSystemCaseSensitive(); | |
| var fsSupportsRecursiveFsWatch = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin"); | |
| var _b = createSystemWatchFunctions({ | |
| pollingWatchFile: createSingleFileWatcherPerName(fsWatchFileWorker, useCaseSensitiveFileNames), | |
| getModifiedTime: getModifiedTime, | |
| setTimeout: setTimeout, | |
| clearTimeout: clearTimeout, | |
| fsWatch: fsWatch, | |
| useCaseSensitiveFileNames: useCaseSensitiveFileNames, | |
| fileExists: fileExists, | |
| fsSupportsRecursiveFsWatch: fsSupportsRecursiveFsWatch, | |
| directoryExists: directoryExists, | |
| getAccessibleSortedChildDirectories: function (path) { return getAccessibleFileSystemEntries(path).directories; }, | |
| realpath: realpath, | |
| tscWatchFile: process.env.TSC_WATCHFILE, | |
| useNonPollingWatchers: process.env.TSC_NONPOLLING_WATCHER, | |
| tscWatchDirectory: process.env.TSC_WATCHDIRECTORY, | |
| }), watchFile = _b.watchFile, watchDirectory = _b.watchDirectory; | |
| var nodeSystem = { | |
| args: process.argv.slice(2), | |
| newLine: _os.EOL, | |
| useCaseSensitiveFileNames: useCaseSensitiveFileNames, | |
| write: function (s) { | |
| process.stdout.write(s); | |
| }, | |
| writeOutputIsTTY: function () { | |
| return process.stdout.isTTY; | |
| }, | |
| readFile: readFile, | |
| writeFile: writeFile, | |
| watchFile: watchFile, | |
| watchDirectory: watchDirectory, | |
| resolvePath: function (path) { return _path.resolve(path); }, | |
| fileExists: fileExists, | |
| directoryExists: directoryExists, | |
| createDirectory: function (directoryName) { | |
| if (!nodeSystem.directoryExists(directoryName)) { | |
| try { | |
| _fs.mkdirSync(directoryName); | |
| } | |
| catch (e) { | |
| if (e.code !== "EEXIST") { | |
| throw e; | |
| } | |
| } | |
| } | |
| }, | |
| getExecutingFilePath: function () { | |
| return __filename; | |
| }, | |
| getCurrentDirectory: function () { | |
| return process.cwd(); | |
| }, | |
| getDirectories: getDirectories, | |
| getEnvironmentVariable: function (name) { | |
| return process.env[name] || ""; | |
| }, | |
| readDirectory: readDirectory, | |
| getModifiedTime: getModifiedTime, | |
| setModifiedTime: setModifiedTime, | |
| deleteFile: deleteFile, | |
| createHash: _crypto ? createSHA256Hash : generateDjb2Hash, | |
| createSHA256Hash: _crypto ? createSHA256Hash : undefined, | |
| getMemoryUsage: function () { | |
| if (global.gc) { | |
| global.gc(); | |
| } | |
| return process.memoryUsage().heapUsed; | |
| }, | |
| getFileSize: function (path) { | |
| try { | |
| var stat = _fs.statSync(path); | |
| if (stat.isFile()) { | |
| return stat.size; | |
| } | |
| } | |
| catch (_a) { } | |
| return 0; | |
| }, | |
| exit: function (exitCode) { | |
| disableCPUProfiler(function () { return process.exit(exitCode); }); | |
| }, | |
| enableCPUProfiler: enableCPUProfiler, | |
| disableCPUProfiler: disableCPUProfiler, | |
| realpath: realpath, | |
| debugMode: ts_some(process.execArgv, function (arg) { return /^--(inspect|debug)(-brk)?(=\d+)?$/i.test(arg); }), | |
| tryEnableSourceMapsForHost: function () { | |
| try { | |
| require("source-map-support").install(); | |
| } | |
| catch (_a) { | |
| } | |
| }, | |
| setTimeout: setTimeout, | |
| clearTimeout: clearTimeout, | |
| clearScreen: function () { | |
| process.stdout.write("\x1Bc"); | |
| }, | |
| setBlocking: function () { | |
| if (process.stdout && process.stdout._handle && process.stdout._handle.setBlocking) { | |
| process.stdout._handle.setBlocking(true); | |
| } | |
| }, | |
| bufferFrom: bufferFrom, | |
| base64decode: function (input) { return bufferFrom(input, "base64").toString("utf8"); }, | |
| base64encode: function (input) { return bufferFrom(input).toString("base64"); }, | |
| require: function (baseDir, moduleName) { | |
| try { | |
| var modulePath = ts_resolveJSModule(moduleName, baseDir, nodeSystem); | |
| return { module: require(modulePath), modulePath: modulePath, error: undefined }; | |
| } | |
| catch (error) { | |
| return { module: undefined, modulePath: undefined, error: error }; | |
| } | |
| } | |
| }; | |
| return nodeSystem; | |
| function enableCPUProfiler(path, cb) { | |
| if (activeSession) { | |
| cb(); | |
| return false; | |
| } | |
| var inspector = require("inspector"); | |
| if (!inspector || !inspector.Session) { | |
| cb(); | |
| return false; | |
| } | |
| var session = new inspector.Session(); | |
| session.connect(); | |
| session.post("Profiler.enable", function () { | |
| session.post("Profiler.start", function () { | |
| activeSession = session; | |
| profilePath = path; | |
| cb(); | |
| }); | |
| }); | |
| return true; | |
| } | |
| function cleanupPaths(profile) { | |
| var externalFileCounter = 0; | |
| var remappedPaths = ts_createMap(); | |
| var normalizedDir = ts_normalizeSlashes(__dirname); | |
| var fileUrlRoot = "file://" + (ts_getRootLength(normalizedDir) === 1 ? "" : "/") + normalizedDir; | |
| for (var _i = 0, _a = profile.nodes; _i < _a.length; _i++) { | |
| var node = _a[_i]; | |
| if (node.callFrame.url) { | |
| var url = ts_normalizeSlashes(node.callFrame.url); | |
| if (ts_containsPath(fileUrlRoot, url, useCaseSensitiveFileNames)) { | |
| node.callFrame.url = ts_getRelativePathToDirectoryOrUrl(fileUrlRoot, url, fileUrlRoot, ts_createGetCanonicalFileName(useCaseSensitiveFileNames), true); | |
| } | |
| else if (!nativePattern.test(url)) { | |
| node.callFrame.url = (remappedPaths.has(url) ? remappedPaths : remappedPaths.set(url, "external" + externalFileCounter + ".js")).get(url); | |
| externalFileCounter++; | |
| } | |
| } | |
| } | |
| return profile; | |
| } | |
| function disableCPUProfiler(cb) { | |
| if (activeSession && activeSession !== "stopping") { | |
| var s_1 = activeSession; | |
| activeSession.post("Profiler.stop", function (err, _a) { | |
| var profile = _a.profile; | |
| if (!err) { | |
| try { | |
| if (_fs.statSync(profilePath).isDirectory()) { | |
| profilePath = _path.join(profilePath, (new Date()).toISOString().replace(/:/g, "-") + "+P" + process.pid + ".cpuprofile"); | |
| } | |
| } | |
| catch (_b) { | |
| } | |
| try { | |
| _fs.mkdirSync(_path.dirname(profilePath), { recursive: true }); | |
| } | |
| catch (_c) { | |
| } | |
| _fs.writeFileSync(profilePath, JSON.stringify(cleanupPaths(profile))); | |
| } | |
| activeSession = undefined; | |
| s_1.disconnect(); | |
| cb(); | |
| }); | |
| activeSession = "stopping"; | |
| return true; | |
| } | |
| else { | |
| cb(); | |
| return false; | |
| } | |
| } | |
| function bufferFrom(input, encoding) { | |
| return Buffer.from && Buffer.from !== Int8Array.from | |
| ? Buffer.from(input, encoding) | |
| : new Buffer(input, encoding); | |
| } | |
| function isFileSystemCaseSensitive() { | |
| if (platform === "win32" || platform === "win64") { | |
| return false; | |
| } | |
| return !fileExists(swapCase(__filename)); | |
| } | |
| function swapCase(s) { | |
| return s.replace(/\w/g, function (ch) { | |
| var up = ch.toUpperCase(); | |
| return ch === up ? ch.toLowerCase() : up; | |
| }); | |
| } | |
| function fsWatchFileWorker(fileName, callback, pollingInterval) { | |
| _fs.watchFile(fileName, { persistent: true, interval: pollingInterval }, fileChanged); | |
| var eventKind; | |
| return { | |
| close: function () { return _fs.unwatchFile(fileName, fileChanged); } | |
| }; | |
| function fileChanged(curr, prev) { | |
| var isPreviouslyDeleted = +prev.mtime === 0 || eventKind === FileWatcherEventKind.Deleted; | |
| if (+curr.mtime === 0) { | |
| if (isPreviouslyDeleted) { | |
| return; | |
| } | |
| eventKind = FileWatcherEventKind.Deleted; | |
| } | |
| else if (isPreviouslyDeleted) { | |
| eventKind = FileWatcherEventKind.Created; | |
| } | |
| else if (+curr.mtime === +prev.mtime) { | |
| return; | |
| } | |
| else { | |
| eventKind = FileWatcherEventKind.Changed; | |
| } | |
| callback(fileName, eventKind); | |
| } | |
| } | |
| function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) { | |
| var options; | |
| var lastDirectoryPartWithDirectorySeparator; | |
| var lastDirectoryPart; | |
| if (isLinuxOrMacOs) { | |
| lastDirectoryPartWithDirectorySeparator = fileOrDirectory.substr(fileOrDirectory.lastIndexOf(ts_directorySeparator)); | |
| lastDirectoryPart = lastDirectoryPartWithDirectorySeparator.slice(ts_directorySeparator.length); | |
| } | |
| var watcher = !fileSystemEntryExists(fileOrDirectory, entryKind) ? | |
| watchMissingFileSystemEntry() : | |
| watchPresentFileSystemEntry(); | |
| return { | |
| close: function () { | |
| watcher.close(); | |
| watcher = undefined; | |
| } | |
| }; | |
| function invokeCallbackAndUpdateWatcher(createWatcher) { | |
| ts_sysLog("sysLog:: " + fileOrDirectory + ":: Changing watcher to " + (createWatcher === watchPresentFileSystemEntry ? "Present" : "Missing") + "FileSystemEntryWatcher"); | |
| callback("rename", ""); | |
| if (watcher) { | |
| watcher.close(); | |
| watcher = createWatcher(); | |
| } | |
| } | |
| function watchPresentFileSystemEntry() { | |
| if (options === undefined) { | |
| if (fsSupportsRecursiveFsWatch) { | |
| options = { persistent: true, recursive: !!recursive }; | |
| } | |
| else { | |
| options = { persistent: true }; | |
| } | |
| } | |
| try { | |
| var presentWatcher = _fs.watch(fileOrDirectory, options, isLinuxOrMacOs ? | |
| callbackChangingToMissingFileSystemEntry : | |
| callback); | |
| presentWatcher.on("error", function () { return invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry); }); | |
| return presentWatcher; | |
| } | |
| catch (e) { | |
| return watchPresentFileSystemEntryWithFsWatchFile(); | |
| } | |
| } | |
| function callbackChangingToMissingFileSystemEntry(event, relativeName) { | |
| return event === "rename" && | |
| (!relativeName || | |
| relativeName === lastDirectoryPart || | |
| relativeName.lastIndexOf(lastDirectoryPartWithDirectorySeparator) === relativeName.length - lastDirectoryPartWithDirectorySeparator.length) && | |
| !fileSystemEntryExists(fileOrDirectory, entryKind) ? | |
| invokeCallbackAndUpdateWatcher(watchMissingFileSystemEntry) : | |
| callback(event, relativeName); | |
| } | |
| function watchPresentFileSystemEntryWithFsWatchFile() { | |
| ts_sysLog("sysLog:: " + fileOrDirectory + ":: Changing to fsWatchFile"); | |
| return watchFile(fileOrDirectory, createFileWatcherCallback(callback), fallbackPollingInterval, fallbackOptions); | |
| } | |
| function watchMissingFileSystemEntry() { | |
| return watchFile(fileOrDirectory, function (_fileName, eventKind) { | |
| if (eventKind === FileWatcherEventKind.Created && fileSystemEntryExists(fileOrDirectory, entryKind)) { | |
| invokeCallbackAndUpdateWatcher(watchPresentFileSystemEntry); | |
| } | |
| }, fallbackPollingInterval, fallbackOptions); | |
| } | |
| } | |
| function readFileWorker(fileName, _encoding) { | |
| var buffer; | |
| try { | |
| buffer = _fs.readFileSync(fileName); | |
| } | |
| catch (e) { | |
| return undefined; | |
| } | |
| var len = buffer.length; | |
| if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) { | |
| len &= ~1; | |
| for (var i = 0; i < len; i += 2) { | |
| var temp = buffer[i]; | |
| buffer[i] = buffer[i + 1]; | |
| buffer[i + 1] = temp; | |
| } | |
| return buffer.toString("utf16le", 2); | |
| } | |
| if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) { | |
| return buffer.toString("utf16le", 2); | |
| } | |
| if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) { | |
| return buffer.toString("utf8", 3); | |
| } | |
| return buffer.toString("utf8"); | |
| } | |
| function readFile(fileName, _encoding) { | |
| ts_perfLogger.logStartReadFile(fileName); | |
| var file = readFileWorker(fileName, _encoding); | |
| ts_perfLogger.logStopReadFile(); | |
| return file; | |
| } | |
| function writeFile(fileName, data, writeByteOrderMark) { | |
| ts_perfLogger.logEvent("WriteFile: " + fileName); | |
| if (writeByteOrderMark) { | |
| data = byteOrderMarkIndicator + data; | |
| } | |
| var fd; | |
| try { | |
| fd = _fs.openSync(fileName, "w"); | |
| _fs.writeSync(fd, data, undefined, "utf8"); | |
| } | |
| finally { | |
| if (fd !== undefined) { | |
| _fs.closeSync(fd); | |
| } | |
| } | |
| } | |
| function getAccessibleFileSystemEntries(path) { | |
| ts_perfLogger.logEvent("ReadDir: " + (path || ".")); | |
| try { | |
| var entries = _fs.readdirSync(path || ".", { withFileTypes: true }); | |
| var files = []; | |
| var directories = []; | |
| for (var _i = 0, entries_2 = entries; _i < entries_2.length; _i++) { | |
| var dirent = entries_2[_i]; | |
| var entry = typeof dirent === "string" ? dirent : dirent.name; | |
| if (entry === "." || entry === "..") { | |
| continue; | |
| } | |
| var stat = void 0; | |
| if (typeof dirent === "string" || dirent.isSymbolicLink()) { | |
| var name = ts_combinePaths(path, entry); | |
| try { | |
| stat = _fs.statSync(name); | |
| } | |
| catch (e) { | |
| continue; | |
| } | |
| } | |
| else { | |
| stat = dirent; | |
| } | |
| if (stat.isFile()) { | |
| files.push(entry); | |
| } | |
| else if (stat.isDirectory()) { | |
| directories.push(entry); | |
| } | |
| } | |
| files.sort(); | |
| directories.sort(); | |
| return { files: files, directories: directories }; | |
| } | |
| catch (e) { | |
| return ts_emptyFileSystemEntries; | |
| } | |
| } | |
| function readDirectory(path, extensions, excludes, includes, depth) { | |
| return ts_matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames, process.cwd(), depth, getAccessibleFileSystemEntries, realpath); | |
| } | |
| function fileSystemEntryExists(path, entryKind) { | |
| try { | |
| var stat = _fs.statSync(path); | |
| switch (entryKind) { | |
| case 0: return stat.isFile(); | |
| case 1: return stat.isDirectory(); | |
| default: return false; | |
| } | |
| } | |
| catch (e) { | |
| return false; | |
| } | |
| } | |
| function fileExists(path) { | |
| return fileSystemEntryExists(path, 0); | |
| } | |
| function directoryExists(path) { | |
| return fileSystemEntryExists(path, 1); | |
| } | |
| function getDirectories(path) { | |
| return getAccessibleFileSystemEntries(path).directories.slice(); | |
| } | |
| function realpath(path) { | |
| try { | |
| return _fs.realpathSync(path); | |
| } | |
| catch (_a) { | |
| return path; | |
| } | |
| } | |
| function getModifiedTime(path) { | |
| try { | |
| return _fs.statSync(path).mtime; | |
| } | |
| catch (e) { | |
| return undefined; | |
| } | |
| } | |
| function setModifiedTime(path, time) { | |
| try { | |
| _fs.utimesSync(path, time, time); | |
| } | |
| catch (e) { | |
| return; | |
| } | |
| } | |
| function deleteFile(path) { | |
| try { | |
| return _fs.unlinkSync(path); | |
| } | |
| catch (e) { | |
| return; | |
| } | |
| } | |
| function createSHA256Hash(data) { | |
| var hash = _crypto.createHash("sha256"); | |
| hash.update(data); | |
| return hash.digest("hex"); | |
| } | |
| } | |
| function getChakraSystem() { | |
| var realpath = ChakraHost.realpath && (function (path) { return ChakraHost.realpath(path); }); | |
| return { | |
| newLine: ChakraHost.newLine || "\r\n", | |
| args: ChakraHost.args, | |
| useCaseSensitiveFileNames: !!ChakraHost.useCaseSensitiveFileNames, | |
| write: ChakraHost.echo, | |
| readFile: function (path, _encoding) { | |
| return ChakraHost.readFile(path); | |
| }, | |
| writeFile: function (path, data, writeByteOrderMark) { | |
| if (writeByteOrderMark) { | |
| data = byteOrderMarkIndicator + data; | |
| } | |
| ChakraHost.writeFile(path, data); | |
| }, | |
| resolvePath: ChakraHost.resolvePath, | |
| fileExists: ChakraHost.fileExists, | |
| deleteFile: ChakraHost.deleteFile, | |
| getModifiedTime: ChakraHost.getModifiedTime, | |
| setModifiedTime: ChakraHost.setModifiedTime, | |
| directoryExists: ChakraHost.directoryExists, | |
| createDirectory: ChakraHost.createDirectory, | |
| getExecutingFilePath: function () { return ChakraHost.executingFile; }, | |
| getCurrentDirectory: function () { return ChakraHost.currentDirectory; }, | |
| getDirectories: ChakraHost.getDirectories, | |
| getEnvironmentVariable: ChakraHost.getEnvironmentVariable || (function () { return ""; }), | |
| readDirectory: function (path, extensions, excludes, includes, _depth) { | |
| var pattern = ts_getFileMatcherPatterns(path, excludes, includes, !!ChakraHost.useCaseSensitiveFileNames, ChakraHost.currentDirectory); | |
| return ChakraHost.readDirectory(path, extensions, pattern.basePaths, pattern.excludePattern, pattern.includeFilePattern, pattern.includeDirectoryPattern); | |
| }, | |
| exit: ChakraHost.quit, | |
| realpath: realpath | |
| }; | |
| } | |
| var sys; | |
| if (typeof ChakraHost !== "undefined") { | |
| sys = getChakraSystem(); | |
| } | |
| else if (typeof process !== "undefined" && process.nextTick && !process.browser && typeof require !== "undefined") { | |
| sys = getNodeSystem(); | |
| } | |
| if (sys) { | |
| patchWriteFileEnsuringDirectory(sys); | |
| } | |
| return sys; | |
| })(); | |
| if (ts_sys && ts_sys.getEnvironmentVariable) { | |
| setCustomPollingValues(ts_sys); | |
| ts_Debug.currentAssertionLevel = /^development$/i.test(ts_sys.getEnvironmentVariable("NODE_ENV")) | |
| ? 1 | |
| : 0; | |
| } | |
| if (ts_sys && ts_sys.debugMode) { | |
| ts_Debug.isDebugging = true; | |
| } | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| ts_directorySeparator = "/"; | |
| var altDirectorySeparator = "\\"; | |
| var urlSchemeSeparator = "://"; | |
| var backslashRegExp = /\\/g; | |
| function isAnyDirectorySeparator(charCode) { | |
| return charCode === 47 || charCode === 92; | |
| } | |
| ts_isAnyDirectorySeparator = isAnyDirectorySeparator; | |
| function isUrl(path) { | |
| return getEncodedRootLength(path) < 0; | |
| } | |
| ts_isUrl = isUrl; | |
| function isRootedDiskPath(path) { | |
| return getEncodedRootLength(path) > 0; | |
| } | |
| ts_isRootedDiskPath = isRootedDiskPath; | |
| function isDiskPathRoot(path) { | |
| var rootLength = getEncodedRootLength(path); | |
| return rootLength > 0 && rootLength === path.length; | |
| } | |
| ts_isDiskPathRoot = isDiskPathRoot; | |
| function pathIsAbsolute(path) { | |
| return getEncodedRootLength(path) !== 0; | |
| } | |
| ts_pathIsAbsolute = pathIsAbsolute; | |
| function pathIsRelative(path) { | |
| return /^\.\.?($|[\\/])/.test(path); | |
| } | |
| ts_pathIsRelative = pathIsRelative; | |
| function hasExtension(fileName) { | |
| return ts_stringContains(getBaseFileName(fileName), "."); | |
| } | |
| ts_hasExtension = hasExtension; | |
| function fileExtensionIs(path, extension) { | |
| return path.length > extension.length && ts_endsWith(path, extension); | |
| } | |
| ts_fileExtensionIs = fileExtensionIs; | |
| function fileExtensionIsOneOf(path, extensions) { | |
| for (var _i = 0, extensions_1 = extensions; _i < extensions_1.length; _i++) { | |
| var extension = extensions_1[_i]; | |
| if (fileExtensionIs(path, extension)) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| ts_fileExtensionIsOneOf = fileExtensionIsOneOf; | |
| function hasTrailingDirectorySeparator(path) { | |
| return path.length > 0 && isAnyDirectorySeparator(path.charCodeAt(path.length - 1)); | |
| } | |
| ts_hasTrailingDirectorySeparator = hasTrailingDirectorySeparator; | |
| function isVolumeCharacter(charCode) { | |
| return (charCode >= 97 && charCode <= 122) || | |
| (charCode >= 65 && charCode <= 90); | |
| } | |
| function getFileUrlVolumeSeparatorEnd(url, start) { | |
| var ch0 = url.charCodeAt(start); | |
| if (ch0 === 58) | |
| return start + 1; | |
| if (ch0 === 37 && url.charCodeAt(start + 1) === 51) { | |
| var ch2 = url.charCodeAt(start + 2); | |
| if (ch2 === 97 || ch2 === 65) | |
| return start + 3; | |
| } | |
| return -1; | |
| } | |
| function getEncodedRootLength(path) { | |
| if (!path) | |
| return 0; | |
| var ch0 = path.charCodeAt(0); | |
| if (ch0 === 47 || ch0 === 92) { | |
| if (path.charCodeAt(1) !== ch0) | |
| return 1; | |
| var p1 = path.indexOf(ch0 === 47 ? ts_directorySeparator : altDirectorySeparator, 2); | |
| if (p1 < 0) | |
| return path.length; | |
| return p1 + 1; | |
| } | |
| if (isVolumeCharacter(ch0) && path.charCodeAt(1) === 58) { | |
| var ch2 = path.charCodeAt(2); | |
| if (ch2 === 47 || ch2 === 92) | |
| return 3; | |
| if (path.length === 2) | |
| return 2; | |
| } | |
| var schemeEnd = path.indexOf(urlSchemeSeparator); | |
| if (schemeEnd !== -1) { | |
| var authorityStart = schemeEnd + urlSchemeSeparator.length; | |
| var authorityEnd = path.indexOf(ts_directorySeparator, authorityStart); | |
| if (authorityEnd !== -1) { | |
| var scheme = path.slice(0, schemeEnd); | |
| var authority = path.slice(authorityStart, authorityEnd); | |
| if (scheme === "file" && (authority === "" || authority === "localhost") && | |
| isVolumeCharacter(path.charCodeAt(authorityEnd + 1))) { | |
| var volumeSeparatorEnd = getFileUrlVolumeSeparatorEnd(path, authorityEnd + 2); | |
| if (volumeSeparatorEnd !== -1) { | |
| if (path.charCodeAt(volumeSeparatorEnd) === 47) { | |
| return ~(volumeSeparatorEnd + 1); | |
| } | |
| if (volumeSeparatorEnd === path.length) { | |
| return ~volumeSeparatorEnd; | |
| } | |
| } | |
| } | |
| return ~(authorityEnd + 1); | |
| } | |
| return ~path.length; | |
| } | |
| return 0; | |
| } | |
| function getRootLength(path) { | |
| var rootLength = getEncodedRootLength(path); | |
| return rootLength < 0 ? ~rootLength : rootLength; | |
| } | |
| ts_getRootLength = getRootLength; | |
| function getDirectoryPath(path) { | |
| path = normalizeSlashes(path); | |
| var rootLength = getRootLength(path); | |
| if (rootLength === path.length) | |
| return path; | |
| path = removeTrailingDirectorySeparator(path); | |
| return path.slice(0, Math.max(rootLength, path.lastIndexOf(ts_directorySeparator))); | |
| } | |
| ts_getDirectoryPath = getDirectoryPath; | |
| function getBaseFileName(path, extensions, ignoreCase) { | |
| path = normalizeSlashes(path); | |
| var rootLength = getRootLength(path); | |
| if (rootLength === path.length) | |
| return ""; | |
| path = removeTrailingDirectorySeparator(path); | |
| var name = path.slice(Math.max(getRootLength(path), path.lastIndexOf(ts_directorySeparator) + 1)); | |
| var extension = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(name, extensions, ignoreCase) : undefined; | |
| return extension ? name.slice(0, name.length - extension.length) : name; | |
| } | |
| ts_getBaseFileName = getBaseFileName; | |
| function tryGetExtensionFromPath(path, extension, stringEqualityComparer) { | |
| if (!ts_startsWith(extension, ".")) | |
| extension = "." + extension; | |
| if (path.length >= extension.length && path.charCodeAt(path.length - extension.length) === 46) { | |
| var pathExtension = path.slice(path.length - extension.length); | |
| if (stringEqualityComparer(pathExtension, extension)) { | |
| return pathExtension; | |
| } | |
| } | |
| } | |
| function getAnyExtensionFromPathWorker(path, extensions, stringEqualityComparer) { | |
| if (typeof extensions === "string") { | |
| return tryGetExtensionFromPath(path, extensions, stringEqualityComparer) || ""; | |
| } | |
| for (var _i = 0, extensions_2 = extensions; _i < extensions_2.length; _i++) { | |
| var extension = extensions_2[_i]; | |
| var result = tryGetExtensionFromPath(path, extension, stringEqualityComparer); | |
| if (result) | |
| return result; | |
| } | |
| return ""; | |
| } | |
| function getAnyExtensionFromPath(path, extensions, ignoreCase) { | |
| if (extensions) { | |
| return getAnyExtensionFromPathWorker(removeTrailingDirectorySeparator(path), extensions, ignoreCase ? ts_equateStringsCaseInsensitive : ts_equateStringsCaseSensitive); | |
| } | |
| var baseFileName = getBaseFileName(path); | |
| var extensionIndex = baseFileName.lastIndexOf("."); | |
| if (extensionIndex >= 0) { | |
| return baseFileName.substring(extensionIndex); | |
| } | |
| return ""; | |
| } | |
| ts_getAnyExtensionFromPath = getAnyExtensionFromPath; | |
| function pathComponents(path, rootLength) { | |
| var root = path.substring(0, rootLength); | |
| var rest = path.substring(rootLength).split(ts_directorySeparator); | |
| if (rest.length && !ts_lastOrUndefined(rest)) | |
| rest.pop(); | |
| return __spreadArrays([root], rest); | |
| } | |
| function getPathComponents(path, currentDirectory) { | |
| if (currentDirectory === void 0) { currentDirectory = ""; } | |
| path = combinePaths(currentDirectory, path); | |
| return pathComponents(path, getRootLength(path)); | |
| } | |
| ts_getPathComponents = getPathComponents; | |
| function getPathFromPathComponents(pathComponents) { | |
| if (pathComponents.length === 0) | |
| return ""; | |
| var root = pathComponents[0] && ensureTrailingDirectorySeparator(pathComponents[0]); | |
| return root + pathComponents.slice(1).join(ts_directorySeparator); | |
| } | |
| ts_getPathFromPathComponents = getPathFromPathComponents; | |
| function normalizeSlashes(path) { | |
| return path.replace(backslashRegExp, ts_directorySeparator); | |
| } | |
| ts_normalizeSlashes = normalizeSlashes; | |
| function reducePathComponents(components) { | |
| if (!ts_some(components)) | |
| return []; | |
| var reduced = [components[0]]; | |
| for (var i = 1; i < components.length; i++) { | |
| var component = components[i]; | |
| if (!component) | |
| continue; | |
| if (component === ".") | |
| continue; | |
| if (component === "..") { | |
| if (reduced.length > 1) { | |
| if (reduced[reduced.length - 1] !== "..") { | |
| reduced.pop(); | |
| continue; | |
| } | |
| } | |
| else if (reduced[0]) | |
| continue; | |
| } | |
| reduced.push(component); | |
| } | |
| return reduced; | |
| } | |
| ts_reducePathComponents = reducePathComponents; | |
| function combinePaths(path) { | |
| var paths = []; | |
| for (var _i = 1; _i < arguments.length; _i++) { | |
| paths[_i - 1] = arguments[_i]; | |
| } | |
| if (path) | |
| path = normalizeSlashes(path); | |
| for (var _a = 0, paths_1 = paths; _a < paths_1.length; _a++) { | |
| var relativePath = paths_1[_a]; | |
| if (!relativePath) | |
| continue; | |
| relativePath = normalizeSlashes(relativePath); | |
| if (!path || getRootLength(relativePath) !== 0) { | |
| path = relativePath; | |
| } | |
| else { | |
| path = ensureTrailingDirectorySeparator(path) + relativePath; | |
| } | |
| } | |
| return path; | |
| } | |
| ts_combinePaths = combinePaths; | |
| function resolvePath(path) { | |
| var paths = []; | |
| for (var _i = 1; _i < arguments.length; _i++) { | |
| paths[_i - 1] = arguments[_i]; | |
| } | |
| return normalizePath(ts_some(paths) ? combinePaths.apply(void 0, __spreadArrays([path], paths)) : normalizeSlashes(path)); | |
| } | |
| ts_resolvePath = resolvePath; | |
| function getNormalizedPathComponents(path, currentDirectory) { | |
| return reducePathComponents(getPathComponents(path, currentDirectory)); | |
| } | |
| ts_getNormalizedPathComponents = getNormalizedPathComponents; | |
| function getNormalizedAbsolutePath(fileName, currentDirectory) { | |
| return getPathFromPathComponents(getNormalizedPathComponents(fileName, currentDirectory)); | |
| } | |
| ts_getNormalizedAbsolutePath = getNormalizedAbsolutePath; | |
| function normalizePath(path) { | |
| path = normalizeSlashes(path); | |
| var normalized = getPathFromPathComponents(reducePathComponents(getPathComponents(path))); | |
| return normalized && hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(normalized) : normalized; | |
| } | |
| ts_normalizePath = normalizePath; | |
| function getPathWithoutRoot(pathComponents) { | |
| if (pathComponents.length === 0) | |
| return ""; | |
| return pathComponents.slice(1).join(ts_directorySeparator); | |
| } | |
| function getNormalizedAbsolutePathWithoutRoot(fileName, currentDirectory) { | |
| return getPathWithoutRoot(getNormalizedPathComponents(fileName, currentDirectory)); | |
| } | |
| ts_getNormalizedAbsolutePathWithoutRoot = getNormalizedAbsolutePathWithoutRoot; | |
| function toPath(fileName, basePath, getCanonicalFileName) { | |
| var nonCanonicalizedPath = isRootedDiskPath(fileName) | |
| ? normalizePath(fileName) | |
| : getNormalizedAbsolutePath(fileName, basePath); | |
| return getCanonicalFileName(nonCanonicalizedPath); | |
| } | |
| ts_toPath = toPath; | |
| function normalizePathAndParts(path) { | |
| path = normalizeSlashes(path); | |
| var _a = reducePathComponents(getPathComponents(path)), root = _a[0], parts = _a.slice(1); | |
| if (parts.length) { | |
| var joinedParts = root + parts.join(ts_directorySeparator); | |
| return { path: hasTrailingDirectorySeparator(path) ? ensureTrailingDirectorySeparator(joinedParts) : joinedParts, parts: parts }; | |
| } | |
| else { | |
| return { path: root, parts: parts }; | |
| } | |
| } | |
| ts_normalizePathAndParts = normalizePathAndParts; | |
| function removeTrailingDirectorySeparator(path) { | |
| if (hasTrailingDirectorySeparator(path)) { | |
| return path.substr(0, path.length - 1); | |
| } | |
| return path; | |
| } | |
| ts_removeTrailingDirectorySeparator = removeTrailingDirectorySeparator; | |
| function ensureTrailingDirectorySeparator(path) { | |
| if (!hasTrailingDirectorySeparator(path)) { | |
| return path + ts_directorySeparator; | |
| } | |
| return path; | |
| } | |
| ts_ensureTrailingDirectorySeparator = ensureTrailingDirectorySeparator; | |
| function ensurePathIsNonModuleName(path) { | |
| return !pathIsAbsolute(path) && !pathIsRelative(path) ? "./" + path : path; | |
| } | |
| ts_ensurePathIsNonModuleName = ensurePathIsNonModuleName; | |
| function changeAnyExtension(path, ext, extensions, ignoreCase) { | |
| var pathext = extensions !== undefined && ignoreCase !== undefined ? getAnyExtensionFromPath(path, extensions, ignoreCase) : getAnyExtensionFromPath(path); | |
| return pathext ? path.slice(0, path.length - pathext.length) + (ts_startsWith(ext, ".") ? ext : "." + ext) : path; | |
| } | |
| ts_changeAnyExtension = changeAnyExtension; | |
| var relativePathSegmentRegExp = /(^|\/)\.{0,2}($|\/)/; | |
| function comparePathsWorker(a, b, componentComparer) { | |
| if (a === b) | |
| return 0; | |
| if (a === undefined) | |
| return -1; | |
| if (b === undefined) | |
| return 1; | |
| var aRoot = a.substring(0, getRootLength(a)); | |
| var bRoot = b.substring(0, getRootLength(b)); | |
| var result = ts_compareStringsCaseInsensitive(aRoot, bRoot); | |
| if (result !== 0) { | |
| return result; | |
| } | |
| var aRest = a.substring(aRoot.length); | |
| var bRest = b.substring(bRoot.length); | |
| if (!relativePathSegmentRegExp.test(aRest) && !relativePathSegmentRegExp.test(bRest)) { | |
| return componentComparer(aRest, bRest); | |
| } | |
| var aComponents = reducePathComponents(getPathComponents(a)); | |
| var bComponents = reducePathComponents(getPathComponents(b)); | |
| var sharedLength = Math.min(aComponents.length, bComponents.length); | |
| for (var i = 1; i < sharedLength; i++) { | |
| var result_1 = componentComparer(aComponents[i], bComponents[i]); | |
| if (result_1 !== 0) { | |
| return result_1; | |
| } | |
| } | |
| return ts_compareValues(aComponents.length, bComponents.length); | |
| } | |
| function comparePathsCaseSensitive(a, b) { | |
| return comparePathsWorker(a, b, ts_compareStringsCaseSensitive); | |
| } | |
| ts_comparePathsCaseSensitive = comparePathsCaseSensitive; | |
| function comparePathsCaseInsensitive(a, b) { | |
| return comparePathsWorker(a, b, ts_compareStringsCaseInsensitive); | |
| } | |
| ts_comparePathsCaseInsensitive = comparePathsCaseInsensitive; | |
| function comparePaths(a, b, currentDirectory, ignoreCase) { | |
| if (typeof currentDirectory === "string") { | |
| a = combinePaths(currentDirectory, a); | |
| b = combinePaths(currentDirectory, b); | |
| } | |
| else if (typeof currentDirectory === "boolean") { | |
| ignoreCase = currentDirectory; | |
| } | |
| return comparePathsWorker(a, b, ts_getStringComparer(ignoreCase)); | |
| } | |
| ts_comparePaths = comparePaths; | |
| function containsPath(parent, child, currentDirectory, ignoreCase) { | |
| if (typeof currentDirectory === "string") { | |
| parent = combinePaths(currentDirectory, parent); | |
| child = combinePaths(currentDirectory, child); | |
| } | |
| else if (typeof currentDirectory === "boolean") { | |
| ignoreCase = currentDirectory; | |
| } | |
| if (parent === undefined || child === undefined) | |
| return false; | |
| if (parent === child) | |
| return true; | |
| var parentComponents = reducePathComponents(getPathComponents(parent)); | |
| var childComponents = reducePathComponents(getPathComponents(child)); | |
| if (childComponents.length < parentComponents.length) { | |
| return false; | |
| } | |
| var componentEqualityComparer = ignoreCase ? ts_equateStringsCaseInsensitive : ts_equateStringsCaseSensitive; | |
| for (var i = 0; i < parentComponents.length; i++) { | |
| var equalityComparer = i === 0 ? ts_equateStringsCaseInsensitive : componentEqualityComparer; | |
| if (!equalityComparer(parentComponents[i], childComponents[i])) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| ts_containsPath = containsPath; | |
| function startsWithDirectory(fileName, directoryName, getCanonicalFileName) { | |
| var canonicalFileName = getCanonicalFileName(fileName); | |
| var canonicalDirectoryName = getCanonicalFileName(directoryName); | |
| return ts_startsWith(canonicalFileName, canonicalDirectoryName + "/") || ts_startsWith(canonicalFileName, canonicalDirectoryName + "\\"); | |
| } | |
| ts_startsWithDirectory = startsWithDirectory; | |
| function getPathComponentsRelativeTo(from, to, stringEqualityComparer, getCanonicalFileName) { | |
| var fromComponents = reducePathComponents(getPathComponents(from)); | |
| var toComponents = reducePathComponents(getPathComponents(to)); | |
| var start; | |
| for (start = 0; start < fromComponents.length && start < toComponents.length; start++) { | |
| var fromComponent = getCanonicalFileName(fromComponents[start]); | |
| var toComponent = getCanonicalFileName(toComponents[start]); | |
| var comparer = start === 0 ? ts_equateStringsCaseInsensitive : stringEqualityComparer; | |
| if (!comparer(fromComponent, toComponent)) | |
| break; | |
| } | |
| if (start === 0) { | |
| return toComponents; | |
| } | |
| var components = toComponents.slice(start); | |
| var relative = []; | |
| for (; start < fromComponents.length; start++) { | |
| relative.push(".."); | |
| } | |
| return __spreadArrays([""], relative, components); | |
| } | |
| ts_getPathComponentsRelativeTo = getPathComponentsRelativeTo; | |
| function getRelativePathFromDirectory(fromDirectory, to, getCanonicalFileNameOrIgnoreCase) { | |
| ts_Debug.assert((getRootLength(fromDirectory) > 0) === (getRootLength(to) > 0), "Paths must either both be absolute or both be relative"); | |
| var getCanonicalFileName = typeof getCanonicalFileNameOrIgnoreCase === "function" ? getCanonicalFileNameOrIgnoreCase : ts_identity; | |
| var ignoreCase = typeof getCanonicalFileNameOrIgnoreCase === "boolean" ? getCanonicalFileNameOrIgnoreCase : false; | |
| var pathComponents = getPathComponentsRelativeTo(fromDirectory, to, ignoreCase ? ts_equateStringsCaseInsensitive : ts_equateStringsCaseSensitive, getCanonicalFileName); | |
| return getPathFromPathComponents(pathComponents); | |
| } | |
| ts_getRelativePathFromDirectory = getRelativePathFromDirectory; | |
| function convertToRelativePath(absoluteOrRelativePath, basePath, getCanonicalFileName) { | |
| return !isRootedDiskPath(absoluteOrRelativePath) | |
| ? absoluteOrRelativePath | |
| : getRelativePathToDirectoryOrUrl(basePath, absoluteOrRelativePath, basePath, getCanonicalFileName, false); | |
| } | |
| ts_convertToRelativePath = convertToRelativePath; | |
| function getRelativePathFromFile(from, to, getCanonicalFileName) { | |
| return ensurePathIsNonModuleName(getRelativePathFromDirectory(getDirectoryPath(from), to, getCanonicalFileName)); | |
| } | |
| ts_getRelativePathFromFile = getRelativePathFromFile; | |
| function getRelativePathToDirectoryOrUrl(directoryPathOrUrl, relativeOrAbsolutePath, currentDirectory, getCanonicalFileName, isAbsolutePathAnUrl) { | |
| var pathComponents = getPathComponentsRelativeTo(resolvePath(currentDirectory, directoryPathOrUrl), resolvePath(currentDirectory, relativeOrAbsolutePath), ts_equateStringsCaseSensitive, getCanonicalFileName); | |
| var firstComponent = pathComponents[0]; | |
| if (isAbsolutePathAnUrl && isRootedDiskPath(firstComponent)) { | |
| var prefix = firstComponent.charAt(0) === ts_directorySeparator ? "file://" : "file:///"; | |
| pathComponents[0] = prefix + firstComponent; | |
| } | |
| return getPathFromPathComponents(pathComponents); | |
| } | |
| ts_getRelativePathToDirectoryOrUrl = getRelativePathToDirectoryOrUrl; | |
| function forEachAncestorDirectory(directory, callback) { | |
| while (true) { | |
| var result = callback(directory); | |
| if (result !== undefined) { | |
| return result; | |
| } | |
| var parentPath = getDirectoryPath(directory); | |
| if (parentPath === directory) { | |
| return undefined; | |
| } | |
| directory = parentPath; | |
| } | |
| } | |
| ts_forEachAncestorDirectory = forEachAncestorDirectory; | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| function diag(code, category, key, message, reportsUnnecessary, elidedInCompatabilityPyramid) { | |
| return { code: code, category: category, key: key, message: message, reportsUnnecessary: reportsUnnecessary, elidedInCompatabilityPyramid: elidedInCompatabilityPyramid }; | |
| } | |
| ts_Diagnostics = { | |
| Unterminated_string_literal: diag(1002, ts_DiagnosticCategory.Error, "Unterminated_string_literal_1002", "Unterminated string literal."), | |
| Identifier_expected: diag(1003, ts_DiagnosticCategory.Error, "Identifier_expected_1003", "Identifier expected."), | |
| _0_expected: diag(1005, ts_DiagnosticCategory.Error, "_0_expected_1005", "'{0}' expected."), | |
| A_file_cannot_have_a_reference_to_itself: diag(1006, ts_DiagnosticCategory.Error, "A_file_cannot_have_a_reference_to_itself_1006", "A file cannot have a reference to itself."), | |
| The_parser_expected_to_find_a_to_match_the_token_here: diag(1007, ts_DiagnosticCategory.Error, "The_parser_expected_to_find_a_to_match_the_token_here_1007", "The parser expected to find a '}' to match the '{' token here."), | |
| Trailing_comma_not_allowed: diag(1009, ts_DiagnosticCategory.Error, "Trailing_comma_not_allowed_1009", "Trailing comma not allowed."), | |
| Asterisk_Slash_expected: diag(1010, ts_DiagnosticCategory.Error, "Asterisk_Slash_expected_1010", "'*/' expected."), | |
| An_element_access_expression_should_take_an_argument: diag(1011, ts_DiagnosticCategory.Error, "An_element_access_expression_should_take_an_argument_1011", "An element access expression should take an argument."), | |
| Unexpected_token: diag(1012, ts_DiagnosticCategory.Error, "Unexpected_token_1012", "Unexpected token."), | |
| A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma: diag(1013, ts_DiagnosticCategory.Error, "A_rest_parameter_or_binding_pattern_may_not_have_a_trailing_comma_1013", "A rest parameter or binding pattern may not have a trailing comma."), | |
| A_rest_parameter_must_be_last_in_a_parameter_list: diag(1014, ts_DiagnosticCategory.Error, "A_rest_parameter_must_be_last_in_a_parameter_list_1014", "A rest parameter must be last in a parameter list."), | |
| Parameter_cannot_have_question_mark_and_initializer: diag(1015, ts_DiagnosticCategory.Error, "Parameter_cannot_have_question_mark_and_initializer_1015", "Parameter cannot have question mark and initializer."), | |
| A_required_parameter_cannot_follow_an_optional_parameter: diag(1016, ts_DiagnosticCategory.Error, "A_required_parameter_cannot_follow_an_optional_parameter_1016", "A required parameter cannot follow an optional parameter."), | |
| An_index_signature_cannot_have_a_rest_parameter: diag(1017, ts_DiagnosticCategory.Error, "An_index_signature_cannot_have_a_rest_parameter_1017", "An index signature cannot have a rest parameter."), | |
| An_index_signature_parameter_cannot_have_an_accessibility_modifier: diag(1018, ts_DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_an_accessibility_modifier_1018", "An index signature parameter cannot have an accessibility modifier."), | |
| An_index_signature_parameter_cannot_have_a_question_mark: diag(1019, ts_DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_a_question_mark_1019", "An index signature parameter cannot have a question mark."), | |
| An_index_signature_parameter_cannot_have_an_initializer: diag(1020, ts_DiagnosticCategory.Error, "An_index_signature_parameter_cannot_have_an_initializer_1020", "An index signature parameter cannot have an initializer."), | |
| An_index_signature_must_have_a_type_annotation: diag(1021, ts_DiagnosticCategory.Error, "An_index_signature_must_have_a_type_annotation_1021", "An index signature must have a type annotation."), | |
| An_index_signature_parameter_must_have_a_type_annotation: diag(1022, ts_DiagnosticCategory.Error, "An_index_signature_parameter_must_have_a_type_annotation_1022", "An index signature parameter must have a type annotation."), | |
| An_index_signature_parameter_type_must_be_either_string_or_number: diag(1023, ts_DiagnosticCategory.Error, "An_index_signature_parameter_type_must_be_either_string_or_number_1023", "An index signature parameter type must be either 'string' or 'number'."), | |
| readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature: diag(1024, ts_DiagnosticCategory.Error, "readonly_modifier_can_only_appear_on_a_property_declaration_or_index_signature_1024", "'readonly' modifier can only appear on a property declaration or index signature."), | |
| Accessibility_modifier_already_seen: diag(1028, ts_DiagnosticCategory.Error, "Accessibility_modifier_already_seen_1028", "Accessibility modifier already seen."), | |
| _0_modifier_must_precede_1_modifier: diag(1029, ts_DiagnosticCategory.Error, "_0_modifier_must_precede_1_modifier_1029", "'{0}' modifier must precede '{1}' modifier."), | |
| _0_modifier_already_seen: diag(1030, ts_DiagnosticCategory.Error, "_0_modifier_already_seen_1030", "'{0}' modifier already seen."), | |
| _0_modifier_cannot_appear_on_a_class_element: diag(1031, ts_DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_class_element_1031", "'{0}' modifier cannot appear on a class element."), | |
| super_must_be_followed_by_an_argument_list_or_member_access: diag(1034, ts_DiagnosticCategory.Error, "super_must_be_followed_by_an_argument_list_or_member_access_1034", "'super' must be followed by an argument list or member access."), | |
| Only_ambient_modules_can_use_quoted_names: diag(1035, ts_DiagnosticCategory.Error, "Only_ambient_modules_can_use_quoted_names_1035", "Only ambient modules can use quoted names."), | |
| Statements_are_not_allowed_in_ambient_contexts: diag(1036, ts_DiagnosticCategory.Error, "Statements_are_not_allowed_in_ambient_contexts_1036", "Statements are not allowed in ambient contexts."), | |
| A_declare_modifier_cannot_be_used_in_an_already_ambient_context: diag(1038, ts_DiagnosticCategory.Error, "A_declare_modifier_cannot_be_used_in_an_already_ambient_context_1038", "A 'declare' modifier cannot be used in an already ambient context."), | |
| Initializers_are_not_allowed_in_ambient_contexts: diag(1039, ts_DiagnosticCategory.Error, "Initializers_are_not_allowed_in_ambient_contexts_1039", "Initializers are not allowed in ambient contexts."), | |
| _0_modifier_cannot_be_used_in_an_ambient_context: diag(1040, ts_DiagnosticCategory.Error, "_0_modifier_cannot_be_used_in_an_ambient_context_1040", "'{0}' modifier cannot be used in an ambient context."), | |
| _0_modifier_cannot_be_used_with_a_class_declaration: diag(1041, ts_DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_a_class_declaration_1041", "'{0}' modifier cannot be used with a class declaration."), | |
| _0_modifier_cannot_be_used_here: diag(1042, ts_DiagnosticCategory.Error, "_0_modifier_cannot_be_used_here_1042", "'{0}' modifier cannot be used here."), | |
| _0_modifier_cannot_appear_on_a_data_property: diag(1043, ts_DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_data_property_1043", "'{0}' modifier cannot appear on a data property."), | |
| _0_modifier_cannot_appear_on_a_module_or_namespace_element: diag(1044, ts_DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_module_or_namespace_element_1044", "'{0}' modifier cannot appear on a module or namespace element."), | |
| A_0_modifier_cannot_be_used_with_an_interface_declaration: diag(1045, ts_DiagnosticCategory.Error, "A_0_modifier_cannot_be_used_with_an_interface_declaration_1045", "A '{0}' modifier cannot be used with an interface declaration."), | |
| Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier: diag(1046, ts_DiagnosticCategory.Error, "Top_level_declarations_in_d_ts_files_must_start_with_either_a_declare_or_export_modifier_1046", "Top-level declarations in .d.ts files must start with either a 'declare' or 'export' modifier."), | |
| A_rest_parameter_cannot_be_optional: diag(1047, ts_DiagnosticCategory.Error, "A_rest_parameter_cannot_be_optional_1047", "A rest parameter cannot be optional."), | |
| A_rest_parameter_cannot_have_an_initializer: diag(1048, ts_DiagnosticCategory.Error, "A_rest_parameter_cannot_have_an_initializer_1048", "A rest parameter cannot have an initializer."), | |
| A_set_accessor_must_have_exactly_one_parameter: diag(1049, ts_DiagnosticCategory.Error, "A_set_accessor_must_have_exactly_one_parameter_1049", "A 'set' accessor must have exactly one parameter."), | |
| A_set_accessor_cannot_have_an_optional_parameter: diag(1051, ts_DiagnosticCategory.Error, "A_set_accessor_cannot_have_an_optional_parameter_1051", "A 'set' accessor cannot have an optional parameter."), | |
| A_set_accessor_parameter_cannot_have_an_initializer: diag(1052, ts_DiagnosticCategory.Error, "A_set_accessor_parameter_cannot_have_an_initializer_1052", "A 'set' accessor parameter cannot have an initializer."), | |
| A_set_accessor_cannot_have_rest_parameter: diag(1053, ts_DiagnosticCategory.Error, "A_set_accessor_cannot_have_rest_parameter_1053", "A 'set' accessor cannot have rest parameter."), | |
| A_get_accessor_cannot_have_parameters: diag(1054, ts_DiagnosticCategory.Error, "A_get_accessor_cannot_have_parameters_1054", "A 'get' accessor cannot have parameters."), | |
| Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Promise_compatible_constructor_value: diag(1055, ts_DiagnosticCategory.Error, "Type_0_is_not_a_valid_async_function_return_type_in_ES5_SlashES3_because_it_does_not_refer_to_a_Prom_1055", "Type '{0}' is not a valid async function return type in ES5/ES3 because it does not refer to a Promise-compatible constructor value."), | |
| Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher: diag(1056, ts_DiagnosticCategory.Error, "Accessors_are_only_available_when_targeting_ECMAScript_5_and_higher_1056", "Accessors are only available when targeting ECMAScript 5 and higher."), | |
| An_async_function_or_method_must_have_a_valid_awaitable_return_type: diag(1057, ts_DiagnosticCategory.Error, "An_async_function_or_method_must_have_a_valid_awaitable_return_type_1057", "An async function or method must have a valid awaitable return type."), | |
| The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1058, ts_DiagnosticCategory.Error, "The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_t_1058", "The return type of an async function must either be a valid promise or must not contain a callable 'then' member."), | |
| A_promise_must_have_a_then_method: diag(1059, ts_DiagnosticCategory.Error, "A_promise_must_have_a_then_method_1059", "A promise must have a 'then' method."), | |
| The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback: diag(1060, ts_DiagnosticCategory.Error, "The_first_parameter_of_the_then_method_of_a_promise_must_be_a_callback_1060", "The first parameter of the 'then' method of a promise must be a callback."), | |
| Enum_member_must_have_initializer: diag(1061, ts_DiagnosticCategory.Error, "Enum_member_must_have_initializer_1061", "Enum member must have initializer."), | |
| Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method: diag(1062, ts_DiagnosticCategory.Error, "Type_is_referenced_directly_or_indirectly_in_the_fulfillment_callback_of_its_own_then_method_1062", "Type is referenced directly or indirectly in the fulfillment callback of its own 'then' method."), | |
| An_export_assignment_cannot_be_used_in_a_namespace: diag(1063, ts_DiagnosticCategory.Error, "An_export_assignment_cannot_be_used_in_a_namespace_1063", "An export assignment cannot be used in a namespace."), | |
| The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type: diag(1064, ts_DiagnosticCategory.Error, "The_return_type_of_an_async_function_or_method_must_be_the_global_Promise_T_type_1064", "The return type of an async function or method must be the global Promise<T> type."), | |
| In_ambient_enum_declarations_member_initializer_must_be_constant_expression: diag(1066, ts_DiagnosticCategory.Error, "In_ambient_enum_declarations_member_initializer_must_be_constant_expression_1066", "In ambient enum declarations member initializer must be constant expression."), | |
| Unexpected_token_A_constructor_method_accessor_or_property_was_expected: diag(1068, ts_DiagnosticCategory.Error, "Unexpected_token_A_constructor_method_accessor_or_property_was_expected_1068", "Unexpected token. A constructor, method, accessor, or property was expected."), | |
| Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces: diag(1069, ts_DiagnosticCategory.Error, "Unexpected_token_A_type_parameter_name_was_expected_without_curly_braces_1069", "Unexpected token. A type parameter name was expected without curly braces."), | |
| _0_modifier_cannot_appear_on_a_type_member: diag(1070, ts_DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_type_member_1070", "'{0}' modifier cannot appear on a type member."), | |
| _0_modifier_cannot_appear_on_an_index_signature: diag(1071, ts_DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_an_index_signature_1071", "'{0}' modifier cannot appear on an index signature."), | |
| A_0_modifier_cannot_be_used_with_an_import_declaration: diag(1079, ts_DiagnosticCategory.Error, "A_0_modifier_cannot_be_used_with_an_import_declaration_1079", "A '{0}' modifier cannot be used with an import declaration."), | |
| Invalid_reference_directive_syntax: diag(1084, ts_DiagnosticCategory.Error, "Invalid_reference_directive_syntax_1084", "Invalid 'reference' directive syntax."), | |
| Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0: diag(1085, ts_DiagnosticCategory.Error, "Octal_literals_are_not_available_when_targeting_ECMAScript_5_and_higher_Use_the_syntax_0_1085", "Octal literals are not available when targeting ECMAScript 5 and higher. Use the syntax '{0}'."), | |
| _0_modifier_cannot_appear_on_a_constructor_declaration: diag(1089, ts_DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_constructor_declaration_1089", "'{0}' modifier cannot appear on a constructor declaration."), | |
| _0_modifier_cannot_appear_on_a_parameter: diag(1090, ts_DiagnosticCategory.Error, "_0_modifier_cannot_appear_on_a_parameter_1090", "'{0}' modifier cannot appear on a parameter."), | |
| Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement: diag(1091, ts_DiagnosticCategory.Error, "Only_a_single_variable_declaration_is_allowed_in_a_for_in_statement_1091", "Only a single variable declaration is allowed in a 'for...in' statement."), | |
| Type_parameters_cannot_appear_on_a_constructor_declaration: diag(1092, ts_DiagnosticCategory.Error, "Type_parameters_cannot_appear_on_a_constructor_declaration_1092", "Type parameters cannot appear on a constructor declaration."), | |
| Type_annotation_cannot_appear_on_a_constructor_declaration: diag(1093, ts_DiagnosticCategory.Error, "Type_annotation_cannot_appear_on_a_constructor_declaration_1093", "Type annotation cannot appear on a constructor declaration."), | |
| An_accessor_cannot_have_type_parameters: diag(1094, ts_DiagnosticCategory.Error, "An_accessor_cannot_have_type_parameters_1094", "An accessor cannot have type parameters."), | |
| A_set_accessor_cannot_have_a_return_type_annotation: diag(1095, ts_DiagnosticCategory.Error, "A_set_accessor_cannot_have_a_return_type_annotation_1095", "A 'set' accessor cannot have a return type annotation."), | |
| An_index_signature_must_have_exactly_one_parameter: diag(1096, ts_DiagnosticCategory.Error, "An_index_signature_must_have_exactly_one_parameter_1096", "An index signature must have exactly one parameter."), | |
| _0_list_cannot_be_empty: diag(1097, ts_DiagnosticCategory.Error, "_0_list_cannot_be_empty_1097", "'{0}' list cannot be empty."), | |
| Type_parameter_list_cannot_be_empty: diag(1098, ts_DiagnosticCategory.Error, "Type_parameter_list_cannot_be_empty_1098", "Type parameter list cannot be empty."), | |
| Type_argument_list_cannot_be_empty: diag(1099, ts_DiagnosticCategory.Error, "Type_argument_list_cannot_be_empty_1099", "Type argument list cannot be empty."), | |
| Invalid_use_of_0_in_strict_mode: diag(1100, ts_DiagnosticCategory.Error, "Invalid_use_of_0_in_strict_mode_1100", "Invalid use of '{0}' in strict mode."), | |
| with_statements_are_not_allowed_in_strict_mode: diag(1101, ts_DiagnosticCategory.Error, "with_statements_are_not_allowed_in_strict_mode_1101", "'with' statements are not allowed in strict mode."), | |
| delete_cannot_be_called_on_an_identifier_in_strict_mode: diag(1102, ts_DiagnosticCategory.Error, "delete_cannot_be_called_on_an_identifier_in_strict_mode_1102", "'delete' cannot be called on an identifier in strict mode."), | |
| A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator: diag(1103, ts_DiagnosticCategory.Error, "A_for_await_of_statement_is_only_allowed_within_an_async_function_or_async_generator_1103", "A 'for-await-of' statement is only allowed within an async function or async generator."), | |
| A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement: diag(1104, ts_DiagnosticCategory.Error, "A_continue_statement_can_only_be_used_within_an_enclosing_iteration_statement_1104", "A 'continue' statement can only be used within an enclosing iteration statement."), | |
| A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement: diag(1105, ts_DiagnosticCategory.Error, "A_break_statement_can_only_be_used_within_an_enclosing_iteration_or_switch_statement_1105", "A 'break' statement can only be used within an enclosing iteration or switch statement."), | |
| Jump_target_cannot_cross_function_boundary: diag(1107, ts_DiagnosticCategory.Error, "Jump_target_cannot_cross_function_boundary_1107", "Jump target cannot cross function boundary."), | |
| A_return_statement_can_only_be_used_within_a_function_body: diag(1108, ts_DiagnosticCategory.Error, "A_return_statement_can_only_be_used_within_a_function_body_1108", "A 'return' statement can only be used within a function body."), | |
| Expression_expected: diag(1109, ts_DiagnosticCategory.Error, "Expression_expected_1109", "Expression expected."), | |
| Type_expected: diag(1110, ts_DiagnosticCategory.Error, "Type_expected_1110", "Type expected."), | |
| A_default_clause_cannot_appear_more_than_once_in_a_switch_statement: diag(1113, ts_DiagnosticCategory.Error, "A_default_clause_cannot_appear_more_than_once_in_a_switch_statement_1113", "A 'default' clause cannot appear more than once in a 'switch' statement."), | |
| Duplicate_label_0: diag(1114, ts_DiagnosticCategory.Error, "Duplicate_label_0_1114", "Duplicate label '{0}'."), | |
| A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement: diag(1115, ts_DiagnosticCategory.Error, "A_continue_statement_can_only_jump_to_a_label_of_an_enclosing_iteration_statement_1115", "A 'continue' statement can only jump to a label of an enclosing iteration statement."), | |
| A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement: diag(1116, ts_DiagnosticCategory.Error, "A_break_statement_can_only_jump_to_a_label_of_an_enclosing_statement_1116", "A 'break' statement can only jump to a label of an enclosing statement."), | |
| An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode: diag(1117, ts_DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_properties_with_the_same_name_in_strict_mode_1117", "An object literal cannot have multiple properties with the same name in strict mode."), | |
| An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name: diag(1118, ts_DiagnosticCategory.Error, "An_object_literal_cannot_have_multiple_get_Slashset_accessors_with_the_same_name_1118", "An object literal cannot have multiple get/set accessors with the same name."), | |
| An_object_literal_cannot_have_property_and_accessor_with_the_same_name: diag(1119, ts_DiagnosticCategory.Error, "An_object_literal_cannot_have_property_and_accessor_with_the_same_name_1119", "An object literal cannot have property and accessor with the same name."), | |
| An_export_assignment_cannot_have_modifiers: diag(1120, ts_DiagnosticCategory.Error, "An_export_assignment_cannot_have_modifiers_1120", "An export assignment cannot have modifiers."), | |
| Octal_literals_are_not_allowed_in_strict_mode: diag(1121, ts_DiagnosticCategory.Error, "Octal_literals_are_not_allowed_in_strict_mode_1121", "Octal literals are not allowed in strict mode."), | |
| Variable_declaration_list_cannot_be_empty: diag(1123, ts_DiagnosticCategory.Error, "Variable_declaration_list_cannot_be_empty_1123", "Variable declaration list cannot be empty."), | |
| Digit_expected: diag(1124, ts_DiagnosticCategory.Error, "Digit_expected_1124", "Digit expected."), | |
| Hexadecimal_digit_expected: diag(1125, ts_DiagnosticCategory.Error, "Hexadecimal_digit_expected_1125", "Hexadecimal digit expected."), | |
| Unexpected_end_of_text: diag(1126, ts_DiagnosticCategory.Error, "Unexpected_end_of_text_1126", "Unexpected end of text."), | |
| Invalid_character: diag(1127, ts_DiagnosticCategory.Error, "Invalid_character_1127", "Invalid character."), | |
| Declaration_or_statement_expected: diag(1128, ts_DiagnosticCategory.Error, "Declaration_or_statement_expected_1128", "Declaration or statement expected."), | |
| Statement_expected: diag(1129, ts_DiagnosticCategory.Error, "Statement_expected_1129", "Statement expected."), | |
| case_or_default_expected: diag(1130, ts_DiagnosticCategory.Error, "case_or_default_expected_1130", "'case' or 'default' expected."), | |
| Property_or_signature_expected: diag(1131, ts_DiagnosticCategory.Error, "Property_or_signature_expected_1131", "Property or signature expected."), | |
| Enum_member_expected: diag(1132, ts_DiagnosticCategory.Error, "Enum_member_expected_1132", "Enum member expected."), | |
| Variable_declaration_expected: diag(1134, ts_DiagnosticCategory.Error, "Variable_declaration_expected_1134", "Variable declaration expected."), | |
| Argument_expression_expected: diag(1135, ts_DiagnosticCategory.Error, "Argument_expression_expected_1135", "Argument expression expected."), | |
| Property_assignment_expected: diag(1136, ts_DiagnosticCategory.Error, "Property_assignment_expected_1136", "Property assignment expected."), | |
| Expression_or_comma_expected: diag(1137, ts_DiagnosticCategory.Error, "Expression_or_comma_expected_1137", "Expression or comma expected."), | |
| Parameter_declaration_expected: diag(1138, ts_DiagnosticCategory.Error, "Parameter_declaration_expected_1138", "Parameter declaration expected."), | |
| Type_parameter_declaration_expected: diag(1139, ts_DiagnosticCategory.Error, "Type_parameter_declaration_expected_1139", "Type parameter declaration expected."), | |
| Type_argument_expected: diag(1140, ts_DiagnosticCategory.Error, "Type_argument_expected_1140", "Type argument expected."), | |
| String_literal_expected: diag(1141, ts_DiagnosticCategory.Error, "String_literal_expected_1141", "String literal expected."), | |
| Line_break_not_permitted_here: diag(1142, ts_DiagnosticCategory.Error, "Line_break_not_permitted_here_1142", "Line break not permitted here."), | |
| or_expected: diag(1144, ts_DiagnosticCategory.Error, "or_expected_1144", "'{' or ';' expected."), | |
| Declaration_expected: diag(1146, ts_DiagnosticCategory.Error, "Declaration_expected_1146", "Declaration expected."), | |
| Import_declarations_in_a_namespace_cannot_reference_a_module: diag(1147, ts_DiagnosticCategory.Error, "Import_declarations_in_a_namespace_cannot_reference_a_module_1147", "Import declarations in a namespace cannot reference a module."), | |
| Cannot_use_imports_exports_or_module_augmentations_when_module_is_none: diag(1148, ts_DiagnosticCategory.Error, "Cannot_use_imports_exports_or_module_augmentations_when_module_is_none_1148", "Cannot use imports, exports, or module augmentations when '--module' is 'none'."), | |
| File_name_0_differs_from_already_included_file_name_1_only_in_casing: diag(1149, ts_DiagnosticCategory.Error, "File_name_0_differs_from_already_included_file_name_1_only_in_casing_1149", "File name '{0}' differs from already included file name '{1}' only in casing."), | |
| const_declarations_must_be_initialized: diag(1155, ts_DiagnosticCategory.Error, "const_declarations_must_be_initialized_1155", "'const' declarations must be initialized."), | |
| const_declarations_can_only_be_declared_inside_a_block: diag(1156, ts_DiagnosticCategory.Error, "const_declarations_can_only_be_declared_inside_a_block_1156", "'const' declarations can only be declared inside a block."), | |
| let_declarations_can_only_be_declared_inside_a_block: diag(1157, ts_DiagnosticCategory.Error, "let_declarations_can_only_be_declared_inside_a_block_1157", "'let' declarations can only be declared inside a block."), | |
| Unterminated_template_literal: diag(1160, ts_DiagnosticCategory.Error, "Unterminated_template_literal_1160", "Unterminated template literal."), | |
| Unterminated_regular_expression_literal: diag(1161, ts_DiagnosticCategory.Error, "Unterminated_regular_expression_literal_1161", "Unterminated regular expression literal."), | |
| An_object_member_cannot_be_declared_optional: diag(1162, ts_DiagnosticCategory.Error, "An_object_member_cannot_be_declared_optional_1162", "An object member cannot be declared optional."), | |
| A_yield_expression_is_only_allowed_in_a_generator_body: diag(1163, ts_DiagnosticCategory.Error, "A_yield_expression_is_only_allowed_in_a_generator_body_1163", "A 'yield' expression is only allowed in a generator body."), | |
| Computed_property_names_are_not_allowed_in_enums: diag(1164, ts_DiagnosticCategory.Error, "Computed_property_names_are_not_allowed_in_enums_1164", "Computed property names are not allowed in enums."), | |
| A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1165, ts_DiagnosticCategory.Error, "A_computed_property_name_in_an_ambient_context_must_refer_to_an_expression_whose_type_is_a_literal_t_1165", "A computed property name in an ambient context must refer to an expression whose type is a literal type or a 'unique symbol' type."), | |
| A_computed_property_name_in_a_class_property_declaration_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1166, ts_DiagnosticCategory.Error, "A_computed_property_name_in_a_class_property_declaration_must_refer_to_an_expression_whose_type_is_a_1166", "A computed property name in a class property declaration must refer to an expression whose type is a literal type or a 'unique symbol' type."), | |
| A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1168, ts_DiagnosticCategory.Error, "A_computed_property_name_in_a_method_overload_must_refer_to_an_expression_whose_type_is_a_literal_ty_1168", "A computed property name in a method overload must refer to an expression whose type is a literal type or a 'unique symbol' type."), | |
| A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1169, ts_DiagnosticCategory.Error, "A_computed_property_name_in_an_interface_must_refer_to_an_expression_whose_type_is_a_literal_type_or_1169", "A computed property name in an interface must refer to an expression whose type is a literal type or a 'unique symbol' type."), | |
| A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type_or_a_unique_symbol_type: diag(1170, ts_DiagnosticCategory.Error, "A_computed_property_name_in_a_type_literal_must_refer_to_an_expression_whose_type_is_a_literal_type__1170", "A computed property name in a type literal must refer to an expression whose type is a literal type or a 'unique symbol' type."), | |
| A_comma_expression_is_not_allowed_in_a_computed_property_name: diag(1171, ts_DiagnosticCategory.Error, "A_comma_expression_is_not_allowed_in_a_computed_property_name_1171", "A comma expression is not allowed in a computed property name."), | |
| extends_clause_already_seen: diag(1172, ts_DiagnosticCategory.Error, "extends_clause_already_seen_1172", "'extends' clause already seen."), | |
| extends_clause_must_precede_implements_clause: diag(1173, ts_DiagnosticCategory.Error, "extends_clause_must_precede_implements_clause_1173", "'extends' clause must precede 'implements' clause."), | |
| Classes_can_only_extend_a_single_class: diag(1174, ts_DiagnosticCategory.Error, "Classes_can_only_extend_a_single_class_1174", "Classes can only extend a single class."), | |
| implements_clause_already_seen: diag(1175, ts_DiagnosticCategory.Error, "implements_clause_already_seen_1175", "'implements' clause already seen."), | |
| Interface_declaration_cannot_have_implements_clause: diag(1176, ts_DiagnosticCategory.Error, "Interface_declaration_cannot_have_implements_clause_1176", "Interface declaration cannot have 'implements' clause."), | |
| Binary_digit_expected: diag(1177, ts_DiagnosticCategory.Error, "Binary_digit_expected_1177", "Binary digit expected."), | |
| Octal_digit_expected: diag(1178, ts_DiagnosticCategory.Error, "Octal_digit_expected_1178", "Octal digit expected."), | |
| Unexpected_token_expected: diag(1179, ts_DiagnosticCategory.Error, "Unexpected_token_expected_1179", "Unexpected token. '{' expected."), | |
| Property_destructuring_pattern_expected: diag(1180, ts_DiagnosticCategory.Error, "Property_destructuring_pattern_expected_1180", "Property destructuring pattern expected."), | |
| Array_element_destructuring_pattern_expected: diag(1181, ts_DiagnosticCategory.Error, "Array_element_destructuring_pattern_expected_1181", "Array element destructuring pattern expected."), | |
| A_destructuring_declaration_must_have_an_initializer: diag(1182, ts_DiagnosticCategory.Error, "A_destructuring_declaration_must_have_an_initializer_1182", "A destructuring declaration must have an initializer."), | |
| An_implementation_cannot_be_declared_in_ambient_contexts: diag(1183, ts_DiagnosticCategory.Error, "An_implementation_cannot_be_declared_in_ambient_contexts_1183", "An implementation cannot be declared in ambient contexts."), | |
| Modifiers_cannot_appear_here: diag(1184, ts_DiagnosticCategory.Error, "Modifiers_cannot_appear_here_1184", "Modifiers cannot appear here."), | |
| Merge_conflict_marker_encountered: diag(1185, ts_DiagnosticCategory.Error, "Merge_conflict_marker_encountered_1185", "Merge conflict marker encountered."), | |
| A_rest_element_cannot_have_an_initializer: diag(1186, ts_DiagnosticCategory.Error, "A_rest_element_cannot_have_an_initializer_1186", "A rest element cannot have an initializer."), | |
| A_parameter_property_may_not_be_declared_using_a_binding_pattern: diag(1187, ts_DiagnosticCategory.Error, "A_parameter_property_may_not_be_declared_using_a_binding_pattern_1187", "A parameter property may not be declared using a binding pattern."), | |
| Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement: diag(1188, ts_DiagnosticCategory.Error, "Only_a_single_variable_declaration_is_allowed_in_a_for_of_statement_1188", "Only a single variable declaration is allowed in a 'for...of' statement."), | |
| The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer: diag(1189, ts_DiagnosticCategory.Error, "The_variable_declaration_of_a_for_in_statement_cannot_have_an_initializer_1189", "The variable declaration of a 'for...in' statement cannot have an initializer."), | |
| The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer: diag(1190, ts_DiagnosticCategory.Error, "The_variable_declaration_of_a_for_of_statement_cannot_have_an_initializer_1190", "The variable declaration of a 'for...of' statement cannot have an initializer."), | |
| An_import_declaration_cannot_have_modifiers: diag(1191, ts_DiagnosticCategory.Error, "An_import_declaration_cannot_have_modifiers_1191", "An import declaration cannot have modifiers."), | |
| Module_0_has_no_default_export: diag(1192, ts_DiagnosticCategory.Error, "Module_0_has_no_default_export_1192", "Module '{0}' has no default export."), | |
| An_export_declaration_cannot_have_modifiers: diag(1193, ts_DiagnosticCategory.Error, "An_export_declaration_cannot_have_modifiers_1193", "An export declaration cannot have modifiers."), | |
| Export_declarations_are_not_permitted_in_a_namespace: diag(1194, ts_DiagnosticCategory.Error, "Export_declarations_are_not_permitted_in_a_namespace_1194", "Export declarations are not permitted in a namespace."), | |
| Catch_clause_variable_cannot_have_a_type_annotation: diag(1196, ts_DiagnosticCategory.Error, "Catch_clause_variable_cannot_have_a_type_annotation_1196", "Catch clause variable cannot have a type annotation."), | |
| Catch_clause_variable_cannot_have_an_initializer: diag(1197, ts_DiagnosticCategory.Error, "Catch_clause_variable_cannot_have_an_initializer_1197", "Catch clause variable cannot have an initializer."), | |
| An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive: diag(1198, ts_DiagnosticCategory.Error, "An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive_1198", "An extended Unicode escape value must be between 0x0 and 0x10FFFF inclusive."), | |
| Unterminated_Unicode_escape_sequence: diag(1199, ts_DiagnosticCategory.Error, "Unterminated_Unicode_escape_sequence_1199", "Unterminated Unicode escape sequence."), | |
| Line_terminator_not_permitted_before_arrow: diag(1200, ts_DiagnosticCategory.Error, "Line_terminator_not_permitted_before_arrow_1200", "Line terminator not permitted before arrow."), | |
| Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_ns_from_mod_import_a_from_mod_import_d_from_mod_or_another_module_format_instead: diag(1202, ts_DiagnosticCategory.Error, "Import_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_import_Asterisk_as_1202", "Import assignment cannot be used when targeting ECMAScript modules. Consider using 'import * as ns from \"mod\"', 'import {a} from \"mod\"', 'import d from \"mod\"', or another module format instead."), | |
| Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or_another_module_format_instead: diag(1203, ts_DiagnosticCategory.Error, "Export_assignment_cannot_be_used_when_targeting_ECMAScript_modules_Consider_using_export_default_or__1203", "Export assignment cannot be used when targeting ECMAScript modules. Consider using 'export default' or another module format instead."), | |
| Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type: diag(1205, ts_DiagnosticCategory.Error, "Re_exporting_a_type_when_the_isolatedModules_flag_is_provided_requires_using_export_type_1205", "Re-exporting a type when the '--isolatedModules' flag is provided requires using 'export type'."), | |
| Decorators_are_not_valid_here: diag(1206, ts_DiagnosticCategory.Error, "Decorators_are_not_valid_here_1206", "Decorators are not valid here."), | |
| Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name: diag(1207, ts_DiagnosticCategory.Error, "Decorators_cannot_be_applied_to_multiple_get_Slashset_accessors_of_the_same_name_1207", "Decorators cannot be applied to multiple get/set accessors of the same name."), | |
| All_files_must_be_modules_when_the_isolatedModules_flag_is_provided: diag(1208, ts_DiagnosticCategory.Error, "All_files_must_be_modules_when_the_isolatedModules_flag_is_provided_1208", "All files must be modules when the '--isolatedModules' flag is provided."), | |
| Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode: diag(1210, ts_DiagnosticCategory.Error, "Invalid_use_of_0_Class_definitions_are_automatically_in_strict_mode_1210", "Invalid use of '{0}'. Class definitions are automatically in strict mode."), | |
| A_class_declaration_without_the_default_modifier_must_have_a_name: diag(1211, ts_DiagnosticCategory.Error, "A_class_declaration_without_the_default_modifier_must_have_a_name_1211", "A class declaration without the 'default' modifier must have a name."), | |
| Identifier_expected_0_is_a_reserved_word_in_strict_mode: diag(1212, ts_DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_1212", "Identifier expected. '{0}' is a reserved word in strict mode."), | |
| Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_strict_mode: diag(1213, ts_DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Class_definitions_are_automatically_in_stric_1213", "Identifier expected. '{0}' is a reserved word in strict mode. Class definitions are automatically in strict mode."), | |
| Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode: diag(1214, ts_DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_in_strict_mode_Modules_are_automatically_in_strict_mode_1214", "Identifier expected. '{0}' is a reserved word in strict mode. Modules are automatically in strict mode."), | |
| Invalid_use_of_0_Modules_are_automatically_in_strict_mode: diag(1215, ts_DiagnosticCategory.Error, "Invalid_use_of_0_Modules_are_automatically_in_strict_mode_1215", "Invalid use of '{0}'. Modules are automatically in strict mode."), | |
| Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules: diag(1216, ts_DiagnosticCategory.Error, "Identifier_expected_esModule_is_reserved_as_an_exported_marker_when_transforming_ECMAScript_modules_1216", "Identifier expected. '__esModule' is reserved as an exported marker when transforming ECMAScript modules."), | |
| Export_assignment_is_not_supported_when_module_flag_is_system: diag(1218, ts_DiagnosticCategory.Error, "Export_assignment_is_not_supported_when_module_flag_is_system_1218", "Export assignment is not supported when '--module' flag is 'system'."), | |
| Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_the_experimentalDecorators_option_in_your_tsconfig_or_jsconfig_to_remove_this_warning: diag(1219, ts_DiagnosticCategory.Error, "Experimental_support_for_decorators_is_a_feature_that_is_subject_to_change_in_a_future_release_Set_t_1219", "Experimental support for decorators is a feature that is subject to change in a future release. Set the 'experimentalDecorators' option in your 'tsconfig' or 'jsconfig' to remove this warning."), | |
| Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher: diag(1220, ts_DiagnosticCategory.Error, "Generators_are_only_available_when_targeting_ECMAScript_2015_or_higher_1220", "Generators are only available when targeting ECMAScript 2015 or higher."), | |
| Generators_are_not_allowed_in_an_ambient_context: diag(1221, ts_DiagnosticCategory.Error, "Generators_are_not_allowed_in_an_ambient_context_1221", "Generators are not allowed in an ambient context."), | |
| An_overload_signature_cannot_be_declared_as_a_generator: diag(1222, ts_DiagnosticCategory.Error, "An_overload_signature_cannot_be_declared_as_a_generator_1222", "An overload signature cannot be declared as a generator."), | |
| _0_tag_already_specified: diag(1223, ts_DiagnosticCategory.Error, "_0_tag_already_specified_1223", "'{0}' tag already specified."), | |
| Signature_0_must_be_a_type_predicate: diag(1224, ts_DiagnosticCategory.Error, "Signature_0_must_be_a_type_predicate_1224", "Signature '{0}' must be a type predicate."), | |
| Cannot_find_parameter_0: diag(1225, ts_DiagnosticCategory.Error, "Cannot_find_parameter_0_1225", "Cannot find parameter '{0}'."), | |
| Type_predicate_0_is_not_assignable_to_1: diag(1226, ts_DiagnosticCategory.Error, "Type_predicate_0_is_not_assignable_to_1_1226", "Type predicate '{0}' is not assignable to '{1}'."), | |
| Parameter_0_is_not_in_the_same_position_as_parameter_1: diag(1227, ts_DiagnosticCategory.Error, "Parameter_0_is_not_in_the_same_position_as_parameter_1_1227", "Parameter '{0}' is not in the same position as parameter '{1}'."), | |
| A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods: diag(1228, ts_DiagnosticCategory.Error, "A_type_predicate_is_only_allowed_in_return_type_position_for_functions_and_methods_1228", "A type predicate is only allowed in return type position for functions and methods."), | |
| A_type_predicate_cannot_reference_a_rest_parameter: diag(1229, ts_DiagnosticCategory.Error, "A_type_predicate_cannot_reference_a_rest_parameter_1229", "A type predicate cannot reference a rest parameter."), | |
| A_type_predicate_cannot_reference_element_0_in_a_binding_pattern: diag(1230, ts_DiagnosticCategory.Error, "A_type_predicate_cannot_reference_element_0_in_a_binding_pattern_1230", "A type predicate cannot reference element '{0}' in a binding pattern."), | |
| An_export_assignment_can_only_be_used_in_a_module: diag(1231, ts_DiagnosticCategory.Error, "An_export_assignment_can_only_be_used_in_a_module_1231", "An export assignment can only be used in a module."), | |
| An_import_declaration_can_only_be_used_in_a_namespace_or_module: diag(1232, ts_DiagnosticCategory.Error, "An_import_declaration_can_only_be_used_in_a_namespace_or_module_1232", "An import declaration can only be used in a namespace or module."), | |
| An_export_declaration_can_only_be_used_in_a_module: diag(1233, ts_DiagnosticCategory.Error, "An_export_declaration_can_only_be_used_in_a_module_1233", "An export declaration can only be used in a module."), | |
| An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file: diag(1234, ts_DiagnosticCategory.Error, "An_ambient_module_declaration_is_only_allowed_at_the_top_level_in_a_file_1234", "An ambient module declaration is only allowed at the top level in a file."), | |
| A_namespace_declaration_is_only_allowed_in_a_namespace_or_module: diag(1235, ts_DiagnosticCategory.Error, "A_namespace_declaration_is_only_allowed_in_a_namespace_or_module_1235", "A namespace declaration is only allowed in a namespace or module."), | |
| The_return_type_of_a_property_decorator_function_must_be_either_void_or_any: diag(1236, ts_DiagnosticCategory.Error, "The_return_type_of_a_property_decorator_function_must_be_either_void_or_any_1236", "The return type of a property decorator function must be either 'void' or 'any'."), | |
| The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any: diag(1237, ts_DiagnosticCategory.Error, "The_return_type_of_a_parameter_decorator_function_must_be_either_void_or_any_1237", "The return type of a parameter decorator function must be either 'void' or 'any'."), | |
| Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression: diag(1238, ts_DiagnosticCategory.Error, "Unable_to_resolve_signature_of_class_decorator_when_called_as_an_expression_1238", "Unable to resolve signature of class decorator when called as an expression."), | |
| Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression: diag(1239, ts_DiagnosticCategory.Error, "Unable_to_resolve_signature_of_parameter_decorator_when_called_as_an_expression_1239", "Unable to resolve signature of parameter decorator when called as an expression."), | |
| Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression: diag(1240, ts_DiagnosticCategory.Error, "Unable_to_resolve_signature_of_property_decorator_when_called_as_an_expression_1240", "Unable to resolve signature of property decorator when called as an expression."), | |
| Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression: diag(1241, ts_DiagnosticCategory.Error, "Unable_to_resolve_signature_of_method_decorator_when_called_as_an_expression_1241", "Unable to resolve signature of method decorator when called as an expression."), | |
| abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration: diag(1242, ts_DiagnosticCategory.Error, "abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration_1242", "'abstract' modifier can only appear on a class, method, or property declaration."), | |
| _0_modifier_cannot_be_used_with_1_modifier: diag(1243, ts_DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_1_modifier_1243", "'{0}' modifier cannot be used with '{1}' modifier."), | |
| Abstract_methods_can_only_appear_within_an_abstract_class: diag(1244, ts_DiagnosticCategory.Error, "Abstract_methods_can_only_appear_within_an_abstract_class_1244", "Abstract methods can only appear within an abstract class."), | |
| Method_0_cannot_have_an_implementation_because_it_is_marked_abstract: diag(1245, ts_DiagnosticCategory.Error, "Method_0_cannot_have_an_implementation_because_it_is_marked_abstract_1245", "Method '{0}' cannot have an implementation because it is marked abstract."), | |
| An_interface_property_cannot_have_an_initializer: diag(1246, ts_DiagnosticCategory.Error, "An_interface_property_cannot_have_an_initializer_1246", "An interface property cannot have an initializer."), | |
| A_type_literal_property_cannot_have_an_initializer: diag(1247, ts_DiagnosticCategory.Error, "A_type_literal_property_cannot_have_an_initializer_1247", "A type literal property cannot have an initializer."), | |
| A_class_member_cannot_have_the_0_keyword: diag(1248, ts_DiagnosticCategory.Error, "A_class_member_cannot_have_the_0_keyword_1248", "A class member cannot have the '{0}' keyword."), | |
| A_decorator_can_only_decorate_a_method_implementation_not_an_overload: diag(1249, ts_DiagnosticCategory.Error, "A_decorator_can_only_decorate_a_method_implementation_not_an_overload_1249", "A decorator can only decorate a method implementation, not an overload."), | |
| Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5: diag(1250, ts_DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_1250", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'."), | |
| Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode: diag(1251, ts_DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_d_1251", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Class definitions are automatically in strict mode."), | |
| Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode: diag(1252, ts_DiagnosticCategory.Error, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_1252", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Modules are automatically in strict mode."), | |
| _0_tag_cannot_be_used_independently_as_a_top_level_JSDoc_tag: diag(1253, ts_DiagnosticCategory.Error, "_0_tag_cannot_be_used_independently_as_a_top_level_JSDoc_tag_1253", "'{0}' tag cannot be used independently as a top level JSDoc tag."), | |
| A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference: diag(1254, ts_DiagnosticCategory.Error, "A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_refere_1254", "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference."), | |
| A_definite_assignment_assertion_is_not_permitted_in_this_context: diag(1255, ts_DiagnosticCategory.Error, "A_definite_assignment_assertion_is_not_permitted_in_this_context_1255", "A definite assignment assertion '!' is not permitted in this context."), | |
| A_rest_element_must_be_last_in_a_tuple_type: diag(1256, ts_DiagnosticCategory.Error, "A_rest_element_must_be_last_in_a_tuple_type_1256", "A rest element must be last in a tuple type."), | |
| A_required_element_cannot_follow_an_optional_element: diag(1257, ts_DiagnosticCategory.Error, "A_required_element_cannot_follow_an_optional_element_1257", "A required element cannot follow an optional element."), | |
| Definite_assignment_assertions_can_only_be_used_along_with_a_type_annotation: diag(1258, ts_DiagnosticCategory.Error, "Definite_assignment_assertions_can_only_be_used_along_with_a_type_annotation_1258", "Definite assignment assertions can only be used along with a type annotation."), | |
| Module_0_can_only_be_default_imported_using_the_1_flag: diag(1259, ts_DiagnosticCategory.Error, "Module_0_can_only_be_default_imported_using_the_1_flag_1259", "Module '{0}' can only be default-imported using the '{1}' flag"), | |
| Keywords_cannot_contain_escape_characters: diag(1260, ts_DiagnosticCategory.Error, "Keywords_cannot_contain_escape_characters_1260", "Keywords cannot contain escape characters."), | |
| Already_included_file_name_0_differs_from_file_name_1_only_in_casing: diag(1261, ts_DiagnosticCategory.Error, "Already_included_file_name_0_differs_from_file_name_1_only_in_casing_1261", "Already included file name '{0}' differs from file name '{1}' only in casing."), | |
| with_statements_are_not_allowed_in_an_async_function_block: diag(1300, ts_DiagnosticCategory.Error, "with_statements_are_not_allowed_in_an_async_function_block_1300", "'with' statements are not allowed in an async function block."), | |
| await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules: diag(1308, ts_DiagnosticCategory.Error, "await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules_1308", "'await' expressions are only allowed within async functions and at the top levels of modules."), | |
| can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment: diag(1312, ts_DiagnosticCategory.Error, "can_only_be_used_in_an_object_literal_property_inside_a_destructuring_assignment_1312", "'=' can only be used in an object literal property inside a destructuring assignment."), | |
| The_body_of_an_if_statement_cannot_be_the_empty_statement: diag(1313, ts_DiagnosticCategory.Error, "The_body_of_an_if_statement_cannot_be_the_empty_statement_1313", "The body of an 'if' statement cannot be the empty statement."), | |
| Global_module_exports_may_only_appear_in_module_files: diag(1314, ts_DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_module_files_1314", "Global module exports may only appear in module files."), | |
| Global_module_exports_may_only_appear_in_declaration_files: diag(1315, ts_DiagnosticCategory.Error, "Global_module_exports_may_only_appear_in_declaration_files_1315", "Global module exports may only appear in declaration files."), | |
| Global_module_exports_may_only_appear_at_top_level: diag(1316, ts_DiagnosticCategory.Error, "Global_module_exports_may_only_appear_at_top_level_1316", "Global module exports may only appear at top level."), | |
| A_parameter_property_cannot_be_declared_using_a_rest_parameter: diag(1317, ts_DiagnosticCategory.Error, "A_parameter_property_cannot_be_declared_using_a_rest_parameter_1317", "A parameter property cannot be declared using a rest parameter."), | |
| An_abstract_accessor_cannot_have_an_implementation: diag(1318, ts_DiagnosticCategory.Error, "An_abstract_accessor_cannot_have_an_implementation_1318", "An abstract accessor cannot have an implementation."), | |
| A_default_export_can_only_be_used_in_an_ECMAScript_style_module: diag(1319, ts_DiagnosticCategory.Error, "A_default_export_can_only_be_used_in_an_ECMAScript_style_module_1319", "A default export can only be used in an ECMAScript-style module."), | |
| Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1320, ts_DiagnosticCategory.Error, "Type_of_await_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member_1320", "Type of 'await' operand must either be a valid promise or must not contain a callable 'then' member."), | |
| Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1321, ts_DiagnosticCategory.Error, "Type_of_yield_operand_in_an_async_generator_must_either_be_a_valid_promise_or_must_not_contain_a_cal_1321", "Type of 'yield' operand in an async generator must either be a valid promise or must not contain a callable 'then' member."), | |
| Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member: diag(1322, ts_DiagnosticCategory.Error, "Type_of_iterated_elements_of_a_yield_Asterisk_operand_must_either_be_a_valid_promise_or_must_not_con_1322", "Type of iterated elements of a 'yield*' operand must either be a valid promise or must not contain a callable 'then' member."), | |
| Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system_or_umd: diag(1323, ts_DiagnosticCategory.Error, "Dynamic_imports_are_only_supported_when_the_module_flag_is_set_to_es2020_esnext_commonjs_amd_system__1323", "Dynamic imports are only supported when the '--module' flag is set to 'es2020', 'esnext', 'commonjs', 'amd', 'system', or 'umd'."), | |
| Dynamic_import_must_have_one_specifier_as_an_argument: diag(1324, ts_DiagnosticCategory.Error, "Dynamic_import_must_have_one_specifier_as_an_argument_1324", "Dynamic import must have one specifier as an argument."), | |
| Specifier_of_dynamic_import_cannot_be_spread_element: diag(1325, ts_DiagnosticCategory.Error, "Specifier_of_dynamic_import_cannot_be_spread_element_1325", "Specifier of dynamic import cannot be spread element."), | |
| Dynamic_import_cannot_have_type_arguments: diag(1326, ts_DiagnosticCategory.Error, "Dynamic_import_cannot_have_type_arguments_1326", "Dynamic import cannot have type arguments"), | |
| String_literal_with_double_quotes_expected: diag(1327, ts_DiagnosticCategory.Error, "String_literal_with_double_quotes_expected_1327", "String literal with double quotes expected."), | |
| Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal: diag(1328, ts_DiagnosticCategory.Error, "Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_li_1328", "Property value can only be string literal, numeric literal, 'true', 'false', 'null', object literal or array literal."), | |
| _0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write_0: diag(1329, ts_DiagnosticCategory.Error, "_0_accepts_too_few_arguments_to_be_used_as_a_decorator_here_Did_you_mean_to_call_it_first_and_write__1329", "'{0}' accepts too few arguments to be used as a decorator here. Did you mean to call it first and write '@{0}()'?"), | |
| A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly: diag(1330, ts_DiagnosticCategory.Error, "A_property_of_an_interface_or_type_literal_whose_type_is_a_unique_symbol_type_must_be_readonly_1330", "A property of an interface or type literal whose type is a 'unique symbol' type must be 'readonly'."), | |
| A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly: diag(1331, ts_DiagnosticCategory.Error, "A_property_of_a_class_whose_type_is_a_unique_symbol_type_must_be_both_static_and_readonly_1331", "A property of a class whose type is a 'unique symbol' type must be both 'static' and 'readonly'."), | |
| A_variable_whose_type_is_a_unique_symbol_type_must_be_const: diag(1332, ts_DiagnosticCategory.Error, "A_variable_whose_type_is_a_unique_symbol_type_must_be_const_1332", "A variable whose type is a 'unique symbol' type must be 'const'."), | |
| unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name: diag(1333, ts_DiagnosticCategory.Error, "unique_symbol_types_may_not_be_used_on_a_variable_declaration_with_a_binding_name_1333", "'unique symbol' types may not be used on a variable declaration with a binding name."), | |
| unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement: diag(1334, ts_DiagnosticCategory.Error, "unique_symbol_types_are_only_allowed_on_variables_in_a_variable_statement_1334", "'unique symbol' types are only allowed on variables in a variable statement."), | |
| unique_symbol_types_are_not_allowed_here: diag(1335, ts_DiagnosticCategory.Error, "unique_symbol_types_are_not_allowed_here_1335", "'unique symbol' types are not allowed here."), | |
| An_index_signature_parameter_type_cannot_be_a_type_alias_Consider_writing_0_Colon_1_Colon_2_instead: diag(1336, ts_DiagnosticCategory.Error, "An_index_signature_parameter_type_cannot_be_a_type_alias_Consider_writing_0_Colon_1_Colon_2_instead_1336", "An index signature parameter type cannot be a type alias. Consider writing '[{0}: {1}]: {2}' instead."), | |
| An_index_signature_parameter_type_cannot_be_a_union_type_Consider_using_a_mapped_object_type_instead: diag(1337, ts_DiagnosticCategory.Error, "An_index_signature_parameter_type_cannot_be_a_union_type_Consider_using_a_mapped_object_type_instead_1337", "An index signature parameter type cannot be a union type. Consider using a mapped object type instead."), | |
| infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type: diag(1338, ts_DiagnosticCategory.Error, "infer_declarations_are_only_permitted_in_the_extends_clause_of_a_conditional_type_1338", "'infer' declarations are only permitted in the 'extends' clause of a conditional type."), | |
| Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here: diag(1339, ts_DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_value_but_is_used_as_a_value_here_1339", "Module '{0}' does not refer to a value, but is used as a value here."), | |
| Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0: diag(1340, ts_DiagnosticCategory.Error, "Module_0_does_not_refer_to_a_type_but_is_used_as_a_type_here_Did_you_mean_typeof_import_0_1340", "Module '{0}' does not refer to a type, but is used as a type here. Did you mean 'typeof import('{0}')'?"), | |
| Type_arguments_cannot_be_used_here: diag(1342, ts_DiagnosticCategory.Error, "Type_arguments_cannot_be_used_here_1342", "Type arguments cannot be used here."), | |
| The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_esnext_or_system: diag(1343, ts_DiagnosticCategory.Error, "The_import_meta_meta_property_is_only_allowed_when_the_module_option_is_esnext_or_system_1343", "The 'import.meta' meta-property is only allowed when the '--module' option is 'esnext' or 'system'."), | |
| A_label_is_not_allowed_here: diag(1344, ts_DiagnosticCategory.Error, "A_label_is_not_allowed_here_1344", "'A label is not allowed here."), | |
| An_expression_of_type_void_cannot_be_tested_for_truthiness: diag(1345, ts_DiagnosticCategory.Error, "An_expression_of_type_void_cannot_be_tested_for_truthiness_1345", "An expression of type 'void' cannot be tested for truthiness"), | |
| This_parameter_is_not_allowed_with_use_strict_directive: diag(1346, ts_DiagnosticCategory.Error, "This_parameter_is_not_allowed_with_use_strict_directive_1346", "This parameter is not allowed with 'use strict' directive."), | |
| use_strict_directive_cannot_be_used_with_non_simple_parameter_list: diag(1347, ts_DiagnosticCategory.Error, "use_strict_directive_cannot_be_used_with_non_simple_parameter_list_1347", "'use strict' directive cannot be used with non-simple parameter list."), | |
| Non_simple_parameter_declared_here: diag(1348, ts_DiagnosticCategory.Error, "Non_simple_parameter_declared_here_1348", "Non-simple parameter declared here."), | |
| use_strict_directive_used_here: diag(1349, ts_DiagnosticCategory.Error, "use_strict_directive_used_here_1349", "'use strict' directive used here."), | |
| Print_the_final_configuration_instead_of_building: diag(1350, ts_DiagnosticCategory.Message, "Print_the_final_configuration_instead_of_building_1350", "Print the final configuration instead of building."), | |
| An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal: diag(1351, ts_DiagnosticCategory.Error, "An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal_1351", "An identifier or keyword cannot immediately follow a numeric literal."), | |
| A_bigint_literal_cannot_use_exponential_notation: diag(1352, ts_DiagnosticCategory.Error, "A_bigint_literal_cannot_use_exponential_notation_1352", "A bigint literal cannot use exponential notation."), | |
| A_bigint_literal_must_be_an_integer: diag(1353, ts_DiagnosticCategory.Error, "A_bigint_literal_must_be_an_integer_1353", "A bigint literal must be an integer."), | |
| readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types: diag(1354, ts_DiagnosticCategory.Error, "readonly_type_modifier_is_only_permitted_on_array_and_tuple_literal_types_1354", "'readonly' type modifier is only permitted on array and tuple literal types."), | |
| A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals: diag(1355, ts_DiagnosticCategory.Error, "A_const_assertions_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array__1355", "A 'const' assertions can only be applied to references to enum members, or string, number, boolean, array, or object literals."), | |
| Did_you_mean_to_mark_this_function_as_async: diag(1356, ts_DiagnosticCategory.Error, "Did_you_mean_to_mark_this_function_as_async_1356", "Did you mean to mark this function as 'async'?"), | |
| An_enum_member_name_must_be_followed_by_a_or: diag(1357, ts_DiagnosticCategory.Error, "An_enum_member_name_must_be_followed_by_a_or_1357", "An enum member name must be followed by a ',', '=', or '}'."), | |
| Tagged_template_expressions_are_not_permitted_in_an_optional_chain: diag(1358, ts_DiagnosticCategory.Error, "Tagged_template_expressions_are_not_permitted_in_an_optional_chain_1358", "Tagged template expressions are not permitted in an optional chain."), | |
| Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here: diag(1359, ts_DiagnosticCategory.Error, "Identifier_expected_0_is_a_reserved_word_that_cannot_be_used_here_1359", "Identifier expected. '{0}' is a reserved word that cannot be used here."), | |
| Did_you_mean_to_parenthesize_this_function_type: diag(1360, ts_DiagnosticCategory.Error, "Did_you_mean_to_parenthesize_this_function_type_1360", "Did you mean to parenthesize this function type?"), | |
| _0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type: diag(1361, ts_DiagnosticCategory.Error, "_0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type_1361", "'{0}' cannot be used as a value because it was imported using 'import type'."), | |
| _0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type: diag(1362, ts_DiagnosticCategory.Error, "_0_cannot_be_used_as_a_value_because_it_was_exported_using_export_type_1362", "'{0}' cannot be used as a value because it was exported using 'export type'."), | |
| A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both: diag(1363, ts_DiagnosticCategory.Error, "A_type_only_import_can_specify_a_default_import_or_named_bindings_but_not_both_1363", "A type-only import can specify a default import or named bindings, but not both."), | |
| Convert_to_type_only_export: diag(1364, ts_DiagnosticCategory.Message, "Convert_to_type_only_export_1364", "Convert to type-only export"), | |
| Convert_all_re_exported_types_to_type_only_exports: diag(1365, ts_DiagnosticCategory.Message, "Convert_all_re_exported_types_to_type_only_exports_1365", "Convert all re-exported types to type-only exports"), | |
| Split_into_two_separate_import_declarations: diag(1366, ts_DiagnosticCategory.Message, "Split_into_two_separate_import_declarations_1366", "Split into two separate import declarations"), | |
| Split_all_invalid_type_only_imports: diag(1367, ts_DiagnosticCategory.Message, "Split_all_invalid_type_only_imports_1367", "Split all invalid type-only imports"), | |
| Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types: diag(1368, ts_DiagnosticCategory.Message, "Specify_emit_Slashchecking_behavior_for_imports_that_are_only_used_for_types_1368", "Specify emit/checking behavior for imports that are only used for types"), | |
| Did_you_mean_0: diag(1369, ts_DiagnosticCategory.Message, "Did_you_mean_0_1369", "Did you mean '{0}'?"), | |
| Only_ECMAScript_imports_may_use_import_type: diag(1370, ts_DiagnosticCategory.Error, "Only_ECMAScript_imports_may_use_import_type_1370", "Only ECMAScript imports may use 'import type'."), | |
| This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is_set_to_error: diag(1371, ts_DiagnosticCategory.Error, "This_import_is_never_used_as_a_value_and_must_use_import_type_because_the_importsNotUsedAsValues_is__1371", "This import is never used as a value and must use 'import type' because the 'importsNotUsedAsValues' is set to 'error'."), | |
| Convert_to_type_only_import: diag(1373, ts_DiagnosticCategory.Message, "Convert_to_type_only_import_1373", "Convert to type-only import"), | |
| Convert_all_imports_not_used_as_a_value_to_type_only_imports: diag(1374, ts_DiagnosticCategory.Message, "Convert_all_imports_not_used_as_a_value_to_type_only_imports_1374", "Convert all imports not used as a value to type-only imports"), | |
| await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_file_has_no_imports_or_exports_Consider_adding_an_empty_export_to_make_this_file_a_module: diag(1375, ts_DiagnosticCategory.Error, "await_expressions_are_only_allowed_at_the_top_level_of_a_file_when_that_file_is_a_module_but_this_fi_1375", "'await' expressions are only allowed at the top level of a file when that file is a module, but this file has no imports or exports. Consider adding an empty 'export {}' to make this file a module."), | |
| _0_was_imported_here: diag(1376, ts_DiagnosticCategory.Message, "_0_was_imported_here_1376", "'{0}' was imported here."), | |
| _0_was_exported_here: diag(1377, ts_DiagnosticCategory.Message, "_0_was_exported_here_1377", "'{0}' was exported here."), | |
| Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_the_target_option_is_set_to_es2017_or_higher: diag(1378, ts_DiagnosticCategory.Error, "Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_esnext_or_system_and_t_1378", "Top-level 'await' expressions are only allowed when the 'module' option is set to 'esnext' or 'system', and the 'target' option is set to 'es2017' or higher."), | |
| An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type: diag(1379, ts_DiagnosticCategory.Error, "An_import_alias_cannot_reference_a_declaration_that_was_exported_using_export_type_1379", "An import alias cannot reference a declaration that was exported using 'export type'."), | |
| An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type: diag(1380, ts_DiagnosticCategory.Error, "An_import_alias_cannot_reference_a_declaration_that_was_imported_using_import_type_1380", "An import alias cannot reference a declaration that was imported using 'import type'."), | |
| Only_named_exports_may_use_export_type: diag(1383, ts_DiagnosticCategory.Error, "Only_named_exports_may_use_export_type_1383", "Only named exports may use 'export type'."), | |
| The_types_of_0_are_incompatible_between_these_types: diag(2200, ts_DiagnosticCategory.Error, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."), | |
| The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, ts_DiagnosticCategory.Error, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."), | |
| Call_signature_return_types_0_and_1_are_incompatible: diag(2202, ts_DiagnosticCategory.Error, "Call_signature_return_types_0_and_1_are_incompatible_2202", "Call signature return types '{0}' and '{1}' are incompatible.", undefined, true), | |
| Construct_signature_return_types_0_and_1_are_incompatible: diag(2203, ts_DiagnosticCategory.Error, "Construct_signature_return_types_0_and_1_are_incompatible_2203", "Construct signature return types '{0}' and '{1}' are incompatible.", undefined, true), | |
| Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2204, ts_DiagnosticCategory.Error, "Call_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2204", "Call signatures with no arguments have incompatible return types '{0}' and '{1}'.", undefined, true), | |
| Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1: diag(2205, ts_DiagnosticCategory.Error, "Construct_signatures_with_no_arguments_have_incompatible_return_types_0_and_1_2205", "Construct signatures with no arguments have incompatible return types '{0}' and '{1}'.", undefined, true), | |
| Duplicate_identifier_0: diag(2300, ts_DiagnosticCategory.Error, "Duplicate_identifier_0_2300", "Duplicate identifier '{0}'."), | |
| Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor: diag(2301, ts_DiagnosticCategory.Error, "Initializer_of_instance_member_variable_0_cannot_reference_identifier_1_declared_in_the_constructor_2301", "Initializer of instance member variable '{0}' cannot reference identifier '{1}' declared in the constructor."), | |
| Static_members_cannot_reference_class_type_parameters: diag(2302, ts_DiagnosticCategory.Error, "Static_members_cannot_reference_class_type_parameters_2302", "Static members cannot reference class type parameters."), | |
| Circular_definition_of_import_alias_0: diag(2303, ts_DiagnosticCategory.Error, "Circular_definition_of_import_alias_0_2303", "Circular definition of import alias '{0}'."), | |
| Cannot_find_name_0: diag(2304, ts_DiagnosticCategory.Error, "Cannot_find_name_0_2304", "Cannot find name '{0}'."), | |
| Module_0_has_no_exported_member_1: diag(2305, ts_DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_2305", "Module '{0}' has no exported member '{1}'."), | |
| File_0_is_not_a_module: diag(2306, ts_DiagnosticCategory.Error, "File_0_is_not_a_module_2306", "File '{0}' is not a module."), | |
| Cannot_find_module_0: diag(2307, ts_DiagnosticCategory.Error, "Cannot_find_module_0_2307", "Cannot find module '{0}'."), | |
| Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambiguity: diag(2308, ts_DiagnosticCategory.Error, "Module_0_has_already_exported_a_member_named_1_Consider_explicitly_re_exporting_to_resolve_the_ambig_2308", "Module {0} has already exported a member named '{1}'. Consider explicitly re-exporting to resolve the ambiguity."), | |
| An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements: diag(2309, ts_DiagnosticCategory.Error, "An_export_assignment_cannot_be_used_in_a_module_with_other_exported_elements_2309", "An export assignment cannot be used in a module with other exported elements."), | |
| Type_0_recursively_references_itself_as_a_base_type: diag(2310, ts_DiagnosticCategory.Error, "Type_0_recursively_references_itself_as_a_base_type_2310", "Type '{0}' recursively references itself as a base type."), | |
| A_class_may_only_extend_another_class: diag(2311, ts_DiagnosticCategory.Error, "A_class_may_only_extend_another_class_2311", "A class may only extend another class."), | |
| An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2312, ts_DiagnosticCategory.Error, "An_interface_can_only_extend_an_object_type_or_intersection_of_object_types_with_statically_known_me_2312", "An interface can only extend an object type or intersection of object types with statically known members."), | |
| Type_parameter_0_has_a_circular_constraint: diag(2313, ts_DiagnosticCategory.Error, "Type_parameter_0_has_a_circular_constraint_2313", "Type parameter '{0}' has a circular constraint."), | |
| Generic_type_0_requires_1_type_argument_s: diag(2314, ts_DiagnosticCategory.Error, "Generic_type_0_requires_1_type_argument_s_2314", "Generic type '{0}' requires {1} type argument(s)."), | |
| Type_0_is_not_generic: diag(2315, ts_DiagnosticCategory.Error, "Type_0_is_not_generic_2315", "Type '{0}' is not generic."), | |
| Global_type_0_must_be_a_class_or_interface_type: diag(2316, ts_DiagnosticCategory.Error, "Global_type_0_must_be_a_class_or_interface_type_2316", "Global type '{0}' must be a class or interface type."), | |
| Global_type_0_must_have_1_type_parameter_s: diag(2317, ts_DiagnosticCategory.Error, "Global_type_0_must_have_1_type_parameter_s_2317", "Global type '{0}' must have {1} type parameter(s)."), | |
| Cannot_find_global_type_0: diag(2318, ts_DiagnosticCategory.Error, "Cannot_find_global_type_0_2318", "Cannot find global type '{0}'."), | |
| Named_property_0_of_types_1_and_2_are_not_identical: diag(2319, ts_DiagnosticCategory.Error, "Named_property_0_of_types_1_and_2_are_not_identical_2319", "Named property '{0}' of types '{1}' and '{2}' are not identical."), | |
| Interface_0_cannot_simultaneously_extend_types_1_and_2: diag(2320, ts_DiagnosticCategory.Error, "Interface_0_cannot_simultaneously_extend_types_1_and_2_2320", "Interface '{0}' cannot simultaneously extend types '{1}' and '{2}'."), | |
| Excessive_stack_depth_comparing_types_0_and_1: diag(2321, ts_DiagnosticCategory.Error, "Excessive_stack_depth_comparing_types_0_and_1_2321", "Excessive stack depth comparing types '{0}' and '{1}'."), | |
| Type_0_is_not_assignable_to_type_1: diag(2322, ts_DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_2322", "Type '{0}' is not assignable to type '{1}'."), | |
| Cannot_redeclare_exported_variable_0: diag(2323, ts_DiagnosticCategory.Error, "Cannot_redeclare_exported_variable_0_2323", "Cannot redeclare exported variable '{0}'."), | |
| Property_0_is_missing_in_type_1: diag(2324, ts_DiagnosticCategory.Error, "Property_0_is_missing_in_type_1_2324", "Property '{0}' is missing in type '{1}'."), | |
| Property_0_is_private_in_type_1_but_not_in_type_2: diag(2325, ts_DiagnosticCategory.Error, "Property_0_is_private_in_type_1_but_not_in_type_2_2325", "Property '{0}' is private in type '{1}' but not in type '{2}'."), | |
| Types_of_property_0_are_incompatible: diag(2326, ts_DiagnosticCategory.Error, "Types_of_property_0_are_incompatible_2326", "Types of property '{0}' are incompatible."), | |
| Property_0_is_optional_in_type_1_but_required_in_type_2: diag(2327, ts_DiagnosticCategory.Error, "Property_0_is_optional_in_type_1_but_required_in_type_2_2327", "Property '{0}' is optional in type '{1}' but required in type '{2}'."), | |
| Types_of_parameters_0_and_1_are_incompatible: diag(2328, ts_DiagnosticCategory.Error, "Types_of_parameters_0_and_1_are_incompatible_2328", "Types of parameters '{0}' and '{1}' are incompatible."), | |
| Index_signature_is_missing_in_type_0: diag(2329, ts_DiagnosticCategory.Error, "Index_signature_is_missing_in_type_0_2329", "Index signature is missing in type '{0}'."), | |
| Index_signatures_are_incompatible: diag(2330, ts_DiagnosticCategory.Error, "Index_signatures_are_incompatible_2330", "Index signatures are incompatible."), | |
| this_cannot_be_referenced_in_a_module_or_namespace_body: diag(2331, ts_DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_module_or_namespace_body_2331", "'this' cannot be referenced in a module or namespace body."), | |
| this_cannot_be_referenced_in_current_location: diag(2332, ts_DiagnosticCategory.Error, "this_cannot_be_referenced_in_current_location_2332", "'this' cannot be referenced in current location."), | |
| this_cannot_be_referenced_in_constructor_arguments: diag(2333, ts_DiagnosticCategory.Error, "this_cannot_be_referenced_in_constructor_arguments_2333", "'this' cannot be referenced in constructor arguments."), | |
| this_cannot_be_referenced_in_a_static_property_initializer: diag(2334, ts_DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_static_property_initializer_2334", "'this' cannot be referenced in a static property initializer."), | |
| super_can_only_be_referenced_in_a_derived_class: diag(2335, ts_DiagnosticCategory.Error, "super_can_only_be_referenced_in_a_derived_class_2335", "'super' can only be referenced in a derived class."), | |
| super_cannot_be_referenced_in_constructor_arguments: diag(2336, ts_DiagnosticCategory.Error, "super_cannot_be_referenced_in_constructor_arguments_2336", "'super' cannot be referenced in constructor arguments."), | |
| Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors: diag(2337, ts_DiagnosticCategory.Error, "Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors_2337", "Super calls are not permitted outside constructors or in nested functions inside constructors."), | |
| super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class: diag(2338, ts_DiagnosticCategory.Error, "super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_der_2338", "'super' property access is permitted only in a constructor, member function, or member accessor of a derived class."), | |
| Property_0_does_not_exist_on_type_1: diag(2339, ts_DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_2339", "Property '{0}' does not exist on type '{1}'."), | |
| Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword: diag(2340, ts_DiagnosticCategory.Error, "Only_public_and_protected_methods_of_the_base_class_are_accessible_via_the_super_keyword_2340", "Only public and protected methods of the base class are accessible via the 'super' keyword."), | |
| Property_0_is_private_and_only_accessible_within_class_1: diag(2341, ts_DiagnosticCategory.Error, "Property_0_is_private_and_only_accessible_within_class_1_2341", "Property '{0}' is private and only accessible within class '{1}'."), | |
| An_index_expression_argument_must_be_of_type_string_number_symbol_or_any: diag(2342, ts_DiagnosticCategory.Error, "An_index_expression_argument_must_be_of_type_string_number_symbol_or_any_2342", "An index expression argument must be of type 'string', 'number', 'symbol', or 'any'."), | |
| This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_version_of_0: diag(2343, ts_DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_named_1_which_does_not_exist_in_0_Consider_upgrading_your_ve_2343", "This syntax requires an imported helper named '{1}' which does not exist in '{0}'. Consider upgrading your version of '{0}'."), | |
| Type_0_does_not_satisfy_the_constraint_1: diag(2344, ts_DiagnosticCategory.Error, "Type_0_does_not_satisfy_the_constraint_1_2344", "Type '{0}' does not satisfy the constraint '{1}'."), | |
| Argument_of_type_0_is_not_assignable_to_parameter_of_type_1: diag(2345, ts_DiagnosticCategory.Error, "Argument_of_type_0_is_not_assignable_to_parameter_of_type_1_2345", "Argument of type '{0}' is not assignable to parameter of type '{1}'."), | |
| Call_target_does_not_contain_any_signatures: diag(2346, ts_DiagnosticCategory.Error, "Call_target_does_not_contain_any_signatures_2346", "Call target does not contain any signatures."), | |
| Untyped_function_calls_may_not_accept_type_arguments: diag(2347, ts_DiagnosticCategory.Error, "Untyped_function_calls_may_not_accept_type_arguments_2347", "Untyped function calls may not accept type arguments."), | |
| Value_of_type_0_is_not_callable_Did_you_mean_to_include_new: diag(2348, ts_DiagnosticCategory.Error, "Value_of_type_0_is_not_callable_Did_you_mean_to_include_new_2348", "Value of type '{0}' is not callable. Did you mean to include 'new'?"), | |
| This_expression_is_not_callable: diag(2349, ts_DiagnosticCategory.Error, "This_expression_is_not_callable_2349", "This expression is not callable."), | |
| Only_a_void_function_can_be_called_with_the_new_keyword: diag(2350, ts_DiagnosticCategory.Error, "Only_a_void_function_can_be_called_with_the_new_keyword_2350", "Only a void function can be called with the 'new' keyword."), | |
| This_expression_is_not_constructable: diag(2351, ts_DiagnosticCategory.Error, "This_expression_is_not_constructable_2351", "This expression is not constructable."), | |
| Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first: diag(2352, ts_DiagnosticCategory.Error, "Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the__2352", "Conversion of type '{0}' to type '{1}' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first."), | |
| Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1: diag(2353, ts_DiagnosticCategory.Error, "Object_literal_may_only_specify_known_properties_and_0_does_not_exist_in_type_1_2353", "Object literal may only specify known properties, and '{0}' does not exist in type '{1}'."), | |
| This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found: diag(2354, ts_DiagnosticCategory.Error, "This_syntax_requires_an_imported_helper_but_module_0_cannot_be_found_2354", "This syntax requires an imported helper but module '{0}' cannot be found."), | |
| A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value: diag(2355, ts_DiagnosticCategory.Error, "A_function_whose_declared_type_is_neither_void_nor_any_must_return_a_value_2355", "A function whose declared type is neither 'void' nor 'any' must return a value."), | |
| An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2356, ts_DiagnosticCategory.Error, "An_arithmetic_operand_must_be_of_type_any_number_bigint_or_an_enum_type_2356", "An arithmetic operand must be of type 'any', 'number', 'bigint' or an enum type."), | |
| The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access: diag(2357, ts_DiagnosticCategory.Error, "The_operand_of_an_increment_or_decrement_operator_must_be_a_variable_or_a_property_access_2357", "The operand of an increment or decrement operator must be a variable or a property access."), | |
| The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2358, ts_DiagnosticCategory.Error, "The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_paramete_2358", "The left-hand side of an 'instanceof' expression must be of type 'any', an object type or a type parameter."), | |
| The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type: diag(2359, ts_DiagnosticCategory.Error, "The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_F_2359", "The right-hand side of an 'instanceof' expression must be of type 'any' or of a type assignable to the 'Function' interface type."), | |
| The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol: diag(2360, ts_DiagnosticCategory.Error, "The_left_hand_side_of_an_in_expression_must_be_of_type_any_string_number_or_symbol_2360", "The left-hand side of an 'in' expression must be of type 'any', 'string', 'number', or 'symbol'."), | |
| The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter: diag(2361, ts_DiagnosticCategory.Error, "The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter_2361", "The right-hand side of an 'in' expression must be of type 'any', an object type or a type parameter."), | |
| The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2362, ts_DiagnosticCategory.Error, "The_left_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2362", "The left-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."), | |
| The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type: diag(2363, ts_DiagnosticCategory.Error, "The_right_hand_side_of_an_arithmetic_operation_must_be_of_type_any_number_bigint_or_an_enum_type_2363", "The right-hand side of an arithmetic operation must be of type 'any', 'number', 'bigint' or an enum type."), | |
| The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access: diag(2364, ts_DiagnosticCategory.Error, "The_left_hand_side_of_an_assignment_expression_must_be_a_variable_or_a_property_access_2364", "The left-hand side of an assignment expression must be a variable or a property access."), | |
| Operator_0_cannot_be_applied_to_types_1_and_2: diag(2365, ts_DiagnosticCategory.Error, "Operator_0_cannot_be_applied_to_types_1_and_2_2365", "Operator '{0}' cannot be applied to types '{1}' and '{2}'."), | |
| Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined: diag(2366, ts_DiagnosticCategory.Error, "Function_lacks_ending_return_statement_and_return_type_does_not_include_undefined_2366", "Function lacks ending return statement and return type does not include 'undefined'."), | |
| This_condition_will_always_return_0_since_the_types_1_and_2_have_no_overlap: diag(2367, ts_DiagnosticCategory.Error, "This_condition_will_always_return_0_since_the_types_1_and_2_have_no_overlap_2367", "This condition will always return '{0}' since the types '{1}' and '{2}' have no overlap."), | |
| Type_parameter_name_cannot_be_0: diag(2368, ts_DiagnosticCategory.Error, "Type_parameter_name_cannot_be_0_2368", "Type parameter name cannot be '{0}'."), | |
| A_parameter_property_is_only_allowed_in_a_constructor_implementation: diag(2369, ts_DiagnosticCategory.Error, "A_parameter_property_is_only_allowed_in_a_constructor_implementation_2369", "A parameter property is only allowed in a constructor implementation."), | |
| A_rest_parameter_must_be_of_an_array_type: diag(2370, ts_DiagnosticCategory.Error, "A_rest_parameter_must_be_of_an_array_type_2370", "A rest parameter must be of an array type."), | |
| A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation: diag(2371, ts_DiagnosticCategory.Error, "A_parameter_initializer_is_only_allowed_in_a_function_or_constructor_implementation_2371", "A parameter initializer is only allowed in a function or constructor implementation."), | |
| Parameter_0_cannot_be_referenced_in_its_initializer: diag(2372, ts_DiagnosticCategory.Error, "Parameter_0_cannot_be_referenced_in_its_initializer_2372", "Parameter '{0}' cannot be referenced in its initializer."), | |
| Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it: diag(2373, ts_DiagnosticCategory.Error, "Initializer_of_parameter_0_cannot_reference_identifier_1_declared_after_it_2373", "Initializer of parameter '{0}' cannot reference identifier '{1}' declared after it."), | |
| Duplicate_string_index_signature: diag(2374, ts_DiagnosticCategory.Error, "Duplicate_string_index_signature_2374", "Duplicate string index signature."), | |
| Duplicate_number_index_signature: diag(2375, ts_DiagnosticCategory.Error, "Duplicate_number_index_signature_2375", "Duplicate number index signature."), | |
| A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_properties_parameter_properties_or_private_identifiers: diag(2376, ts_DiagnosticCategory.Error, "A_super_call_must_be_the_first_statement_in_the_constructor_when_a_class_contains_initialized_proper_2376", "A 'super' call must be the first statement in the constructor when a class contains initialized properties, parameter properties, or private identifiers."), | |
| Constructors_for_derived_classes_must_contain_a_super_call: diag(2377, ts_DiagnosticCategory.Error, "Constructors_for_derived_classes_must_contain_a_super_call_2377", "Constructors for derived classes must contain a 'super' call."), | |
| A_get_accessor_must_return_a_value: diag(2378, ts_DiagnosticCategory.Error, "A_get_accessor_must_return_a_value_2378", "A 'get' accessor must return a value."), | |
| Getter_and_setter_accessors_do_not_agree_in_visibility: diag(2379, ts_DiagnosticCategory.Error, "Getter_and_setter_accessors_do_not_agree_in_visibility_2379", "Getter and setter accessors do not agree in visibility."), | |
| get_and_set_accessor_must_have_the_same_type: diag(2380, ts_DiagnosticCategory.Error, "get_and_set_accessor_must_have_the_same_type_2380", "'get' and 'set' accessor must have the same type."), | |
| A_signature_with_an_implementation_cannot_use_a_string_literal_type: diag(2381, ts_DiagnosticCategory.Error, "A_signature_with_an_implementation_cannot_use_a_string_literal_type_2381", "A signature with an implementation cannot use a string literal type."), | |
| Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature: diag(2382, ts_DiagnosticCategory.Error, "Specialized_overload_signature_is_not_assignable_to_any_non_specialized_signature_2382", "Specialized overload signature is not assignable to any non-specialized signature."), | |
| Overload_signatures_must_all_be_exported_or_non_exported: diag(2383, ts_DiagnosticCategory.Error, "Overload_signatures_must_all_be_exported_or_non_exported_2383", "Overload signatures must all be exported or non-exported."), | |
| Overload_signatures_must_all_be_ambient_or_non_ambient: diag(2384, ts_DiagnosticCategory.Error, "Overload_signatures_must_all_be_ambient_or_non_ambient_2384", "Overload signatures must all be ambient or non-ambient."), | |
| Overload_signatures_must_all_be_public_private_or_protected: diag(2385, ts_DiagnosticCategory.Error, "Overload_signatures_must_all_be_public_private_or_protected_2385", "Overload signatures must all be public, private or protected."), | |
| Overload_signatures_must_all_be_optional_or_required: diag(2386, ts_DiagnosticCategory.Error, "Overload_signatures_must_all_be_optional_or_required_2386", "Overload signatures must all be optional or required."), | |
| Function_overload_must_be_static: diag(2387, ts_DiagnosticCategory.Error, "Function_overload_must_be_static_2387", "Function overload must be static."), | |
| Function_overload_must_not_be_static: diag(2388, ts_DiagnosticCategory.Error, "Function_overload_must_not_be_static_2388", "Function overload must not be static."), | |
| Function_implementation_name_must_be_0: diag(2389, ts_DiagnosticCategory.Error, "Function_implementation_name_must_be_0_2389", "Function implementation name must be '{0}'."), | |
| Constructor_implementation_is_missing: diag(2390, ts_DiagnosticCategory.Error, "Constructor_implementation_is_missing_2390", "Constructor implementation is missing."), | |
| Function_implementation_is_missing_or_not_immediately_following_the_declaration: diag(2391, ts_DiagnosticCategory.Error, "Function_implementation_is_missing_or_not_immediately_following_the_declaration_2391", "Function implementation is missing or not immediately following the declaration."), | |
| Multiple_constructor_implementations_are_not_allowed: diag(2392, ts_DiagnosticCategory.Error, "Multiple_constructor_implementations_are_not_allowed_2392", "Multiple constructor implementations are not allowed."), | |
| Duplicate_function_implementation: diag(2393, ts_DiagnosticCategory.Error, "Duplicate_function_implementation_2393", "Duplicate function implementation."), | |
| This_overload_signature_is_not_compatible_with_its_implementation_signature: diag(2394, ts_DiagnosticCategory.Error, "This_overload_signature_is_not_compatible_with_its_implementation_signature_2394", "This overload signature is not compatible with its implementation signature."), | |
| Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local: diag(2395, ts_DiagnosticCategory.Error, "Individual_declarations_in_merged_declaration_0_must_be_all_exported_or_all_local_2395", "Individual declarations in merged declaration '{0}' must be all exported or all local."), | |
| Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters: diag(2396, ts_DiagnosticCategory.Error, "Duplicate_identifier_arguments_Compiler_uses_arguments_to_initialize_rest_parameters_2396", "Duplicate identifier 'arguments'. Compiler uses 'arguments' to initialize rest parameters."), | |
| Declaration_name_conflicts_with_built_in_global_identifier_0: diag(2397, ts_DiagnosticCategory.Error, "Declaration_name_conflicts_with_built_in_global_identifier_0_2397", "Declaration name conflicts with built-in global identifier '{0}'."), | |
| Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference: diag(2399, ts_DiagnosticCategory.Error, "Duplicate_identifier_this_Compiler_uses_variable_declaration_this_to_capture_this_reference_2399", "Duplicate identifier '_this'. Compiler uses variable declaration '_this' to capture 'this' reference."), | |
| Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference: diag(2400, ts_DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_this_that_compiler_uses_to_capture_this_reference_2400", "Expression resolves to variable declaration '_this' that compiler uses to capture 'this' reference."), | |
| Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference: diag(2401, ts_DiagnosticCategory.Error, "Duplicate_identifier_super_Compiler_uses_super_to_capture_base_class_reference_2401", "Duplicate identifier '_super'. Compiler uses '_super' to capture base class reference."), | |
| Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference: diag(2402, ts_DiagnosticCategory.Error, "Expression_resolves_to_super_that_compiler_uses_to_capture_base_class_reference_2402", "Expression resolves to '_super' that compiler uses to capture base class reference."), | |
| Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_type_2: diag(2403, ts_DiagnosticCategory.Error, "Subsequent_variable_declarations_must_have_the_same_type_Variable_0_must_be_of_type_1_but_here_has_t_2403", "Subsequent variable declarations must have the same type. Variable '{0}' must be of type '{1}', but here has type '{2}'."), | |
| The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation: diag(2404, ts_DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_cannot_use_a_type_annotation_2404", "The left-hand side of a 'for...in' statement cannot use a type annotation."), | |
| The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any: diag(2405, ts_DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any_2405", "The left-hand side of a 'for...in' statement must be of type 'string' or 'any'."), | |
| The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access: diag(2406, ts_DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access_2406", "The left-hand side of a 'for...in' statement must be a variable or a property access."), | |
| The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0: diag(2407, ts_DiagnosticCategory.Error, "The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_2407", "The right-hand side of a 'for...in' statement must be of type 'any', an object type or a type parameter, but here has type '{0}'."), | |
| Setters_cannot_return_a_value: diag(2408, ts_DiagnosticCategory.Error, "Setters_cannot_return_a_value_2408", "Setters cannot return a value."), | |
| Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class: diag(2409, ts_DiagnosticCategory.Error, "Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class_2409", "Return type of constructor signature must be assignable to the instance type of the class."), | |
| The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any: diag(2410, ts_DiagnosticCategory.Error, "The_with_statement_is_not_supported_All_symbols_in_a_with_block_will_have_type_any_2410", "The 'with' statement is not supported. All symbols in a 'with' block will have type 'any'."), | |
| Property_0_of_type_1_is_not_assignable_to_string_index_type_2: diag(2411, ts_DiagnosticCategory.Error, "Property_0_of_type_1_is_not_assignable_to_string_index_type_2_2411", "Property '{0}' of type '{1}' is not assignable to string index type '{2}'."), | |
| Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2: diag(2412, ts_DiagnosticCategory.Error, "Property_0_of_type_1_is_not_assignable_to_numeric_index_type_2_2412", "Property '{0}' of type '{1}' is not assignable to numeric index type '{2}'."), | |
| Numeric_index_type_0_is_not_assignable_to_string_index_type_1: diag(2413, ts_DiagnosticCategory.Error, "Numeric_index_type_0_is_not_assignable_to_string_index_type_1_2413", "Numeric index type '{0}' is not assignable to string index type '{1}'."), | |
| Class_name_cannot_be_0: diag(2414, ts_DiagnosticCategory.Error, "Class_name_cannot_be_0_2414", "Class name cannot be '{0}'."), | |
| Class_0_incorrectly_extends_base_class_1: diag(2415, ts_DiagnosticCategory.Error, "Class_0_incorrectly_extends_base_class_1_2415", "Class '{0}' incorrectly extends base class '{1}'."), | |
| Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2: diag(2416, ts_DiagnosticCategory.Error, "Property_0_in_type_1_is_not_assignable_to_the_same_property_in_base_type_2_2416", "Property '{0}' in type '{1}' is not assignable to the same property in base type '{2}'."), | |
| Class_static_side_0_incorrectly_extends_base_class_static_side_1: diag(2417, ts_DiagnosticCategory.Error, "Class_static_side_0_incorrectly_extends_base_class_static_side_1_2417", "Class static side '{0}' incorrectly extends base class static side '{1}'."), | |
| Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1: diag(2418, ts_DiagnosticCategory.Error, "Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1_2418", "Type of computed property's value is '{0}', which is not assignable to type '{1}'."), | |
| Class_0_incorrectly_implements_interface_1: diag(2420, ts_DiagnosticCategory.Error, "Class_0_incorrectly_implements_interface_1_2420", "Class '{0}' incorrectly implements interface '{1}'."), | |
| A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2422, ts_DiagnosticCategory.Error, "A_class_can_only_implement_an_object_type_or_intersection_of_object_types_with_statically_known_memb_2422", "A class can only implement an object type or intersection of object types with statically known members."), | |
| Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_accessor: diag(2423, ts_DiagnosticCategory.Error, "Class_0_defines_instance_member_function_1_but_extended_class_2_defines_it_as_instance_member_access_2423", "Class '{0}' defines instance member function '{1}', but extended class '{2}' defines it as instance member accessor."), | |
| Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_function: diag(2425, ts_DiagnosticCategory.Error, "Class_0_defines_instance_member_property_1_but_extended_class_2_defines_it_as_instance_member_functi_2425", "Class '{0}' defines instance member property '{1}', but extended class '{2}' defines it as instance member function."), | |
| Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_function: diag(2426, ts_DiagnosticCategory.Error, "Class_0_defines_instance_member_accessor_1_but_extended_class_2_defines_it_as_instance_member_functi_2426", "Class '{0}' defines instance member accessor '{1}', but extended class '{2}' defines it as instance member function."), | |
| Interface_name_cannot_be_0: diag(2427, ts_DiagnosticCategory.Error, "Interface_name_cannot_be_0_2427", "Interface name cannot be '{0}'."), | |
| All_declarations_of_0_must_have_identical_type_parameters: diag(2428, ts_DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_type_parameters_2428", "All declarations of '{0}' must have identical type parameters."), | |
| Interface_0_incorrectly_extends_interface_1: diag(2430, ts_DiagnosticCategory.Error, "Interface_0_incorrectly_extends_interface_1_2430", "Interface '{0}' incorrectly extends interface '{1}'."), | |
| Enum_name_cannot_be_0: diag(2431, ts_DiagnosticCategory.Error, "Enum_name_cannot_be_0_2431", "Enum name cannot be '{0}'."), | |
| In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enum_element: diag(2432, ts_DiagnosticCategory.Error, "In_an_enum_with_multiple_declarations_only_one_declaration_can_omit_an_initializer_for_its_first_enu_2432", "In an enum with multiple declarations, only one declaration can omit an initializer for its first enum element."), | |
| A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merged: diag(2433, ts_DiagnosticCategory.Error, "A_namespace_declaration_cannot_be_in_a_different_file_from_a_class_or_function_with_which_it_is_merg_2433", "A namespace declaration cannot be in a different file from a class or function with which it is merged."), | |
| A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged: diag(2434, ts_DiagnosticCategory.Error, "A_namespace_declaration_cannot_be_located_prior_to_a_class_or_function_with_which_it_is_merged_2434", "A namespace declaration cannot be located prior to a class or function with which it is merged."), | |
| Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces: diag(2435, ts_DiagnosticCategory.Error, "Ambient_modules_cannot_be_nested_in_other_modules_or_namespaces_2435", "Ambient modules cannot be nested in other modules or namespaces."), | |
| Ambient_module_declaration_cannot_specify_relative_module_name: diag(2436, ts_DiagnosticCategory.Error, "Ambient_module_declaration_cannot_specify_relative_module_name_2436", "Ambient module declaration cannot specify relative module name."), | |
| Module_0_is_hidden_by_a_local_declaration_with_the_same_name: diag(2437, ts_DiagnosticCategory.Error, "Module_0_is_hidden_by_a_local_declaration_with_the_same_name_2437", "Module '{0}' is hidden by a local declaration with the same name."), | |
| Import_name_cannot_be_0: diag(2438, ts_DiagnosticCategory.Error, "Import_name_cannot_be_0_2438", "Import name cannot be '{0}'."), | |
| Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relative_module_name: diag(2439, ts_DiagnosticCategory.Error, "Import_or_export_declaration_in_an_ambient_module_declaration_cannot_reference_module_through_relati_2439", "Import or export declaration in an ambient module declaration cannot reference module through relative module name."), | |
| Import_declaration_conflicts_with_local_declaration_of_0: diag(2440, ts_DiagnosticCategory.Error, "Import_declaration_conflicts_with_local_declaration_of_0_2440", "Import declaration conflicts with local declaration of '{0}'."), | |
| Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module: diag(2441, ts_DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_2441", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module."), | |
| Types_have_separate_declarations_of_a_private_property_0: diag(2442, ts_DiagnosticCategory.Error, "Types_have_separate_declarations_of_a_private_property_0_2442", "Types have separate declarations of a private property '{0}'."), | |
| Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2: diag(2443, ts_DiagnosticCategory.Error, "Property_0_is_protected_but_type_1_is_not_a_class_derived_from_2_2443", "Property '{0}' is protected but type '{1}' is not a class derived from '{2}'."), | |
| Property_0_is_protected_in_type_1_but_public_in_type_2: diag(2444, ts_DiagnosticCategory.Error, "Property_0_is_protected_in_type_1_but_public_in_type_2_2444", "Property '{0}' is protected in type '{1}' but public in type '{2}'."), | |
| Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses: diag(2445, ts_DiagnosticCategory.Error, "Property_0_is_protected_and_only_accessible_within_class_1_and_its_subclasses_2445", "Property '{0}' is protected and only accessible within class '{1}' and its subclasses."), | |
| Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1: diag(2446, ts_DiagnosticCategory.Error, "Property_0_is_protected_and_only_accessible_through_an_instance_of_class_1_2446", "Property '{0}' is protected and only accessible through an instance of class '{1}'."), | |
| The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead: diag(2447, ts_DiagnosticCategory.Error, "The_0_operator_is_not_allowed_for_boolean_types_Consider_using_1_instead_2447", "The '{0}' operator is not allowed for boolean types. Consider using '{1}' instead."), | |
| Block_scoped_variable_0_used_before_its_declaration: diag(2448, ts_DiagnosticCategory.Error, "Block_scoped_variable_0_used_before_its_declaration_2448", "Block-scoped variable '{0}' used before its declaration."), | |
| Class_0_used_before_its_declaration: diag(2449, ts_DiagnosticCategory.Error, "Class_0_used_before_its_declaration_2449", "Class '{0}' used before its declaration."), | |
| Enum_0_used_before_its_declaration: diag(2450, ts_DiagnosticCategory.Error, "Enum_0_used_before_its_declaration_2450", "Enum '{0}' used before its declaration."), | |
| Cannot_redeclare_block_scoped_variable_0: diag(2451, ts_DiagnosticCategory.Error, "Cannot_redeclare_block_scoped_variable_0_2451", "Cannot redeclare block-scoped variable '{0}'."), | |
| An_enum_member_cannot_have_a_numeric_name: diag(2452, ts_DiagnosticCategory.Error, "An_enum_member_cannot_have_a_numeric_name_2452", "An enum member cannot have a numeric name."), | |
| The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_type_arguments_explicitly: diag(2453, ts_DiagnosticCategory.Error, "The_type_argument_for_type_parameter_0_cannot_be_inferred_from_the_usage_Consider_specifying_the_typ_2453", "The type argument for type parameter '{0}' cannot be inferred from the usage. Consider specifying the type arguments explicitly."), | |
| Variable_0_is_used_before_being_assigned: diag(2454, ts_DiagnosticCategory.Error, "Variable_0_is_used_before_being_assigned_2454", "Variable '{0}' is used before being assigned."), | |
| Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0: diag(2455, ts_DiagnosticCategory.Error, "Type_argument_candidate_1_is_not_a_valid_type_argument_because_it_is_not_a_supertype_of_candidate_0_2455", "Type argument candidate '{1}' is not a valid type argument because it is not a supertype of candidate '{0}'."), | |
| Type_alias_0_circularly_references_itself: diag(2456, ts_DiagnosticCategory.Error, "Type_alias_0_circularly_references_itself_2456", "Type alias '{0}' circularly references itself."), | |
| Type_alias_name_cannot_be_0: diag(2457, ts_DiagnosticCategory.Error, "Type_alias_name_cannot_be_0_2457", "Type alias name cannot be '{0}'."), | |
| An_AMD_module_cannot_have_multiple_name_assignments: diag(2458, ts_DiagnosticCategory.Error, "An_AMD_module_cannot_have_multiple_name_assignments_2458", "An AMD module cannot have multiple name assignments."), | |
| Module_0_declares_1_locally_but_it_is_not_exported: diag(2459, ts_DiagnosticCategory.Error, "Module_0_declares_1_locally_but_it_is_not_exported_2459", "Module '{0}' declares '{1}' locally, but it is not exported."), | |
| Module_0_declares_1_locally_but_it_is_exported_as_2: diag(2460, ts_DiagnosticCategory.Error, "Module_0_declares_1_locally_but_it_is_exported_as_2_2460", "Module '{0}' declares '{1}' locally, but it is exported as '{2}'."), | |
| Type_0_is_not_an_array_type: diag(2461, ts_DiagnosticCategory.Error, "Type_0_is_not_an_array_type_2461", "Type '{0}' is not an array type."), | |
| A_rest_element_must_be_last_in_a_destructuring_pattern: diag(2462, ts_DiagnosticCategory.Error, "A_rest_element_must_be_last_in_a_destructuring_pattern_2462", "A rest element must be last in a destructuring pattern."), | |
| A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature: diag(2463, ts_DiagnosticCategory.Error, "A_binding_pattern_parameter_cannot_be_optional_in_an_implementation_signature_2463", "A binding pattern parameter cannot be optional in an implementation signature."), | |
| A_computed_property_name_must_be_of_type_string_number_symbol_or_any: diag(2464, ts_DiagnosticCategory.Error, "A_computed_property_name_must_be_of_type_string_number_symbol_or_any_2464", "A computed property name must be of type 'string', 'number', 'symbol', or 'any'."), | |
| this_cannot_be_referenced_in_a_computed_property_name: diag(2465, ts_DiagnosticCategory.Error, "this_cannot_be_referenced_in_a_computed_property_name_2465", "'this' cannot be referenced in a computed property name."), | |
| super_cannot_be_referenced_in_a_computed_property_name: diag(2466, ts_DiagnosticCategory.Error, "super_cannot_be_referenced_in_a_computed_property_name_2466", "'super' cannot be referenced in a computed property name."), | |
| A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type: diag(2467, ts_DiagnosticCategory.Error, "A_computed_property_name_cannot_reference_a_type_parameter_from_its_containing_type_2467", "A computed property name cannot reference a type parameter from its containing type."), | |
| Cannot_find_global_value_0: diag(2468, ts_DiagnosticCategory.Error, "Cannot_find_global_value_0_2468", "Cannot find global value '{0}'."), | |
| The_0_operator_cannot_be_applied_to_type_symbol: diag(2469, ts_DiagnosticCategory.Error, "The_0_operator_cannot_be_applied_to_type_symbol_2469", "The '{0}' operator cannot be applied to type 'symbol'."), | |
| Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object: diag(2470, ts_DiagnosticCategory.Error, "Symbol_reference_does_not_refer_to_the_global_Symbol_constructor_object_2470", "'Symbol' reference does not refer to the global Symbol constructor object."), | |
| A_computed_property_name_of_the_form_0_must_be_of_type_symbol: diag(2471, ts_DiagnosticCategory.Error, "A_computed_property_name_of_the_form_0_must_be_of_type_symbol_2471", "A computed property name of the form '{0}' must be of type 'symbol'."), | |
| Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher: diag(2472, ts_DiagnosticCategory.Error, "Spread_operator_in_new_expressions_is_only_available_when_targeting_ECMAScript_5_and_higher_2472", "Spread operator in 'new' expressions is only available when targeting ECMAScript 5 and higher."), | |
| Enum_declarations_must_all_be_const_or_non_const: diag(2473, ts_DiagnosticCategory.Error, "Enum_declarations_must_all_be_const_or_non_const_2473", "Enum declarations must all be const or non-const."), | |
| const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values: diag(2474, ts_DiagnosticCategory.Error, "const_enum_member_initializers_can_only_contain_literal_values_and_other_computed_enum_values_2474", "const enum member initializers can only contain literal values and other computed enum values."), | |
| const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query: diag(2475, ts_DiagnosticCategory.Error, "const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_im_2475", "'const' enums can only be used in property or index access expressions or the right hand side of an import declaration or export assignment or type query."), | |
| A_const_enum_member_can_only_be_accessed_using_a_string_literal: diag(2476, ts_DiagnosticCategory.Error, "A_const_enum_member_can_only_be_accessed_using_a_string_literal_2476", "A const enum member can only be accessed using a string literal."), | |
| const_enum_member_initializer_was_evaluated_to_a_non_finite_value: diag(2477, ts_DiagnosticCategory.Error, "const_enum_member_initializer_was_evaluated_to_a_non_finite_value_2477", "'const' enum member initializer was evaluated to a non-finite value."), | |
| const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN: diag(2478, ts_DiagnosticCategory.Error, "const_enum_member_initializer_was_evaluated_to_disallowed_value_NaN_2478", "'const' enum member initializer was evaluated to disallowed value 'NaN'."), | |
| Property_0_does_not_exist_on_const_enum_1: diag(2479, ts_DiagnosticCategory.Error, "Property_0_does_not_exist_on_const_enum_1_2479", "Property '{0}' does not exist on 'const' enum '{1}'."), | |
| let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations: diag(2480, ts_DiagnosticCategory.Error, "let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations_2480", "'let' is not allowed to be used as a name in 'let' or 'const' declarations."), | |
| Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1: diag(2481, ts_DiagnosticCategory.Error, "Cannot_initialize_outer_scoped_variable_0_in_the_same_scope_as_block_scoped_declaration_1_2481", "Cannot initialize outer scoped variable '{0}' in the same scope as block scoped declaration '{1}'."), | |
| The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation: diag(2483, ts_DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_cannot_use_a_type_annotation_2483", "The left-hand side of a 'for...of' statement cannot use a type annotation."), | |
| Export_declaration_conflicts_with_exported_declaration_of_0: diag(2484, ts_DiagnosticCategory.Error, "Export_declaration_conflicts_with_exported_declaration_of_0_2484", "Export declaration conflicts with exported declaration of '{0}'."), | |
| The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access: diag(2487, ts_DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access_2487", "The left-hand side of a 'for...of' statement must be a variable or a property access."), | |
| Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2488, ts_DiagnosticCategory.Error, "Type_0_must_have_a_Symbol_iterator_method_that_returns_an_iterator_2488", "Type '{0}' must have a '[Symbol.iterator]()' method that returns an iterator."), | |
| An_iterator_must_have_a_next_method: diag(2489, ts_DiagnosticCategory.Error, "An_iterator_must_have_a_next_method_2489", "An iterator must have a 'next()' method."), | |
| The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property: diag(2490, ts_DiagnosticCategory.Error, "The_type_returned_by_the_0_method_of_an_iterator_must_have_a_value_property_2490", "The type returned by the '{0}()' method of an iterator must have a 'value' property."), | |
| The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern: diag(2491, ts_DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern_2491", "The left-hand side of a 'for...in' statement cannot be a destructuring pattern."), | |
| Cannot_redeclare_identifier_0_in_catch_clause: diag(2492, ts_DiagnosticCategory.Error, "Cannot_redeclare_identifier_0_in_catch_clause_2492", "Cannot redeclare identifier '{0}' in catch clause."), | |
| Tuple_type_0_of_length_1_has_no_element_at_index_2: diag(2493, ts_DiagnosticCategory.Error, "Tuple_type_0_of_length_1_has_no_element_at_index_2_2493", "Tuple type '{0}' of length '{1}' has no element at index '{2}'."), | |
| Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher: diag(2494, ts_DiagnosticCategory.Error, "Using_a_string_in_a_for_of_statement_is_only_supported_in_ECMAScript_5_and_higher_2494", "Using a string in a 'for...of' statement is only supported in ECMAScript 5 and higher."), | |
| Type_0_is_not_an_array_type_or_a_string_type: diag(2495, ts_DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_2495", "Type '{0}' is not an array type or a string type."), | |
| The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_standard_function_expression: diag(2496, ts_DiagnosticCategory.Error, "The_arguments_object_cannot_be_referenced_in_an_arrow_function_in_ES3_and_ES5_Consider_using_a_stand_2496", "The 'arguments' object cannot be referenced in an arrow function in ES3 and ES5. Consider using a standard function expression."), | |
| This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_referencing_its_default_export: diag(2497, ts_DiagnosticCategory.Error, "This_module_can_only_be_referenced_with_ECMAScript_imports_Slashexports_by_turning_on_the_0_flag_and_2497", "This module can only be referenced with ECMAScript imports/exports by turning on the '{0}' flag and referencing its default export."), | |
| Module_0_uses_export_and_cannot_be_used_with_export_Asterisk: diag(2498, ts_DiagnosticCategory.Error, "Module_0_uses_export_and_cannot_be_used_with_export_Asterisk_2498", "Module '{0}' uses 'export =' and cannot be used with 'export *'."), | |
| An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments: diag(2499, ts_DiagnosticCategory.Error, "An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments_2499", "An interface can only extend an identifier/qualified-name with optional type arguments."), | |
| A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments: diag(2500, ts_DiagnosticCategory.Error, "A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments_2500", "A class can only implement an identifier/qualified-name with optional type arguments."), | |
| A_rest_element_cannot_contain_a_binding_pattern: diag(2501, ts_DiagnosticCategory.Error, "A_rest_element_cannot_contain_a_binding_pattern_2501", "A rest element cannot contain a binding pattern."), | |
| _0_is_referenced_directly_or_indirectly_in_its_own_type_annotation: diag(2502, ts_DiagnosticCategory.Error, "_0_is_referenced_directly_or_indirectly_in_its_own_type_annotation_2502", "'{0}' is referenced directly or indirectly in its own type annotation."), | |
| Cannot_find_namespace_0: diag(2503, ts_DiagnosticCategory.Error, "Cannot_find_namespace_0_2503", "Cannot find namespace '{0}'."), | |
| Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator: diag(2504, ts_DiagnosticCategory.Error, "Type_0_must_have_a_Symbol_asyncIterator_method_that_returns_an_async_iterator_2504", "Type '{0}' must have a '[Symbol.asyncIterator]()' method that returns an async iterator."), | |
| A_generator_cannot_have_a_void_type_annotation: diag(2505, ts_DiagnosticCategory.Error, "A_generator_cannot_have_a_void_type_annotation_2505", "A generator cannot have a 'void' type annotation."), | |
| _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: diag(2506, ts_DiagnosticCategory.Error, "_0_is_referenced_directly_or_indirectly_in_its_own_base_expression_2506", "'{0}' is referenced directly or indirectly in its own base expression."), | |
| Type_0_is_not_a_constructor_function_type: diag(2507, ts_DiagnosticCategory.Error, "Type_0_is_not_a_constructor_function_type_2507", "Type '{0}' is not a constructor function type."), | |
| No_base_constructor_has_the_specified_number_of_type_arguments: diag(2508, ts_DiagnosticCategory.Error, "No_base_constructor_has_the_specified_number_of_type_arguments_2508", "No base constructor has the specified number of type arguments."), | |
| Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_known_members: diag(2509, ts_DiagnosticCategory.Error, "Base_constructor_return_type_0_is_not_an_object_type_or_intersection_of_object_types_with_statically_2509", "Base constructor return type '{0}' is not an object type or intersection of object types with statically known members."), | |
| Base_constructors_must_all_have_the_same_return_type: diag(2510, ts_DiagnosticCategory.Error, "Base_constructors_must_all_have_the_same_return_type_2510", "Base constructors must all have the same return type."), | |
| Cannot_create_an_instance_of_an_abstract_class: diag(2511, ts_DiagnosticCategory.Error, "Cannot_create_an_instance_of_an_abstract_class_2511", "Cannot create an instance of an abstract class."), | |
| Overload_signatures_must_all_be_abstract_or_non_abstract: diag(2512, ts_DiagnosticCategory.Error, "Overload_signatures_must_all_be_abstract_or_non_abstract_2512", "Overload signatures must all be abstract or non-abstract."), | |
| Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression: diag(2513, ts_DiagnosticCategory.Error, "Abstract_method_0_in_class_1_cannot_be_accessed_via_super_expression_2513", "Abstract method '{0}' in class '{1}' cannot be accessed via super expression."), | |
| Classes_containing_abstract_methods_must_be_marked_abstract: diag(2514, ts_DiagnosticCategory.Error, "Classes_containing_abstract_methods_must_be_marked_abstract_2514", "Classes containing abstract methods must be marked abstract."), | |
| Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2: diag(2515, ts_DiagnosticCategory.Error, "Non_abstract_class_0_does_not_implement_inherited_abstract_member_1_from_class_2_2515", "Non-abstract class '{0}' does not implement inherited abstract member '{1}' from class '{2}'."), | |
| All_declarations_of_an_abstract_method_must_be_consecutive: diag(2516, ts_DiagnosticCategory.Error, "All_declarations_of_an_abstract_method_must_be_consecutive_2516", "All declarations of an abstract method must be consecutive."), | |
| Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type: diag(2517, ts_DiagnosticCategory.Error, "Cannot_assign_an_abstract_constructor_type_to_a_non_abstract_constructor_type_2517", "Cannot assign an abstract constructor type to a non-abstract constructor type."), | |
| A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard: diag(2518, ts_DiagnosticCategory.Error, "A_this_based_type_guard_is_not_compatible_with_a_parameter_based_type_guard_2518", "A 'this'-based type guard is not compatible with a parameter-based type guard."), | |
| An_async_iterator_must_have_a_next_method: diag(2519, ts_DiagnosticCategory.Error, "An_async_iterator_must_have_a_next_method_2519", "An async iterator must have a 'next()' method."), | |
| Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions: diag(2520, ts_DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_uses_declaration_1_to_support_async_functions_2520", "Duplicate identifier '{0}'. Compiler uses declaration '{1}' to support async functions."), | |
| Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions: diag(2521, ts_DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_0_that_compiler_uses_to_support_async_functions_2521", "Expression resolves to variable declaration '{0}' that compiler uses to support async functions."), | |
| The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_using_a_standard_function_or_method: diag(2522, ts_DiagnosticCategory.Error, "The_arguments_object_cannot_be_referenced_in_an_async_function_or_method_in_ES3_and_ES5_Consider_usi_2522", "The 'arguments' object cannot be referenced in an async function or method in ES3 and ES5. Consider using a standard function or method."), | |
| yield_expressions_cannot_be_used_in_a_parameter_initializer: diag(2523, ts_DiagnosticCategory.Error, "yield_expressions_cannot_be_used_in_a_parameter_initializer_2523", "'yield' expressions cannot be used in a parameter initializer."), | |
| await_expressions_cannot_be_used_in_a_parameter_initializer: diag(2524, ts_DiagnosticCategory.Error, "await_expressions_cannot_be_used_in_a_parameter_initializer_2524", "'await' expressions cannot be used in a parameter initializer."), | |
| Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value: diag(2525, ts_DiagnosticCategory.Error, "Initializer_provides_no_value_for_this_binding_element_and_the_binding_element_has_no_default_value_2525", "Initializer provides no value for this binding element and the binding element has no default value."), | |
| A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface: diag(2526, ts_DiagnosticCategory.Error, "A_this_type_is_available_only_in_a_non_static_member_of_a_class_or_interface_2526", "A 'this' type is available only in a non-static member of a class or interface."), | |
| The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary: diag(2527, ts_DiagnosticCategory.Error, "The_inferred_type_of_0_references_an_inaccessible_1_type_A_type_annotation_is_necessary_2527", "The inferred type of '{0}' references an inaccessible '{1}' type. A type annotation is necessary."), | |
| A_module_cannot_have_multiple_default_exports: diag(2528, ts_DiagnosticCategory.Error, "A_module_cannot_have_multiple_default_exports_2528", "A module cannot have multiple default exports."), | |
| Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_functions: diag(2529, ts_DiagnosticCategory.Error, "Duplicate_identifier_0_Compiler_reserves_name_1_in_top_level_scope_of_a_module_containing_async_func_2529", "Duplicate identifier '{0}'. Compiler reserves name '{1}' in top level scope of a module containing async functions."), | |
| Property_0_is_incompatible_with_index_signature: diag(2530, ts_DiagnosticCategory.Error, "Property_0_is_incompatible_with_index_signature_2530", "Property '{0}' is incompatible with index signature."), | |
| Object_is_possibly_null: diag(2531, ts_DiagnosticCategory.Error, "Object_is_possibly_null_2531", "Object is possibly 'null'."), | |
| Object_is_possibly_undefined: diag(2532, ts_DiagnosticCategory.Error, "Object_is_possibly_undefined_2532", "Object is possibly 'undefined'."), | |
| Object_is_possibly_null_or_undefined: diag(2533, ts_DiagnosticCategory.Error, "Object_is_possibly_null_or_undefined_2533", "Object is possibly 'null' or 'undefined'."), | |
| A_function_returning_never_cannot_have_a_reachable_end_point: diag(2534, ts_DiagnosticCategory.Error, "A_function_returning_never_cannot_have_a_reachable_end_point_2534", "A function returning 'never' cannot have a reachable end point."), | |
| Enum_type_0_has_members_with_initializers_that_are_not_literals: diag(2535, ts_DiagnosticCategory.Error, "Enum_type_0_has_members_with_initializers_that_are_not_literals_2535", "Enum type '{0}' has members with initializers that are not literals."), | |
| Type_0_cannot_be_used_to_index_type_1: diag(2536, ts_DiagnosticCategory.Error, "Type_0_cannot_be_used_to_index_type_1_2536", "Type '{0}' cannot be used to index type '{1}'."), | |
| Type_0_has_no_matching_index_signature_for_type_1: diag(2537, ts_DiagnosticCategory.Error, "Type_0_has_no_matching_index_signature_for_type_1_2537", "Type '{0}' has no matching index signature for type '{1}'."), | |
| Type_0_cannot_be_used_as_an_index_type: diag(2538, ts_DiagnosticCategory.Error, "Type_0_cannot_be_used_as_an_index_type_2538", "Type '{0}' cannot be used as an index type."), | |
| Cannot_assign_to_0_because_it_is_not_a_variable: diag(2539, ts_DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_not_a_variable_2539", "Cannot assign to '{0}' because it is not a variable."), | |
| Cannot_assign_to_0_because_it_is_a_read_only_property: diag(2540, ts_DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_read_only_property_2540", "Cannot assign to '{0}' because it is a read-only property."), | |
| The_target_of_an_assignment_must_be_a_variable_or_a_property_access: diag(2541, ts_DiagnosticCategory.Error, "The_target_of_an_assignment_must_be_a_variable_or_a_property_access_2541", "The target of an assignment must be a variable or a property access."), | |
| Index_signature_in_type_0_only_permits_reading: diag(2542, ts_DiagnosticCategory.Error, "Index_signature_in_type_0_only_permits_reading_2542", "Index signature in type '{0}' only permits reading."), | |
| Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_meta_property_reference: diag(2543, ts_DiagnosticCategory.Error, "Duplicate_identifier_newTarget_Compiler_uses_variable_declaration_newTarget_to_capture_new_target_me_2543", "Duplicate identifier '_newTarget'. Compiler uses variable declaration '_newTarget' to capture 'new.target' meta-property reference."), | |
| Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta_property_reference: diag(2544, ts_DiagnosticCategory.Error, "Expression_resolves_to_variable_declaration_newTarget_that_compiler_uses_to_capture_new_target_meta__2544", "Expression resolves to variable declaration '_newTarget' that compiler uses to capture 'new.target' meta-property reference."), | |
| A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any: diag(2545, ts_DiagnosticCategory.Error, "A_mixin_class_must_have_a_constructor_with_a_single_rest_parameter_of_type_any_2545", "A mixin class must have a constructor with a single rest parameter of type 'any[]'."), | |
| Property_0_has_conflicting_declarations_and_is_inaccessible_in_type_1: diag(2546, ts_DiagnosticCategory.Error, "Property_0_has_conflicting_declarations_and_is_inaccessible_in_type_1_2546", "Property '{0}' has conflicting declarations and is inaccessible in type '{1}'."), | |
| The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_property: diag(2547, ts_DiagnosticCategory.Error, "The_type_returned_by_the_0_method_of_an_async_iterator_must_be_a_promise_for_a_type_with_a_value_pro_2547", "The type returned by the '{0}()' method of an async iterator must be a promise for a type with a 'value' property."), | |
| Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2548, ts_DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator_2548", "Type '{0}' is not an array type or does not have a '[Symbol.iterator]()' method that returns an iterator."), | |
| Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns_an_iterator: diag(2549, ts_DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_or_does_not_have_a_Symbol_iterator_method_that_returns__2549", "Type '{0}' is not an array type or a string type or does not have a '[Symbol.iterator]()' method that returns an iterator."), | |
| Property_0_does_not_exist_on_type_1_Did_you_mean_2: diag(2551, ts_DiagnosticCategory.Error, "Property_0_does_not_exist_on_type_1_Did_you_mean_2_2551", "Property '{0}' does not exist on type '{1}'. Did you mean '{2}'?"), | |
| Cannot_find_name_0_Did_you_mean_1: diag(2552, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_1_2552", "Cannot find name '{0}'. Did you mean '{1}'?"), | |
| Computed_values_are_not_permitted_in_an_enum_with_string_valued_members: diag(2553, ts_DiagnosticCategory.Error, "Computed_values_are_not_permitted_in_an_enum_with_string_valued_members_2553", "Computed values are not permitted in an enum with string valued members."), | |
| Expected_0_arguments_but_got_1: diag(2554, ts_DiagnosticCategory.Error, "Expected_0_arguments_but_got_1_2554", "Expected {0} arguments, but got {1}."), | |
| Expected_at_least_0_arguments_but_got_1: diag(2555, ts_DiagnosticCategory.Error, "Expected_at_least_0_arguments_but_got_1_2555", "Expected at least {0} arguments, but got {1}."), | |
| Expected_0_arguments_but_got_1_or_more: diag(2556, ts_DiagnosticCategory.Error, "Expected_0_arguments_but_got_1_or_more_2556", "Expected {0} arguments, but got {1} or more."), | |
| Expected_at_least_0_arguments_but_got_1_or_more: diag(2557, ts_DiagnosticCategory.Error, "Expected_at_least_0_arguments_but_got_1_or_more_2557", "Expected at least {0} arguments, but got {1} or more."), | |
| Expected_0_type_arguments_but_got_1: diag(2558, ts_DiagnosticCategory.Error, "Expected_0_type_arguments_but_got_1_2558", "Expected {0} type arguments, but got {1}."), | |
| Type_0_has_no_properties_in_common_with_type_1: diag(2559, ts_DiagnosticCategory.Error, "Type_0_has_no_properties_in_common_with_type_1_2559", "Type '{0}' has no properties in common with type '{1}'."), | |
| Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it: diag(2560, ts_DiagnosticCategory.Error, "Value_of_type_0_has_no_properties_in_common_with_type_1_Did_you_mean_to_call_it_2560", "Value of type '{0}' has no properties in common with type '{1}'. Did you mean to call it?"), | |
| Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_write_2: diag(2561, ts_DiagnosticCategory.Error, "Object_literal_may_only_specify_known_properties_but_0_does_not_exist_in_type_1_Did_you_mean_to_writ_2561", "Object literal may only specify known properties, but '{0}' does not exist in type '{1}'. Did you mean to write '{2}'?"), | |
| Base_class_expressions_cannot_reference_class_type_parameters: diag(2562, ts_DiagnosticCategory.Error, "Base_class_expressions_cannot_reference_class_type_parameters_2562", "Base class expressions cannot reference class type parameters."), | |
| The_containing_function_or_module_body_is_too_large_for_control_flow_analysis: diag(2563, ts_DiagnosticCategory.Error, "The_containing_function_or_module_body_is_too_large_for_control_flow_analysis_2563", "The containing function or module body is too large for control flow analysis."), | |
| Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor: diag(2564, ts_DiagnosticCategory.Error, "Property_0_has_no_initializer_and_is_not_definitely_assigned_in_the_constructor_2564", "Property '{0}' has no initializer and is not definitely assigned in the constructor."), | |
| Property_0_is_used_before_being_assigned: diag(2565, ts_DiagnosticCategory.Error, "Property_0_is_used_before_being_assigned_2565", "Property '{0}' is used before being assigned."), | |
| A_rest_element_cannot_have_a_property_name: diag(2566, ts_DiagnosticCategory.Error, "A_rest_element_cannot_have_a_property_name_2566", "A rest element cannot have a property name."), | |
| Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations: diag(2567, ts_DiagnosticCategory.Error, "Enum_declarations_can_only_merge_with_namespace_or_other_enum_declarations_2567", "Enum declarations can only merge with namespace or other enum declarations."), | |
| Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterating_of_iterators: diag(2569, ts_DiagnosticCategory.Error, "Type_0_is_not_an_array_type_or_a_string_type_Use_compiler_option_downlevelIteration_to_allow_iterati_2569", "Type '{0}' is not an array type or a string type. Use compiler option '--downlevelIteration' to allow iterating of iterators."), | |
| Object_is_of_type_unknown: diag(2571, ts_DiagnosticCategory.Error, "Object_is_of_type_unknown_2571", "Object is of type 'unknown'."), | |
| Rest_signatures_are_incompatible: diag(2572, ts_DiagnosticCategory.Error, "Rest_signatures_are_incompatible_2572", "Rest signatures are incompatible."), | |
| Property_0_is_incompatible_with_rest_element_type: diag(2573, ts_DiagnosticCategory.Error, "Property_0_is_incompatible_with_rest_element_type_2573", "Property '{0}' is incompatible with rest element type."), | |
| A_rest_element_type_must_be_an_array_type: diag(2574, ts_DiagnosticCategory.Error, "A_rest_element_type_must_be_an_array_type_2574", "A rest element type must be an array type."), | |
| No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments: diag(2575, ts_DiagnosticCategory.Error, "No_overload_expects_0_arguments_but_overloads_do_exist_that_expect_either_1_or_2_arguments_2575", "No overload expects {0} arguments, but overloads do exist that expect either {1} or {2} arguments."), | |
| Property_0_is_a_static_member_of_type_1: diag(2576, ts_DiagnosticCategory.Error, "Property_0_is_a_static_member_of_type_1_2576", "Property '{0}' is a static member of type '{1}'"), | |
| Return_type_annotation_circularly_references_itself: diag(2577, ts_DiagnosticCategory.Error, "Return_type_annotation_circularly_references_itself_2577", "Return type annotation circularly references itself."), | |
| Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode: diag(2580, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_2580", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i @types/node`."), | |
| Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery: diag(2581, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_2581", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i @types/jquery`."), | |
| Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha: diag(2582, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashje_2582", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha`."), | |
| Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: diag(2583, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2583", "Cannot find name '{0}'. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later."), | |
| Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_include_dom: diag(2584, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_2584", "Cannot find name '{0}'. Do you need to change your target library? Try changing the `lib` compiler option to include 'dom'."), | |
| _0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_Try_changing_the_lib_compiler_option_to_es2015_or_later: diag(2585, ts_DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_Do_you_need_to_change_your_target_library_2585", "'{0}' only refers to a type, but is being used as a value here. Do you need to change your target library? Try changing the `lib` compiler option to es2015 or later."), | |
| Enum_type_0_circularly_references_itself: diag(2586, ts_DiagnosticCategory.Error, "Enum_type_0_circularly_references_itself_2586", "Enum type '{0}' circularly references itself."), | |
| JSDoc_type_0_circularly_references_itself: diag(2587, ts_DiagnosticCategory.Error, "JSDoc_type_0_circularly_references_itself_2587", "JSDoc type '{0}' circularly references itself."), | |
| Cannot_assign_to_0_because_it_is_a_constant: diag(2588, ts_DiagnosticCategory.Error, "Cannot_assign_to_0_because_it_is_a_constant_2588", "Cannot assign to '{0}' because it is a constant."), | |
| Type_instantiation_is_excessively_deep_and_possibly_infinite: diag(2589, ts_DiagnosticCategory.Error, "Type_instantiation_is_excessively_deep_and_possibly_infinite_2589", "Type instantiation is excessively deep and possibly infinite."), | |
| Expression_produces_a_union_type_that_is_too_complex_to_represent: diag(2590, ts_DiagnosticCategory.Error, "Expression_produces_a_union_type_that_is_too_complex_to_represent_2590", "Expression produces a union type that is too complex to represent."), | |
| Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig: diag(2591, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_types_Slashnode_and_th_2591", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i @types/node` and then add `node` to the types field in your tsconfig."), | |
| Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig: diag(2592, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_types_Slashjquery_an_2592", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i @types/jquery` and then add `jquery` to the types field in your tsconfig."), | |
| Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashjest_or_npm_i_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig: diag(2593, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_types_Slashje_2593", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i @types/jest` or `npm i @types/mocha` and then add `jest` or `mocha` to the types field in your tsconfig."), | |
| This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag: diag(2594, ts_DiagnosticCategory.Error, "This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the__2594", "This module is declared with using 'export =', and can only be used with a default import when using the '{0}' flag."), | |
| JSX_element_attributes_type_0_may_not_be_a_union_type: diag(2600, ts_DiagnosticCategory.Error, "JSX_element_attributes_type_0_may_not_be_a_union_type_2600", "JSX element attributes type '{0}' may not be a union type."), | |
| The_return_type_of_a_JSX_element_constructor_must_return_an_object_type: diag(2601, ts_DiagnosticCategory.Error, "The_return_type_of_a_JSX_element_constructor_must_return_an_object_type_2601", "The return type of a JSX element constructor must return an object type."), | |
| JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist: diag(2602, ts_DiagnosticCategory.Error, "JSX_element_implicitly_has_type_any_because_the_global_type_JSX_Element_does_not_exist_2602", "JSX element implicitly has type 'any' because the global type 'JSX.Element' does not exist."), | |
| Property_0_in_type_1_is_not_assignable_to_type_2: diag(2603, ts_DiagnosticCategory.Error, "Property_0_in_type_1_is_not_assignable_to_type_2_2603", "Property '{0}' in type '{1}' is not assignable to type '{2}'."), | |
| JSX_element_type_0_does_not_have_any_construct_or_call_signatures: diag(2604, ts_DiagnosticCategory.Error, "JSX_element_type_0_does_not_have_any_construct_or_call_signatures_2604", "JSX element type '{0}' does not have any construct or call signatures."), | |
| JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements: diag(2605, ts_DiagnosticCategory.Error, "JSX_element_type_0_is_not_a_constructor_function_for_JSX_elements_2605", "JSX element type '{0}' is not a constructor function for JSX elements."), | |
| Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property: diag(2606, ts_DiagnosticCategory.Error, "Property_0_of_JSX_spread_attribute_is_not_assignable_to_target_property_2606", "Property '{0}' of JSX spread attribute is not assignable to target property."), | |
| JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property: diag(2607, ts_DiagnosticCategory.Error, "JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property_2607", "JSX element class does not support attributes because it does not have a '{0}' property."), | |
| The_global_type_JSX_0_may_not_have_more_than_one_property: diag(2608, ts_DiagnosticCategory.Error, "The_global_type_JSX_0_may_not_have_more_than_one_property_2608", "The global type 'JSX.{0}' may not have more than one property."), | |
| JSX_spread_child_must_be_an_array_type: diag(2609, ts_DiagnosticCategory.Error, "JSX_spread_child_must_be_an_array_type_2609", "JSX spread child must be an array type."), | |
| _0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property: diag(2610, ts_DiagnosticCategory.Error, "_0_is_defined_as_an_accessor_in_class_1_but_is_overridden_here_in_2_as_an_instance_property_2610", "'{0}' is defined as an accessor in class '{1}', but is overridden here in '{2}' as an instance property."), | |
| _0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor: diag(2611, ts_DiagnosticCategory.Error, "_0_is_defined_as_a_property_in_class_1_but_is_overridden_here_in_2_as_an_accessor_2611", "'{0}' is defined as a property in class '{1}', but is overridden here in '{2}' as an accessor."), | |
| Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_add_a_declare_modifier_or_remove_the_redundant_declaration: diag(2612, ts_DiagnosticCategory.Error, "Property_0_will_overwrite_the_base_property_in_1_If_this_is_intentional_add_an_initializer_Otherwise_2612", "Property '{0}' will overwrite the base property in '{1}'. If this is intentional, add an initializer. Otherwise, add a 'declare' modifier or remove the redundant declaration."), | |
| Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead: diag(2613, ts_DiagnosticCategory.Error, "Module_0_has_no_default_export_Did_you_mean_to_use_import_1_from_0_instead_2613", "Module '{0}' has no default export. Did you mean to use 'import { {1} } from {0}' instead?"), | |
| Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead: diag(2614, ts_DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_Did_you_mean_to_use_import_1_from_0_instead_2614", "Module '{0}' has no exported member '{1}'. Did you mean to use 'import {1} from {0}' instead?"), | |
| Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity: diag(2649, ts_DiagnosticCategory.Error, "Cannot_augment_module_0_with_value_exports_because_it_resolves_to_a_non_module_entity_2649", "Cannot augment module '{0}' with value exports because it resolves to a non-module entity."), | |
| A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_members_defined_in_other_enums: diag(2651, ts_DiagnosticCategory.Error, "A_member_initializer_in_a_enum_declaration_cannot_reference_members_declared_after_it_including_memb_2651", "A member initializer in a enum declaration cannot reference members declared after it, including members defined in other enums."), | |
| Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_default_0_declaration_instead: diag(2652, ts_DiagnosticCategory.Error, "Merged_declaration_0_cannot_include_a_default_export_declaration_Consider_adding_a_separate_export_d_2652", "Merged declaration '{0}' cannot include a default export declaration. Consider adding a separate 'export default {0}' declaration instead."), | |
| Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1: diag(2653, ts_DiagnosticCategory.Error, "Non_abstract_class_expression_does_not_implement_inherited_abstract_member_0_from_class_1_2653", "Non-abstract class expression does not implement inherited abstract member '{0}' from class '{1}'."), | |
| Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_package_author_to_update_the_package_definition: diag(2654, ts_DiagnosticCategory.Error, "Exported_external_package_typings_file_cannot_contain_tripleslash_references_Please_contact_the_pack_2654", "Exported external package typings file cannot contain tripleslash references. Please contact the package author to update the package definition."), | |
| Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_the_package_definition: diag(2656, ts_DiagnosticCategory.Error, "Exported_external_package_typings_file_0_is_not_a_module_Please_contact_the_package_author_to_update_2656", "Exported external package typings file '{0}' is not a module. Please contact the package author to update the package definition."), | |
| JSX_expressions_must_have_one_parent_element: diag(2657, ts_DiagnosticCategory.Error, "JSX_expressions_must_have_one_parent_element_2657", "JSX expressions must have one parent element."), | |
| Type_0_provides_no_match_for_the_signature_1: diag(2658, ts_DiagnosticCategory.Error, "Type_0_provides_no_match_for_the_signature_1_2658", "Type '{0}' provides no match for the signature '{1}'."), | |
| super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_higher: diag(2659, ts_DiagnosticCategory.Error, "super_is_only_allowed_in_members_of_object_literal_expressions_when_option_target_is_ES2015_or_highe_2659", "'super' is only allowed in members of object literal expressions when option 'target' is 'ES2015' or higher."), | |
| super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions: diag(2660, ts_DiagnosticCategory.Error, "super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions_2660", "'super' can only be referenced in members of derived classes or object literal expressions."), | |
| Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module: diag(2661, ts_DiagnosticCategory.Error, "Cannot_export_0_Only_local_declarations_can_be_exported_from_a_module_2661", "Cannot export '{0}'. Only local declarations can be exported from a module."), | |
| Cannot_find_name_0_Did_you_mean_the_static_member_1_0: diag(2662, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_the_static_member_1_0_2662", "Cannot find name '{0}'. Did you mean the static member '{1}.{0}'?"), | |
| Cannot_find_name_0_Did_you_mean_the_instance_member_this_0: diag(2663, ts_DiagnosticCategory.Error, "Cannot_find_name_0_Did_you_mean_the_instance_member_this_0_2663", "Cannot find name '{0}'. Did you mean the instance member 'this.{0}'?"), | |
| Invalid_module_name_in_augmentation_module_0_cannot_be_found: diag(2664, ts_DiagnosticCategory.Error, "Invalid_module_name_in_augmentation_module_0_cannot_be_found_2664", "Invalid module name in augmentation, module '{0}' cannot be found."), | |
| Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augmented: diag(2665, ts_DiagnosticCategory.Error, "Invalid_module_name_in_augmentation_Module_0_resolves_to_an_untyped_module_at_1_which_cannot_be_augm_2665", "Invalid module name in augmentation. Module '{0}' resolves to an untyped module at '{1}', which cannot be augmented."), | |
| Exports_and_export_assignments_are_not_permitted_in_module_augmentations: diag(2666, ts_DiagnosticCategory.Error, "Exports_and_export_assignments_are_not_permitted_in_module_augmentations_2666", "Exports and export assignments are not permitted in module augmentations."), | |
| Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module: diag(2667, ts_DiagnosticCategory.Error, "Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_mod_2667", "Imports are not permitted in module augmentations. Consider moving them to the enclosing external module."), | |
| export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always_visible: diag(2668, ts_DiagnosticCategory.Error, "export_modifier_cannot_be_applied_to_ambient_modules_and_module_augmentations_since_they_are_always__2668", "'export' modifier cannot be applied to ambient modules and module augmentations since they are always visible."), | |
| Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_declarations: diag(2669, ts_DiagnosticCategory.Error, "Augmentations_for_the_global_scope_can_only_be_directly_nested_in_external_modules_or_ambient_module_2669", "Augmentations for the global scope can only be directly nested in external modules or ambient module declarations."), | |
| Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambient_context: diag(2670, ts_DiagnosticCategory.Error, "Augmentations_for_the_global_scope_should_have_declare_modifier_unless_they_appear_in_already_ambien_2670", "Augmentations for the global scope should have 'declare' modifier unless they appear in already ambient context."), | |
| Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity: diag(2671, ts_DiagnosticCategory.Error, "Cannot_augment_module_0_because_it_resolves_to_a_non_module_entity_2671", "Cannot augment module '{0}' because it resolves to a non-module entity."), | |
| Cannot_assign_a_0_constructor_type_to_a_1_constructor_type: diag(2672, ts_DiagnosticCategory.Error, "Cannot_assign_a_0_constructor_type_to_a_1_constructor_type_2672", "Cannot assign a '{0}' constructor type to a '{1}' constructor type."), | |
| Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration: diag(2673, ts_DiagnosticCategory.Error, "Constructor_of_class_0_is_private_and_only_accessible_within_the_class_declaration_2673", "Constructor of class '{0}' is private and only accessible within the class declaration."), | |
| Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration: diag(2674, ts_DiagnosticCategory.Error, "Constructor_of_class_0_is_protected_and_only_accessible_within_the_class_declaration_2674", "Constructor of class '{0}' is protected and only accessible within the class declaration."), | |
| Cannot_extend_a_class_0_Class_constructor_is_marked_as_private: diag(2675, ts_DiagnosticCategory.Error, "Cannot_extend_a_class_0_Class_constructor_is_marked_as_private_2675", "Cannot extend a class '{0}'. Class constructor is marked as private."), | |
| Accessors_must_both_be_abstract_or_non_abstract: diag(2676, ts_DiagnosticCategory.Error, "Accessors_must_both_be_abstract_or_non_abstract_2676", "Accessors must both be abstract or non-abstract."), | |
| A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type: diag(2677, ts_DiagnosticCategory.Error, "A_type_predicate_s_type_must_be_assignable_to_its_parameter_s_type_2677", "A type predicate's type must be assignable to its parameter's type."), | |
| Type_0_is_not_comparable_to_type_1: diag(2678, ts_DiagnosticCategory.Error, "Type_0_is_not_comparable_to_type_1_2678", "Type '{0}' is not comparable to type '{1}'."), | |
| A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void: diag(2679, ts_DiagnosticCategory.Error, "A_function_that_is_called_with_the_new_keyword_cannot_have_a_this_type_that_is_void_2679", "A function that is called with the 'new' keyword cannot have a 'this' type that is 'void'."), | |
| A_0_parameter_must_be_the_first_parameter: diag(2680, ts_DiagnosticCategory.Error, "A_0_parameter_must_be_the_first_parameter_2680", "A '{0}' parameter must be the first parameter."), | |
| A_constructor_cannot_have_a_this_parameter: diag(2681, ts_DiagnosticCategory.Error, "A_constructor_cannot_have_a_this_parameter_2681", "A constructor cannot have a 'this' parameter."), | |
| get_and_set_accessor_must_have_the_same_this_type: diag(2682, ts_DiagnosticCategory.Error, "get_and_set_accessor_must_have_the_same_this_type_2682", "'get' and 'set' accessor must have the same 'this' type."), | |
| this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation: diag(2683, ts_DiagnosticCategory.Error, "this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_2683", "'this' implicitly has type 'any' because it does not have a type annotation."), | |
| The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1: diag(2684, ts_DiagnosticCategory.Error, "The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1_2684", "The 'this' context of type '{0}' is not assignable to method's 'this' of type '{1}'."), | |
| The_this_types_of_each_signature_are_incompatible: diag(2685, ts_DiagnosticCategory.Error, "The_this_types_of_each_signature_are_incompatible_2685", "The 'this' types of each signature are incompatible."), | |
| _0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead: diag(2686, ts_DiagnosticCategory.Error, "_0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead_2686", "'{0}' refers to a UMD global, but the current file is a module. Consider adding an import instead."), | |
| All_declarations_of_0_must_have_identical_modifiers: diag(2687, ts_DiagnosticCategory.Error, "All_declarations_of_0_must_have_identical_modifiers_2687", "All declarations of '{0}' must have identical modifiers."), | |
| Cannot_find_type_definition_file_for_0: diag(2688, ts_DiagnosticCategory.Error, "Cannot_find_type_definition_file_for_0_2688", "Cannot find type definition file for '{0}'."), | |
| Cannot_extend_an_interface_0_Did_you_mean_implements: diag(2689, ts_DiagnosticCategory.Error, "Cannot_extend_an_interface_0_Did_you_mean_implements_2689", "Cannot extend an interface '{0}'. Did you mean 'implements'?"), | |
| An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead: diag(2691, ts_DiagnosticCategory.Error, "An_import_path_cannot_end_with_a_0_extension_Consider_importing_1_instead_2691", "An import path cannot end with a '{0}' extension. Consider importing '{1}' instead."), | |
| _0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible: diag(2692, ts_DiagnosticCategory.Error, "_0_is_a_primitive_but_1_is_a_wrapper_object_Prefer_using_0_when_possible_2692", "'{0}' is a primitive, but '{1}' is a wrapper object. Prefer using '{0}' when possible."), | |
| _0_only_refers_to_a_type_but_is_being_used_as_a_value_here: diag(2693, ts_DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_value_here_2693", "'{0}' only refers to a type, but is being used as a value here."), | |
| Namespace_0_has_no_exported_member_1: diag(2694, ts_DiagnosticCategory.Error, "Namespace_0_has_no_exported_member_1_2694", "Namespace '{0}' has no exported member '{1}'."), | |
| Left_side_of_comma_operator_is_unused_and_has_no_side_effects: diag(2695, ts_DiagnosticCategory.Error, "Left_side_of_comma_operator_is_unused_and_has_no_side_effects_2695", "Left side of comma operator is unused and has no side effects.", true), | |
| The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead: diag(2696, ts_DiagnosticCategory.Error, "The_Object_type_is_assignable_to_very_few_other_types_Did_you_mean_to_use_the_any_type_instead_2696", "The 'Object' type is assignable to very few other types. Did you mean to use the 'any' type instead?"), | |
| An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: diag(2697, ts_DiagnosticCategory.Error, "An_async_function_or_method_must_return_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_in_2697", "An async function or method must return a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your `--lib` option."), | |
| Spread_types_may_only_be_created_from_object_types: diag(2698, ts_DiagnosticCategory.Error, "Spread_types_may_only_be_created_from_object_types_2698", "Spread types may only be created from object types."), | |
| Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1: diag(2699, ts_DiagnosticCategory.Error, "Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1_2699", "Static property '{0}' conflicts with built-in property 'Function.{0}' of constructor function '{1}'."), | |
| Rest_types_may_only_be_created_from_object_types: diag(2700, ts_DiagnosticCategory.Error, "Rest_types_may_only_be_created_from_object_types_2700", "Rest types may only be created from object types."), | |
| The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access: diag(2701, ts_DiagnosticCategory.Error, "The_target_of_an_object_rest_assignment_must_be_a_variable_or_a_property_access_2701", "The target of an object rest assignment must be a variable or a property access."), | |
| _0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here: diag(2702, ts_DiagnosticCategory.Error, "_0_only_refers_to_a_type_but_is_being_used_as_a_namespace_here_2702", "'{0}' only refers to a type, but is being used as a namespace here."), | |
| The_operand_of_a_delete_operator_must_be_a_property_reference: diag(2703, ts_DiagnosticCategory.Error, "The_operand_of_a_delete_operator_must_be_a_property_reference_2703", "The operand of a 'delete' operator must be a property reference."), | |
| The_operand_of_a_delete_operator_cannot_be_a_read_only_property: diag(2704, ts_DiagnosticCategory.Error, "The_operand_of_a_delete_operator_cannot_be_a_read_only_property_2704", "The operand of a 'delete' operator cannot be a read-only property."), | |
| An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: diag(2705, ts_DiagnosticCategory.Error, "An_async_function_or_method_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_de_2705", "An async function or method in ES5/ES3 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option."), | |
| Required_type_parameters_may_not_follow_optional_type_parameters: diag(2706, ts_DiagnosticCategory.Error, "Required_type_parameters_may_not_follow_optional_type_parameters_2706", "Required type parameters may not follow optional type parameters."), | |
| Generic_type_0_requires_between_1_and_2_type_arguments: diag(2707, ts_DiagnosticCategory.Error, "Generic_type_0_requires_between_1_and_2_type_arguments_2707", "Generic type '{0}' requires between {1} and {2} type arguments."), | |
| Cannot_use_namespace_0_as_a_value: diag(2708, ts_DiagnosticCategory.Error, "Cannot_use_namespace_0_as_a_value_2708", "Cannot use namespace '{0}' as a value."), | |
| Cannot_use_namespace_0_as_a_type: diag(2709, ts_DiagnosticCategory.Error, "Cannot_use_namespace_0_as_a_type_2709", "Cannot use namespace '{0}' as a type."), | |
| _0_are_specified_twice_The_attribute_named_0_will_be_overwritten: diag(2710, ts_DiagnosticCategory.Error, "_0_are_specified_twice_The_attribute_named_0_will_be_overwritten_2710", "'{0}' are specified twice. The attribute named '{0}' will be overwritten."), | |
| A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES2015_in_your_lib_option: diag(2711, ts_DiagnosticCategory.Error, "A_dynamic_import_call_returns_a_Promise_Make_sure_you_have_a_declaration_for_Promise_or_include_ES20_2711", "A dynamic import call returns a 'Promise'. Make sure you have a declaration for 'Promise' or include 'ES2015' in your `--lib` option."), | |
| A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declaration_for_the_Promise_constructor_or_include_ES2015_in_your_lib_option: diag(2712, ts_DiagnosticCategory.Error, "A_dynamic_import_call_in_ES5_SlashES3_requires_the_Promise_constructor_Make_sure_you_have_a_declarat_2712", "A dynamic import call in ES5/ES3 requires the 'Promise' constructor. Make sure you have a declaration for the 'Promise' constructor or include 'ES2015' in your `--lib` option."), | |
| Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_property_1_in_0_with_0_1: diag(2713, ts_DiagnosticCategory.Error, "Cannot_access_0_1_because_0_is_a_type_but_not_a_namespace_Did_you_mean_to_retrieve_the_type_of_the_p_2713", "Cannot access '{0}.{1}' because '{0}' is a type, but not a namespace. Did you mean to retrieve the type of the property '{1}' in '{0}' with '{0}[\"{1}\"]'?"), | |
| The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context: diag(2714, ts_DiagnosticCategory.Error, "The_expression_of_an_export_assignment_must_be_an_identifier_or_qualified_name_in_an_ambient_context_2714", "The expression of an export assignment must be an identifier or qualified name in an ambient context."), | |
| Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor: diag(2715, ts_DiagnosticCategory.Error, "Abstract_property_0_in_class_1_cannot_be_accessed_in_the_constructor_2715", "Abstract property '{0}' in class '{1}' cannot be accessed in the constructor."), | |
| Type_parameter_0_has_a_circular_default: diag(2716, ts_DiagnosticCategory.Error, "Type_parameter_0_has_a_circular_default_2716", "Type parameter '{0}' has a circular default."), | |
| Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_type_2: diag(2717, ts_DiagnosticCategory.Error, "Subsequent_property_declarations_must_have_the_same_type_Property_0_must_be_of_type_1_but_here_has_t_2717", "Subsequent property declarations must have the same type. Property '{0}' must be of type '{1}', but here has type '{2}'."), | |
| Duplicate_property_0: diag(2718, ts_DiagnosticCategory.Error, "Duplicate_property_0_2718", "Duplicate property '{0}'."), | |
| Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated: diag(2719, ts_DiagnosticCategory.Error, "Type_0_is_not_assignable_to_type_1_Two_different_types_with_this_name_exist_but_they_are_unrelated_2719", "Type '{0}' is not assignable to type '{1}'. Two different types with this name exist, but they are unrelated."), | |
| Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclass: diag(2720, ts_DiagnosticCategory.Error, "Class_0_incorrectly_implements_class_1_Did_you_mean_to_extend_1_and_inherit_its_members_as_a_subclas_2720", "Class '{0}' incorrectly implements class '{1}'. Did you mean to extend '{1}' and inherit its members as a subclass?"), | |
| Cannot_invoke_an_object_which_is_possibly_null: diag(2721, ts_DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_null_2721", "Cannot invoke an object which is possibly 'null'."), | |
| Cannot_invoke_an_object_which_is_possibly_undefined: diag(2722, ts_DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_undefined_2722", "Cannot invoke an object which is possibly 'undefined'."), | |
| Cannot_invoke_an_object_which_is_possibly_null_or_undefined: diag(2723, ts_DiagnosticCategory.Error, "Cannot_invoke_an_object_which_is_possibly_null_or_undefined_2723", "Cannot invoke an object which is possibly 'null' or 'undefined'."), | |
| Module_0_has_no_exported_member_1_Did_you_mean_2: diag(2724, ts_DiagnosticCategory.Error, "Module_0_has_no_exported_member_1_Did_you_mean_2_2724", "Module '{0}' has no exported member '{1}'. Did you mean '{2}'?"), | |
| Class_name_cannot_be_Object_when_targeting_ES5_with_module_0: diag(2725, ts_DiagnosticCategory.Error, "Class_name_cannot_be_Object_when_targeting_ES5_with_module_0_2725", "Class name cannot be 'Object' when targeting ES5 with module {0}."), | |
| Cannot_find_lib_definition_for_0: diag(2726, ts_DiagnosticCategory.Error, "Cannot_find_lib_definition_for_0_2726", "Cannot find lib definition for '{0}'."), | |
| Cannot_find_lib_definition_for_0_Did_you_mean_1: diag(2727, ts_DiagnosticCategory.Error, "Cannot_find_lib_definition_for_0_Did_you_mean_1_2727", "Cannot find lib definition for '{0}'. Did you mean '{1}'?"), | |
| _0_is_declared_here: diag(2728, ts_DiagnosticCategory.Message, "_0_is_declared_here_2728", "'{0}' is declared here."), | |
| Property_0_is_used_before_its_initialization: diag(2729, ts_DiagnosticCategory.Error, "Property_0_is_used_before_its_initialization_2729", "Property '{0}' is used before its initialization."), | |
| An_arrow_function_cannot_have_a_this_parameter: diag(2730, ts_DiagnosticCategory.Error, "An_arrow_function_cannot_have_a_this_parameter_2730", "An arrow function cannot have a 'this' parameter."), | |
| Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String: diag(2731, ts_DiagnosticCategory.Error, "Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_i_2731", "Implicit conversion of a 'symbol' to a 'string' will fail at runtime. Consider wrapping this expression in 'String(...)'."), | |
| Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension: diag(2732, ts_DiagnosticCategory.Error, "Cannot_find_module_0_Consider_using_resolveJsonModule_to_import_module_with_json_extension_2732", "Cannot find module '{0}'. Consider using '--resolveJsonModule' to import module with '.json' extension"), | |
| Property_0_was_also_declared_here: diag(2733, ts_DiagnosticCategory.Error, "Property_0_was_also_declared_here_2733", "Property '{0}' was also declared here."), | |
| It_is_highly_likely_that_you_are_missing_a_semicolon: diag(2734, ts_DiagnosticCategory.Error, "It_is_highly_likely_that_you_are_missing_a_semicolon_2734", "It is highly likely that you are missing a semicolon."), | |
| Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1: diag(2735, ts_DiagnosticCategory.Error, "Did_you_mean_for_0_to_be_constrained_to_type_new_args_Colon_any_1_2735", "Did you mean for '{0}' to be constrained to type 'new (...args: any[]) => {1}'?"), | |
| Operator_0_cannot_be_applied_to_type_1: diag(2736, ts_DiagnosticCategory.Error, "Operator_0_cannot_be_applied_to_type_1_2736", "Operator '{0}' cannot be applied to type '{1}'."), | |
| BigInt_literals_are_not_available_when_targeting_lower_than_ES2020: diag(2737, ts_DiagnosticCategory.Error, "BigInt_literals_are_not_available_when_targeting_lower_than_ES2020_2737", "BigInt literals are not available when targeting lower than ES2020."), | |
| An_outer_value_of_this_is_shadowed_by_this_container: diag(2738, ts_DiagnosticCategory.Message, "An_outer_value_of_this_is_shadowed_by_this_container_2738", "An outer value of 'this' is shadowed by this container."), | |
| Type_0_is_missing_the_following_properties_from_type_1_Colon_2: diag(2739, ts_DiagnosticCategory.Error, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_2739", "Type '{0}' is missing the following properties from type '{1}': {2}"), | |
| Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more: diag(2740, ts_DiagnosticCategory.Error, "Type_0_is_missing_the_following_properties_from_type_1_Colon_2_and_3_more_2740", "Type '{0}' is missing the following properties from type '{1}': {2}, and {3} more."), | |
| Property_0_is_missing_in_type_1_but_required_in_type_2: diag(2741, ts_DiagnosticCategory.Error, "Property_0_is_missing_in_type_1_but_required_in_type_2_2741", "Property '{0}' is missing in type '{1}' but required in type '{2}'."), | |
| The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_annotation_is_necessary: diag(2742, ts_DiagnosticCategory.Error, "The_inferred_type_of_0_cannot_be_named_without_a_reference_to_1_This_is_likely_not_portable_A_type_a_2742", "The inferred type of '{0}' cannot be named without a reference to '{1}'. This is likely not portable. A type annotation is necessary."), | |
| No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments: diag(2743, ts_DiagnosticCategory.Error, "No_overload_expects_0_type_arguments_but_overloads_do_exist_that_expect_either_1_or_2_type_arguments_2743", "No overload expects {0} type arguments, but overloads do exist that expect either {1} or {2} type arguments."), | |
| Type_parameter_defaults_can_only_reference_previously_declared_type_parameters: diag(2744, ts_DiagnosticCategory.Error, "Type_parameter_defaults_can_only_reference_previously_declared_type_parameters_2744", "Type parameter defaults can only reference previously declared type parameters."), | |
| This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided: diag(2745, ts_DiagnosticCategory.Error, "This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_pr_2745", "This JSX tag's '{0}' prop expects type '{1}' which requires multiple children, but only a single child was provided."), | |
| This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided: diag(2746, ts_DiagnosticCategory.Error, "This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided_2746", "This JSX tag's '{0}' prop expects a single child of type '{1}', but multiple children were provided."), | |
| _0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2: diag(2747, ts_DiagnosticCategory.Error, "_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_t_2747", "'{0}' components don't accept text as child elements. Text in JSX has the type 'string', but the expected type of '{1}' is '{2}'."), | |
| Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided: diag(2748, ts_DiagnosticCategory.Error, "Cannot_access_ambient_const_enums_when_the_isolatedModules_flag_is_provided_2748", "Cannot access ambient const enums when the '--isolatedModules' flag is provided."), | |
| _0_refers_to_a_value_but_is_being_used_as_a_type_here: diag(2749, ts_DiagnosticCategory.Error, "_0_refers_to_a_value_but_is_being_used_as_a_type_here_2749", "'{0}' refers to a value, but is being used as a type here."), | |
| The_implementation_signature_is_declared_here: diag(2750, ts_DiagnosticCategory.Error, "The_implementation_signature_is_declared_here_2750", "The implementation signature is declared here."), | |
| Circularity_originates_in_type_at_this_location: diag(2751, ts_DiagnosticCategory.Error, "Circularity_originates_in_type_at_this_location_2751", "Circularity originates in type at this location."), | |
| The_first_export_default_is_here: diag(2752, ts_DiagnosticCategory.Error, "The_first_export_default_is_here_2752", "The first export default is here."), | |
| Another_export_default_is_here: diag(2753, ts_DiagnosticCategory.Error, "Another_export_default_is_here_2753", "Another export default is here."), | |
| super_may_not_use_type_arguments: diag(2754, ts_DiagnosticCategory.Error, "super_may_not_use_type_arguments_2754", "'super' may not use type arguments."), | |
| No_constituent_of_type_0_is_callable: diag(2755, ts_DiagnosticCategory.Error, "No_constituent_of_type_0_is_callable_2755", "No constituent of type '{0}' is callable."), | |
| Not_all_constituents_of_type_0_are_callable: diag(2756, ts_DiagnosticCategory.Error, "Not_all_constituents_of_type_0_are_callable_2756", "Not all constituents of type '{0}' are callable."), | |
| Type_0_has_no_call_signatures: diag(2757, ts_DiagnosticCategory.Error, "Type_0_has_no_call_signatures_2757", "Type '{0}' has no call signatures."), | |
| Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_other: diag(2758, ts_DiagnosticCategory.Error, "Each_member_of_the_union_type_0_has_signatures_but_none_of_those_signatures_are_compatible_with_each_2758", "Each member of the union type '{0}' has signatures, but none of those signatures are compatible with each other."), | |
| No_constituent_of_type_0_is_constructable: diag(2759, ts_DiagnosticCategory.Error, "No_constituent_of_type_0_is_constructable_2759", "No constituent of type '{0}' is constructable."), | |
| Not_all_constituents_of_type_0_are_constructable: diag(2760, ts_DiagnosticCategory.Error, "Not_all_constituents_of_type_0_are_constructable_2760", "Not all constituents of type '{0}' are constructable."), | |
| Type_0_has_no_construct_signatures: diag(2761, ts_DiagnosticCategory.Error, "Type_0_has_no_construct_signatures_2761", "Type '{0}' has no construct signatures."), | |
| Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_with_each_other: diag(2762, ts_DiagnosticCategory.Error, "Each_member_of_the_union_type_0_has_construct_signatures_but_none_of_those_signatures_are_compatible_2762", "Each member of the union type '{0}' has construct signatures, but none of those signatures are compatible with each other."), | |
| Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_send_0: diag(2763, ts_DiagnosticCategory.Error, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_for_of_will_always_s_2763", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but for-of will always send '{0}'."), | |
| Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_always_send_0: diag(2764, ts_DiagnosticCategory.Error, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_spread_will_al_2764", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array spread will always send '{0}'."), | |
| Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring_will_always_send_0: diag(2765, ts_DiagnosticCategory.Error, "Cannot_iterate_value_because_the_next_method_of_its_iterator_expects_type_1_but_array_destructuring__2765", "Cannot iterate value because the 'next' method of its iterator expects type '{1}', but array destructuring will always send '{0}'."), | |
| Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_containing_generator_will_always_send_0: diag(2766, ts_DiagnosticCategory.Error, "Cannot_delegate_iteration_to_value_because_the_next_method_of_its_iterator_expects_type_1_but_the_co_2766", "Cannot delegate iteration to value because the 'next' method of its iterator expects type '{1}', but the containing generator will always send '{0}'."), | |
| The_0_property_of_an_iterator_must_be_a_method: diag(2767, ts_DiagnosticCategory.Error, "The_0_property_of_an_iterator_must_be_a_method_2767", "The '{0}' property of an iterator must be a method."), | |
| The_0_property_of_an_async_iterator_must_be_a_method: diag(2768, ts_DiagnosticCategory.Error, "The_0_property_of_an_async_iterator_must_be_a_method_2768", "The '{0}' property of an async iterator must be a method."), | |
| No_overload_matches_this_call: diag(2769, ts_DiagnosticCategory.Error, "No_overload_matches_this_call_2769", "No overload matches this call."), | |
| The_last_overload_gave_the_following_error: diag(2770, ts_DiagnosticCategory.Error, "The_last_overload_gave_the_following_error_2770", "The last overload gave the following error."), | |
| The_last_overload_is_declared_here: diag(2771, ts_DiagnosticCategory.Error, "The_last_overload_is_declared_here_2771", "The last overload is declared here."), | |
| Overload_0_of_1_2_gave_the_following_error: diag(2772, ts_DiagnosticCategory.Error, "Overload_0_of_1_2_gave_the_following_error_2772", "Overload {0} of {1}, '{2}', gave the following error."), | |
| Did_you_forget_to_use_await: diag(2773, ts_DiagnosticCategory.Error, "Did_you_forget_to_use_await_2773", "Did you forget to use 'await'?"), | |
| This_condition_will_always_return_true_since_the_function_is_always_defined_Did_you_mean_to_call_it_instead: diag(2774, ts_DiagnosticCategory.Error, "This_condition_will_always_return_true_since_the_function_is_always_defined_Did_you_mean_to_call_it__2774", "This condition will always return true since the function is always defined. Did you mean to call it instead?"), | |
| Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation: diag(2775, ts_DiagnosticCategory.Error, "Assertions_require_every_name_in_the_call_target_to_be_declared_with_an_explicit_type_annotation_2775", "Assertions require every name in the call target to be declared with an explicit type annotation."), | |
| Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name: diag(2776, ts_DiagnosticCategory.Error, "Assertions_require_the_call_target_to_be_an_identifier_or_qualified_name_2776", "Assertions require the call target to be an identifier or qualified name."), | |
| The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access: diag(2777, ts_DiagnosticCategory.Error, "The_operand_of_an_increment_or_decrement_operator_may_not_be_an_optional_property_access_2777", "The operand of an increment or decrement operator may not be an optional property access."), | |
| The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access: diag(2778, ts_DiagnosticCategory.Error, "The_target_of_an_object_rest_assignment_may_not_be_an_optional_property_access_2778", "The target of an object rest assignment may not be an optional property access."), | |
| The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access: diag(2779, ts_DiagnosticCategory.Error, "The_left_hand_side_of_an_assignment_expression_may_not_be_an_optional_property_access_2779", "The left-hand side of an assignment expression may not be an optional property access."), | |
| The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access: diag(2780, ts_DiagnosticCategory.Error, "The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access_2780", "The left-hand side of a 'for...in' statement may not be an optional property access."), | |
| The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access: diag(2781, ts_DiagnosticCategory.Error, "The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access_2781", "The left-hand side of a 'for...of' statement may not be an optional property access."), | |
| _0_needs_an_explicit_type_annotation: diag(2782, ts_DiagnosticCategory.Message, "_0_needs_an_explicit_type_annotation_2782", "'{0}' needs an explicit type annotation."), | |
| Import_declaration_0_is_using_private_name_1: diag(4000, ts_DiagnosticCategory.Error, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."), | |
| Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, ts_DiagnosticCategory.Error, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."), | |
| Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, ts_DiagnosticCategory.Error, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."), | |
| Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4006, ts_DiagnosticCategory.Error, "Type_parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4006", "Type parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."), | |
| Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4008, ts_DiagnosticCategory.Error, "Type_parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4008", "Type parameter '{0}' of call signature from exported interface has or is using private name '{1}'."), | |
| Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: diag(4010, ts_DiagnosticCategory.Error, "Type_parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4010", "Type parameter '{0}' of public static method from exported class has or is using private name '{1}'."), | |
| Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: diag(4012, ts_DiagnosticCategory.Error, "Type_parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4012", "Type parameter '{0}' of public method from exported class has or is using private name '{1}'."), | |
| Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: diag(4014, ts_DiagnosticCategory.Error, "Type_parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4014", "Type parameter '{0}' of method from exported interface has or is using private name '{1}'."), | |
| Type_parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4016, ts_DiagnosticCategory.Error, "Type_parameter_0_of_exported_function_has_or_is_using_private_name_1_4016", "Type parameter '{0}' of exported function has or is using private name '{1}'."), | |
| Implements_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4019, ts_DiagnosticCategory.Error, "Implements_clause_of_exported_class_0_has_or_is_using_private_name_1_4019", "Implements clause of exported class '{0}' has or is using private name '{1}'."), | |
| extends_clause_of_exported_class_0_has_or_is_using_private_name_1: diag(4020, ts_DiagnosticCategory.Error, "extends_clause_of_exported_class_0_has_or_is_using_private_name_1_4020", "'extends' clause of exported class '{0}' has or is using private name '{1}'."), | |
| extends_clause_of_exported_interface_0_has_or_is_using_private_name_1: diag(4022, ts_DiagnosticCategory.Error, "extends_clause_of_exported_interface_0_has_or_is_using_private_name_1_4022", "'extends' clause of exported interface '{0}' has or is using private name '{1}'."), | |
| Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4023, ts_DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4023", "Exported variable '{0}' has or is using name '{1}' from external module {2} but cannot be named."), | |
| Exported_variable_0_has_or_is_using_name_1_from_private_module_2: diag(4024, ts_DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_name_1_from_private_module_2_4024", "Exported variable '{0}' has or is using name '{1}' from private module '{2}'."), | |
| Exported_variable_0_has_or_is_using_private_name_1: diag(4025, ts_DiagnosticCategory.Error, "Exported_variable_0_has_or_is_using_private_name_1_4025", "Exported variable '{0}' has or is using private name '{1}'."), | |
| Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4026, ts_DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot__4026", "Public static property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), | |
| Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4027, ts_DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4027", "Public static property '{0}' of exported class has or is using name '{1}' from private module '{2}'."), | |
| Public_static_property_0_of_exported_class_has_or_is_using_private_name_1: diag(4028, ts_DiagnosticCategory.Error, "Public_static_property_0_of_exported_class_has_or_is_using_private_name_1_4028", "Public static property '{0}' of exported class has or is using private name '{1}'."), | |
| Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4029, ts_DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_name_4029", "Public property '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), | |
| Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4030, ts_DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4030", "Public property '{0}' of exported class has or is using name '{1}' from private module '{2}'."), | |
| Public_property_0_of_exported_class_has_or_is_using_private_name_1: diag(4031, ts_DiagnosticCategory.Error, "Public_property_0_of_exported_class_has_or_is_using_private_name_1_4031", "Public property '{0}' of exported class has or is using private name '{1}'."), | |
| Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4032, ts_DiagnosticCategory.Error, "Property_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4032", "Property '{0}' of exported interface has or is using name '{1}' from private module '{2}'."), | |
| Property_0_of_exported_interface_has_or_is_using_private_name_1: diag(4033, ts_DiagnosticCategory.Error, "Property_0_of_exported_interface_has_or_is_using_private_name_1_4033", "Property '{0}' of exported interface has or is using private name '{1}'."), | |
| Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4034, ts_DiagnosticCategory.Error, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_name_1_from_private_mod_4034", "Parameter type of public static setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), | |
| Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1: diag(4035, ts_DiagnosticCategory.Error, "Parameter_type_of_public_static_setter_0_from_exported_class_has_or_is_using_private_name_1_4035", "Parameter type of public static setter '{0}' from exported class has or is using private name '{1}'."), | |
| Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4036, ts_DiagnosticCategory.Error, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4036", "Parameter type of public setter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), | |
| Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1: diag(4037, ts_DiagnosticCategory.Error, "Parameter_type_of_public_setter_0_from_exported_class_has_or_is_using_private_name_1_4037", "Parameter type of public setter '{0}' from exported class has or is using private name '{1}'."), | |
| Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4038, ts_DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_external_modul_4038", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."), | |
| Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4039, ts_DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_4039", "Return type of public static getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), | |
| Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1: diag(4040, ts_DiagnosticCategory.Error, "Return_type_of_public_static_getter_0_from_exported_class_has_or_is_using_private_name_1_4040", "Return type of public static getter '{0}' from exported class has or is using private name '{1}'."), | |
| Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4041, ts_DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_4041", "Return type of public getter '{0}' from exported class has or is using name '{1}' from external module {2} but cannot be named."), | |
| Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4042, ts_DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_name_1_from_private_module_2_4042", "Return type of public getter '{0}' from exported class has or is using name '{1}' from private module '{2}'."), | |
| Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1: diag(4043, ts_DiagnosticCategory.Error, "Return_type_of_public_getter_0_from_exported_class_has_or_is_using_private_name_1_4043", "Return type of public getter '{0}' from exported class has or is using private name '{1}'."), | |
| Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4044, ts_DiagnosticCategory.Error, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_name_0_from_private_mod_4044", "Return type of constructor signature from exported interface has or is using name '{0}' from private module '{1}'."), | |
| Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4045, ts_DiagnosticCategory.Error, "Return_type_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_0_4045", "Return type of constructor signature from exported interface has or is using private name '{0}'."), | |
| Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4046, ts_DiagnosticCategory.Error, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4046", "Return type of call signature from exported interface has or is using name '{0}' from private module '{1}'."), | |
| Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4047, ts_DiagnosticCategory.Error, "Return_type_of_call_signature_from_exported_interface_has_or_is_using_private_name_0_4047", "Return type of call signature from exported interface has or is using private name '{0}'."), | |
| Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4048, ts_DiagnosticCategory.Error, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4048", "Return type of index signature from exported interface has or is using name '{0}' from private module '{1}'."), | |
| Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0: diag(4049, ts_DiagnosticCategory.Error, "Return_type_of_index_signature_from_exported_interface_has_or_is_using_private_name_0_4049", "Return type of index signature from exported interface has or is using private name '{0}'."), | |
| Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4050, ts_DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_external_module__4050", "Return type of public static method from exported class has or is using name '{0}' from external module {1} but cannot be named."), | |
| Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: diag(4051, ts_DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4051", "Return type of public static method from exported class has or is using name '{0}' from private module '{1}'."), | |
| Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0: diag(4052, ts_DiagnosticCategory.Error, "Return_type_of_public_static_method_from_exported_class_has_or_is_using_private_name_0_4052", "Return type of public static method from exported class has or is using private name '{0}'."), | |
| Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4053, ts_DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_external_module_1_but_c_4053", "Return type of public method from exported class has or is using name '{0}' from external module {1} but cannot be named."), | |
| Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1: diag(4054, ts_DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_name_0_from_private_module_1_4054", "Return type of public method from exported class has or is using name '{0}' from private module '{1}'."), | |
| Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0: diag(4055, ts_DiagnosticCategory.Error, "Return_type_of_public_method_from_exported_class_has_or_is_using_private_name_0_4055", "Return type of public method from exported class has or is using private name '{0}'."), | |
| Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1: diag(4056, ts_DiagnosticCategory.Error, "Return_type_of_method_from_exported_interface_has_or_is_using_name_0_from_private_module_1_4056", "Return type of method from exported interface has or is using name '{0}' from private module '{1}'."), | |
| Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0: diag(4057, ts_DiagnosticCategory.Error, "Return_type_of_method_from_exported_interface_has_or_is_using_private_name_0_4057", "Return type of method from exported interface has or is using private name '{0}'."), | |
| Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named: diag(4058, ts_DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_name_0_from_external_module_1_but_cannot_be_named_4058", "Return type of exported function has or is using name '{0}' from external module {1} but cannot be named."), | |
| Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1: diag(4059, ts_DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_name_0_from_private_module_1_4059", "Return type of exported function has or is using name '{0}' from private module '{1}'."), | |
| Return_type_of_exported_function_has_or_is_using_private_name_0: diag(4060, ts_DiagnosticCategory.Error, "Return_type_of_exported_function_has_or_is_using_private_name_0_4060", "Return type of exported function has or is using private name '{0}'."), | |
| Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4061, ts_DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_can_4061", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from external module {2} but cannot be named."), | |
| Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4062, ts_DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_name_1_from_private_module_2_4062", "Parameter '{0}' of constructor from exported class has or is using name '{1}' from private module '{2}'."), | |
| Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1: diag(4063, ts_DiagnosticCategory.Error, "Parameter_0_of_constructor_from_exported_class_has_or_is_using_private_name_1_4063", "Parameter '{0}' of constructor from exported class has or is using private name '{1}'."), | |
| Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4064, ts_DiagnosticCategory.Error, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_name_1_from_private_mod_4064", "Parameter '{0}' of constructor signature from exported interface has or is using name '{1}' from private module '{2}'."), | |
| Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4065, ts_DiagnosticCategory.Error, "Parameter_0_of_constructor_signature_from_exported_interface_has_or_is_using_private_name_1_4065", "Parameter '{0}' of constructor signature from exported interface has or is using private name '{1}'."), | |
| Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4066, ts_DiagnosticCategory.Error, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4066", "Parameter '{0}' of call signature from exported interface has or is using name '{1}' from private module '{2}'."), | |
| Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4067, ts_DiagnosticCategory.Error, "Parameter_0_of_call_signature_from_exported_interface_has_or_is_using_private_name_1_4067", "Parameter '{0}' of call signature from exported interface has or is using private name '{1}'."), | |
| Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4068, ts_DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_external_module__4068", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from external module {2} but cannot be named."), | |
| Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4069, ts_DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4069", "Parameter '{0}' of public static method from exported class has or is using name '{1}' from private module '{2}'."), | |
| Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1: diag(4070, ts_DiagnosticCategory.Error, "Parameter_0_of_public_static_method_from_exported_class_has_or_is_using_private_name_1_4070", "Parameter '{0}' of public static method from exported class has or is using private name '{1}'."), | |
| Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4071, ts_DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_external_module_2_but_c_4071", "Parameter '{0}' of public method from exported class has or is using name '{1}' from external module {2} but cannot be named."), | |
| Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4072, ts_DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_name_1_from_private_module_2_4072", "Parameter '{0}' of public method from exported class has or is using name '{1}' from private module '{2}'."), | |
| Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1: diag(4073, ts_DiagnosticCategory.Error, "Parameter_0_of_public_method_from_exported_class_has_or_is_using_private_name_1_4073", "Parameter '{0}' of public method from exported class has or is using private name '{1}'."), | |
| Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4074, ts_DiagnosticCategory.Error, "Parameter_0_of_method_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4074", "Parameter '{0}' of method from exported interface has or is using name '{1}' from private module '{2}'."), | |
| Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1: diag(4075, ts_DiagnosticCategory.Error, "Parameter_0_of_method_from_exported_interface_has_or_is_using_private_name_1_4075", "Parameter '{0}' of method from exported interface has or is using private name '{1}'."), | |
| Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4076, ts_DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4076", "Parameter '{0}' of exported function has or is using name '{1}' from external module {2} but cannot be named."), | |
| Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2: diag(4077, ts_DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_name_1_from_private_module_2_4077", "Parameter '{0}' of exported function has or is using name '{1}' from private module '{2}'."), | |
| Parameter_0_of_exported_function_has_or_is_using_private_name_1: diag(4078, ts_DiagnosticCategory.Error, "Parameter_0_of_exported_function_has_or_is_using_private_name_1_4078", "Parameter '{0}' of exported function has or is using private name '{1}'."), | |
| Exported_type_alias_0_has_or_is_using_private_name_1: diag(4081, ts_DiagnosticCategory.Error, "Exported_type_alias_0_has_or_is_using_private_name_1_4081", "Exported type alias '{0}' has or is using private name '{1}'."), | |
| Default_export_of_the_module_has_or_is_using_private_name_0: diag(4082, ts_DiagnosticCategory.Error, "Default_export_of_the_module_has_or_is_using_private_name_0_4082", "Default export of the module has or is using private name '{0}'."), | |
| Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1: diag(4083, ts_DiagnosticCategory.Error, "Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1_4083", "Type parameter '{0}' of exported type alias has or is using private name '{1}'."), | |
| Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_library_to_resolve_the_conflict: diag(4090, ts_DiagnosticCategory.Error, "Conflicting_definitions_for_0_found_at_1_and_2_Consider_installing_a_specific_version_of_this_librar_4090", "Conflicting definitions for '{0}' found at '{1}' and '{2}'. Consider installing a specific version of this library to resolve the conflict."), | |
| Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4091, ts_DiagnosticCategory.Error, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_name_1_from_private_module_2_4091", "Parameter '{0}' of index signature from exported interface has or is using name '{1}' from private module '{2}'."), | |
| Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1: diag(4092, ts_DiagnosticCategory.Error, "Parameter_0_of_index_signature_from_exported_interface_has_or_is_using_private_name_1_4092", "Parameter '{0}' of index signature from exported interface has or is using private name '{1}'."), | |
| Property_0_of_exported_class_expression_may_not_be_private_or_protected: diag(4094, ts_DiagnosticCategory.Error, "Property_0_of_exported_class_expression_may_not_be_private_or_protected_4094", "Property '{0}' of exported class expression may not be private or protected."), | |
| Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4095, ts_DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_4095", "Public static method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), | |
| Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4096, ts_DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4096", "Public static method '{0}' of exported class has or is using name '{1}' from private module '{2}'."), | |
| Public_static_method_0_of_exported_class_has_or_is_using_private_name_1: diag(4097, ts_DiagnosticCategory.Error, "Public_static_method_0_of_exported_class_has_or_is_using_private_name_1_4097", "Public static method '{0}' of exported class has or is using private name '{1}'."), | |
| Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4098, ts_DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4098", "Public method '{0}' of exported class has or is using name '{1}' from external module {2} but cannot be named."), | |
| Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2: diag(4099, ts_DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_name_1_from_private_module_2_4099", "Public method '{0}' of exported class has or is using name '{1}' from private module '{2}'."), | |
| Public_method_0_of_exported_class_has_or_is_using_private_name_1: diag(4100, ts_DiagnosticCategory.Error, "Public_method_0_of_exported_class_has_or_is_using_private_name_1_4100", "Public method '{0}' of exported class has or is using private name '{1}'."), | |
| Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2: diag(4101, ts_DiagnosticCategory.Error, "Method_0_of_exported_interface_has_or_is_using_name_1_from_private_module_2_4101", "Method '{0}' of exported interface has or is using name '{1}' from private module '{2}'."), | |
| Method_0_of_exported_interface_has_or_is_using_private_name_1: diag(4102, ts_DiagnosticCategory.Error, "Method_0_of_exported_interface_has_or_is_using_private_name_1_4102", "Method '{0}' of exported interface has or is using private name '{1}'."), | |
| Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1: diag(4103, ts_DiagnosticCategory.Error, "Type_parameter_0_of_exported_mapped_object_type_is_using_private_name_1_4103", "Type parameter '{0}' of exported mapped object type is using private name '{1}'."), | |
| The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1: diag(4104, ts_DiagnosticCategory.Error, "The_type_0_is_readonly_and_cannot_be_assigned_to_the_mutable_type_1_4104", "The type '{0}' is 'readonly' and cannot be assigned to the mutable type '{1}'."), | |
| Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter: diag(4105, ts_DiagnosticCategory.Error, "Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter_4105", "Private or protected member '{0}' cannot be accessed on a type parameter."), | |
| Parameter_0_of_accessor_has_or_is_using_private_name_1: diag(4106, ts_DiagnosticCategory.Error, "Parameter_0_of_accessor_has_or_is_using_private_name_1_4106", "Parameter '{0}' of accessor has or is using private name '{1}'."), | |
| Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2: diag(4107, ts_DiagnosticCategory.Error, "Parameter_0_of_accessor_has_or_is_using_name_1_from_private_module_2_4107", "Parameter '{0}' of accessor has or is using name '{1}' from private module '{2}'."), | |
| Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named: diag(4108, ts_DiagnosticCategory.Error, "Parameter_0_of_accessor_has_or_is_using_name_1_from_external_module_2_but_cannot_be_named_4108", "Parameter '{0}' of accessor has or is using name '{1}' from external module '{2}' but cannot be named."), | |
| Type_arguments_for_0_circularly_reference_themselves: diag(4109, ts_DiagnosticCategory.Error, "Type_arguments_for_0_circularly_reference_themselves_4109", "Type arguments for '{0}' circularly reference themselves."), | |
| Tuple_type_arguments_circularly_reference_themselves: diag(4110, ts_DiagnosticCategory.Error, "Tuple_type_arguments_circularly_reference_themselves_4110", "Tuple type arguments circularly reference themselves."), | |
| The_current_host_does_not_support_the_0_option: diag(5001, ts_DiagnosticCategory.Error, "The_current_host_does_not_support_the_0_option_5001", "The current host does not support the '{0}' option."), | |
| Cannot_find_the_common_subdirectory_path_for_the_input_files: diag(5009, ts_DiagnosticCategory.Error, "Cannot_find_the_common_subdirectory_path_for_the_input_files_5009", "Cannot find the common subdirectory path for the input files."), | |
| File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5010, ts_DiagnosticCategory.Error, "File_specification_cannot_end_in_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0_5010", "File specification cannot end in a recursive directory wildcard ('**'): '{0}'."), | |
| Cannot_read_file_0_Colon_1: diag(5012, ts_DiagnosticCategory.Error, "Cannot_read_file_0_Colon_1_5012", "Cannot read file '{0}': {1}."), | |
| Failed_to_parse_file_0_Colon_1: diag(5014, ts_DiagnosticCategory.Error, "Failed_to_parse_file_0_Colon_1_5014", "Failed to parse file '{0}': {1}."), | |
| Unknown_compiler_option_0: diag(5023, ts_DiagnosticCategory.Error, "Unknown_compiler_option_0_5023", "Unknown compiler option '{0}'."), | |
| Compiler_option_0_requires_a_value_of_type_1: diag(5024, ts_DiagnosticCategory.Error, "Compiler_option_0_requires_a_value_of_type_1_5024", "Compiler option '{0}' requires a value of type {1}."), | |
| Unknown_compiler_option_0_Did_you_mean_1: diag(5025, ts_DiagnosticCategory.Error, "Unknown_compiler_option_0_Did_you_mean_1_5025", "Unknown compiler option '{0}'. Did you mean '{1}'?"), | |
| Could_not_write_file_0_Colon_1: diag(5033, ts_DiagnosticCategory.Error, "Could_not_write_file_0_Colon_1_5033", "Could not write file '{0}': {1}."), | |
| Option_project_cannot_be_mixed_with_source_files_on_a_command_line: diag(5042, ts_DiagnosticCategory.Error, "Option_project_cannot_be_mixed_with_source_files_on_a_command_line_5042", "Option 'project' cannot be mixed with source files on a command line."), | |
| Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES2015_or_higher: diag(5047, ts_DiagnosticCategory.Error, "Option_isolatedModules_can_only_be_used_when_either_option_module_is_provided_or_option_target_is_ES_5047", "Option 'isolatedModules' can only be used when either option '--module' is provided or option 'target' is 'ES2015' or higher."), | |
| Option_0_cannot_be_specified_when_option_target_is_ES3: diag(5048, ts_DiagnosticCategory.Error, "Option_0_cannot_be_specified_when_option_target_is_ES3_5048", "Option '{0}' cannot be specified when option 'target' is 'ES3'."), | |
| Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided: diag(5051, ts_DiagnosticCategory.Error, "Option_0_can_only_be_used_when_either_option_inlineSourceMap_or_option_sourceMap_is_provided_5051", "Option '{0} can only be used when either option '--inlineSourceMap' or option '--sourceMap' is provided."), | |
| Option_0_cannot_be_specified_without_specifying_option_1: diag(5052, ts_DiagnosticCategory.Error, "Option_0_cannot_be_specified_without_specifying_option_1_5052", "Option '{0}' cannot be specified without specifying option '{1}'."), | |
| Option_0_cannot_be_specified_with_option_1: diag(5053, ts_DiagnosticCategory.Error, "Option_0_cannot_be_specified_with_option_1_5053", "Option '{0}' cannot be specified with option '{1}'."), | |
| A_tsconfig_json_file_is_already_defined_at_Colon_0: diag(5054, ts_DiagnosticCategory.Error, "A_tsconfig_json_file_is_already_defined_at_Colon_0_5054", "A 'tsconfig.json' file is already defined at: '{0}'."), | |
| Cannot_write_file_0_because_it_would_overwrite_input_file: diag(5055, ts_DiagnosticCategory.Error, "Cannot_write_file_0_because_it_would_overwrite_input_file_5055", "Cannot write file '{0}' because it would overwrite input file."), | |
| Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files: diag(5056, ts_DiagnosticCategory.Error, "Cannot_write_file_0_because_it_would_be_overwritten_by_multiple_input_files_5056", "Cannot write file '{0}' because it would be overwritten by multiple input files."), | |
| Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0: diag(5057, ts_DiagnosticCategory.Error, "Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0_5057", "Cannot find a tsconfig.json file at the specified directory: '{0}'."), | |
| The_specified_path_does_not_exist_Colon_0: diag(5058, ts_DiagnosticCategory.Error, "The_specified_path_does_not_exist_Colon_0_5058", "The specified path does not exist: '{0}'."), | |
| Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier: diag(5059, ts_DiagnosticCategory.Error, "Invalid_value_for_reactNamespace_0_is_not_a_valid_identifier_5059", "Invalid value for '--reactNamespace'. '{0}' is not a valid identifier."), | |
| Option_paths_cannot_be_used_without_specifying_baseUrl_option: diag(5060, ts_DiagnosticCategory.Error, "Option_paths_cannot_be_used_without_specifying_baseUrl_option_5060", "Option 'paths' cannot be used without specifying '--baseUrl' option."), | |
| Pattern_0_can_have_at_most_one_Asterisk_character: diag(5061, ts_DiagnosticCategory.Error, "Pattern_0_can_have_at_most_one_Asterisk_character_5061", "Pattern '{0}' can have at most one '*' character."), | |
| Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character: diag(5062, ts_DiagnosticCategory.Error, "Substitution_0_in_pattern_1_can_have_at_most_one_Asterisk_character_5062", "Substitution '{0}' in pattern '{1}' can have at most one '*' character."), | |
| Substitutions_for_pattern_0_should_be_an_array: diag(5063, ts_DiagnosticCategory.Error, "Substitutions_for_pattern_0_should_be_an_array_5063", "Substitutions for pattern '{0}' should be an array."), | |
| Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2: diag(5064, ts_DiagnosticCategory.Error, "Substitution_0_for_pattern_1_has_incorrect_type_expected_string_got_2_5064", "Substitution '{0}' for pattern '{1}' has incorrect type, expected 'string', got '{2}'."), | |
| File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildcard_Asterisk_Asterisk_Colon_0: diag(5065, ts_DiagnosticCategory.Error, "File_specification_cannot_contain_a_parent_directory_that_appears_after_a_recursive_directory_wildca_5065", "File specification cannot contain a parent directory ('..') that appears after a recursive directory wildcard ('**'): '{0}'."), | |
| Substitutions_for_pattern_0_shouldn_t_be_an_empty_array: diag(5066, ts_DiagnosticCategory.Error, "Substitutions_for_pattern_0_shouldn_t_be_an_empty_array_5066", "Substitutions for pattern '{0}' shouldn't be an empty array."), | |
| Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name: diag(5067, ts_DiagnosticCategory.Error, "Invalid_value_for_jsxFactory_0_is_not_a_valid_identifier_or_qualified_name_5067", "Invalid value for 'jsxFactory'. '{0}' is not a valid identifier or qualified-name."), | |
| Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript_files_Learn_more_at_https_Colon_Slash_Slashaka_ms_Slashtsconfig: diag(5068, ts_DiagnosticCategory.Error, "Adding_a_tsconfig_json_file_will_help_organize_projects_that_contain_both_TypeScript_and_JavaScript__5068", "Adding a tsconfig.json file will help organize projects that contain both TypeScript and JavaScript files. Learn more at https://aka.ms/tsconfig."), | |
| Option_0_cannot_be_specified_without_specifying_option_1_or_option_2: diag(5069, ts_DiagnosticCategory.Error, "Option_0_cannot_be_specified_without_specifying_option_1_or_option_2_5069", "Option '{0}' cannot be specified without specifying option '{1}' or option '{2}'."), | |
| Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy: diag(5070, ts_DiagnosticCategory.Error, "Option_resolveJsonModule_cannot_be_specified_without_node_module_resolution_strategy_5070", "Option '--resolveJsonModule' cannot be specified without 'node' module resolution strategy."), | |
| Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_esNext: diag(5071, ts_DiagnosticCategory.Error, "Option_resolveJsonModule_can_only_be_specified_when_module_code_generation_is_commonjs_amd_es2015_or_5071", "Option '--resolveJsonModule' can only be specified when module code generation is 'commonjs', 'amd', 'es2015' or 'esNext'."), | |
| Unknown_build_option_0: diag(5072, ts_DiagnosticCategory.Error, "Unknown_build_option_0_5072", "Unknown build option '{0}'."), | |
| Build_option_0_requires_a_value_of_type_1: diag(5073, ts_DiagnosticCategory.Error, "Build_option_0_requires_a_value_of_type_1_5073", "Build option '{0}' requires a value of type {1}."), | |
| Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBuildInfoFile_is_specified: diag(5074, ts_DiagnosticCategory.Error, "Option_incremental_can_only_be_specified_using_tsconfig_emitting_to_single_file_or_when_option_tsBui_5074", "Option '--incremental' can only be specified using tsconfig, emitting to single file or when option `--tsBuildInfoFile` is specified."), | |
| _0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_constraint_2: diag(5075, ts_DiagnosticCategory.Error, "_0_is_assignable_to_the_constraint_of_type_1_but_1_could_be_instantiated_with_a_different_subtype_of_5075", "'{0}' is assignable to the constraint of type '{1}', but '{1}' could be instantiated with a different subtype of constraint '{2}'."), | |
| _0_and_1_operations_cannot_be_mixed_without_parentheses: diag(5076, ts_DiagnosticCategory.Error, "_0_and_1_operations_cannot_be_mixed_without_parentheses_5076", "'{0}' and '{1}' operations cannot be mixed without parentheses."), | |
| Unknown_build_option_0_Did_you_mean_1: diag(5077, ts_DiagnosticCategory.Error, "Unknown_build_option_0_Did_you_mean_1_5077", "Unknown build option '{0}'. Did you mean '{1}'?"), | |
| Unknown_watch_option_0: diag(5078, ts_DiagnosticCategory.Error, "Unknown_watch_option_0_5078", "Unknown watch option '{0}'."), | |
| Unknown_watch_option_0_Did_you_mean_1: diag(5079, ts_DiagnosticCategory.Error, "Unknown_watch_option_0_Did_you_mean_1_5079", "Unknown watch option '{0}'. Did you mean '{1}'?"), | |
| Watch_option_0_requires_a_value_of_type_1: diag(5080, ts_DiagnosticCategory.Error, "Watch_option_0_requires_a_value_of_type_1_5080", "Watch option '{0}' requires a value of type {1}."), | |
| Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0: diag(5081, ts_DiagnosticCategory.Error, "Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0_5081", "Cannot find a tsconfig.json file at the current directory: {0}."), | |
| Generates_a_sourcemap_for_each_corresponding_d_ts_file: diag(6000, ts_DiagnosticCategory.Message, "Generates_a_sourcemap_for_each_corresponding_d_ts_file_6000", "Generates a sourcemap for each corresponding '.d.ts' file."), | |
| Concatenate_and_emit_output_to_single_file: diag(6001, ts_DiagnosticCategory.Message, "Concatenate_and_emit_output_to_single_file_6001", "Concatenate and emit output to single file."), | |
| Generates_corresponding_d_ts_file: diag(6002, ts_DiagnosticCategory.Message, "Generates_corresponding_d_ts_file_6002", "Generates corresponding '.d.ts' file."), | |
| Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations: diag(6003, ts_DiagnosticCategory.Message, "Specify_the_location_where_debugger_should_locate_map_files_instead_of_generated_locations_6003", "Specify the location where debugger should locate map files instead of generated locations."), | |
| Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations: diag(6004, ts_DiagnosticCategory.Message, "Specify_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations_6004", "Specify the location where debugger should locate TypeScript files instead of source locations."), | |
| Watch_input_files: diag(6005, ts_DiagnosticCategory.Message, "Watch_input_files_6005", "Watch input files."), | |
| Redirect_output_structure_to_the_directory: diag(6006, ts_DiagnosticCategory.Message, "Redirect_output_structure_to_the_directory_6006", "Redirect output structure to the directory."), | |
| Do_not_erase_const_enum_declarations_in_generated_code: diag(6007, ts_DiagnosticCategory.Message, "Do_not_erase_const_enum_declarations_in_generated_code_6007", "Do not erase const enum declarations in generated code."), | |
| Do_not_emit_outputs_if_any_errors_were_reported: diag(6008, ts_DiagnosticCategory.Message, "Do_not_emit_outputs_if_any_errors_were_reported_6008", "Do not emit outputs if any errors were reported."), | |
| Do_not_emit_comments_to_output: diag(6009, ts_DiagnosticCategory.Message, "Do_not_emit_comments_to_output_6009", "Do not emit comments to output."), | |
| Do_not_emit_outputs: diag(6010, ts_DiagnosticCategory.Message, "Do_not_emit_outputs_6010", "Do not emit outputs."), | |
| Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typechecking: diag(6011, ts_DiagnosticCategory.Message, "Allow_default_imports_from_modules_with_no_default_export_This_does_not_affect_code_emit_just_typech_6011", "Allow default imports from modules with no default export. This does not affect code emit, just typechecking."), | |
| Skip_type_checking_of_declaration_files: diag(6012, ts_DiagnosticCategory.Message, "Skip_type_checking_of_declaration_files_6012", "Skip type checking of declaration files."), | |
| Do_not_resolve_the_real_path_of_symlinks: diag(6013, ts_DiagnosticCategory.Message, "Do_not_resolve_the_real_path_of_symlinks_6013", "Do not resolve the real path of symlinks."), | |
| Only_emit_d_ts_declaration_files: diag(6014, ts_DiagnosticCategory.Message, "Only_emit_d_ts_declaration_files_6014", "Only emit '.d.ts' declaration files."), | |
| Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_ES2020_or_ESNEXT: diag(6015, ts_DiagnosticCategory.Message, "Specify_ECMAScript_target_version_Colon_ES3_default_ES5_ES2015_ES2016_ES2017_ES2018_ES2019_ES2020_or_6015", "Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019', 'ES2020', or 'ESNEXT'."), | |
| Specify_module_code_generation_Colon_none_commonjs_amd_system_umd_es2015_es2020_or_ESNext: diag(6016, ts_DiagnosticCategory.Message, "Specify_module_code_generation_Colon_none_commonjs_amd_system_umd_es2015_es2020_or_ESNext_6016", "Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', 'es2020', or 'ESNext'."), | |
| Print_this_message: diag(6017, ts_DiagnosticCategory.Message, "Print_this_message_6017", "Print this message."), | |
| Print_the_compiler_s_version: diag(6019, ts_DiagnosticCategory.Message, "Print_the_compiler_s_version_6019", "Print the compiler's version."), | |
| Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json: diag(6020, ts_DiagnosticCategory.Message, "Compile_the_project_given_the_path_to_its_configuration_file_or_to_a_folder_with_a_tsconfig_json_6020", "Compile the project given the path to its configuration file, or to a folder with a 'tsconfig.json'."), | |
| Syntax_Colon_0: diag(6023, ts_DiagnosticCategory.Message, "Syntax_Colon_0_6023", "Syntax: {0}"), | |
| options: diag(6024, ts_DiagnosticCategory.Message, "options_6024", "options"), | |
| file: diag(6025, ts_DiagnosticCategory.Message, "file_6025", "file"), | |
| Examples_Colon_0: diag(6026, ts_DiagnosticCategory.Message, "Examples_Colon_0_6026", "Examples: {0}"), | |
| Options_Colon: diag(6027, ts_DiagnosticCategory.Message, "Options_Colon_6027", "Options:"), | |
| Version_0: diag(6029, ts_DiagnosticCategory.Message, "Version_0_6029", "Version {0}"), | |
| Insert_command_line_options_and_files_from_a_file: diag(6030, ts_DiagnosticCategory.Message, "Insert_command_line_options_and_files_from_a_file_6030", "Insert command line options and files from a file."), | |
| Starting_compilation_in_watch_mode: diag(6031, ts_DiagnosticCategory.Message, "Starting_compilation_in_watch_mode_6031", "Starting compilation in watch mode..."), | |
| File_change_detected_Starting_incremental_compilation: diag(6032, ts_DiagnosticCategory.Message, "File_change_detected_Starting_incremental_compilation_6032", "File change detected. Starting incremental compilation..."), | |
| KIND: diag(6034, ts_DiagnosticCategory.Message, "KIND_6034", "KIND"), | |
| FILE: diag(6035, ts_DiagnosticCategory.Message, "FILE_6035", "FILE"), | |
| VERSION: diag(6036, ts_DiagnosticCategory.Message, "VERSION_6036", "VERSION"), | |
| LOCATION: diag(6037, ts_DiagnosticCategory.Message, "LOCATION_6037", "LOCATION"), | |
| DIRECTORY: diag(6038, ts_DiagnosticCategory.Message, "DIRECTORY_6038", "DIRECTORY"), | |
| STRATEGY: diag(6039, ts_DiagnosticCategory.Message, "STRATEGY_6039", "STRATEGY"), | |
| FILE_OR_DIRECTORY: diag(6040, ts_DiagnosticCategory.Message, "FILE_OR_DIRECTORY_6040", "FILE OR DIRECTORY"), | |
| Generates_corresponding_map_file: diag(6043, ts_DiagnosticCategory.Message, "Generates_corresponding_map_file_6043", "Generates corresponding '.map' file."), | |
| Compiler_option_0_expects_an_argument: diag(6044, ts_DiagnosticCategory.Error, "Compiler_option_0_expects_an_argument_6044", "Compiler option '{0}' expects an argument."), | |
| Unterminated_quoted_string_in_response_file_0: diag(6045, ts_DiagnosticCategory.Error, "Unterminated_quoted_string_in_response_file_0_6045", "Unterminated quoted string in response file '{0}'."), | |
| Argument_for_0_option_must_be_Colon_1: diag(6046, ts_DiagnosticCategory.Error, "Argument_for_0_option_must_be_Colon_1_6046", "Argument for '{0}' option must be: {1}."), | |
| Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1: diag(6048, ts_DiagnosticCategory.Error, "Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1_6048", "Locale must be of the form <language> or <language>-<territory>. For example '{0}' or '{1}'."), | |
| Unsupported_locale_0: diag(6049, ts_DiagnosticCategory.Error, "Unsupported_locale_0_6049", "Unsupported locale '{0}'."), | |
| Unable_to_open_file_0: diag(6050, ts_DiagnosticCategory.Error, "Unable_to_open_file_0_6050", "Unable to open file '{0}'."), | |
| Corrupted_locale_file_0: diag(6051, ts_DiagnosticCategory.Error, "Corrupted_locale_file_0_6051", "Corrupted locale file {0}."), | |
| Raise_error_on_expressions_and_declarations_with_an_implied_any_type: diag(6052, ts_DiagnosticCategory.Message, "Raise_error_on_expressions_and_declarations_with_an_implied_any_type_6052", "Raise error on expressions and declarations with an implied 'any' type."), | |
| File_0_not_found: diag(6053, ts_DiagnosticCategory.Error, "File_0_not_found_6053", "File '{0}' not found."), | |
| File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1: diag(6054, ts_DiagnosticCategory.Error, "File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1_6054", "File '{0}' has an unsupported extension. The only supported extensions are {1}."), | |
| Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: diag(6055, ts_DiagnosticCategory.Message, "Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures_6055", "Suppress noImplicitAny errors for indexing objects lacking index signatures."), | |
| Do_not_emit_declarations_for_code_that_has_an_internal_annotation: diag(6056, ts_DiagnosticCategory.Message, "Do_not_emit_declarations_for_code_that_has_an_internal_annotation_6056", "Do not emit declarations for code that has an '@internal' annotation."), | |
| Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir: diag(6058, ts_DiagnosticCategory.Message, "Specify_the_root_directory_of_input_files_Use_to_control_the_output_directory_structure_with_outDir_6058", "Specify the root directory of input files. Use to control the output directory structure with --outDir."), | |
| File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files: diag(6059, ts_DiagnosticCategory.Error, "File_0_is_not_under_rootDir_1_rootDir_is_expected_to_contain_all_source_files_6059", "File '{0}' is not under 'rootDir' '{1}'. 'rootDir' is expected to contain all source files."), | |
| Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix: diag(6060, ts_DiagnosticCategory.Message, "Specify_the_end_of_line_sequence_to_be_used_when_emitting_files_Colon_CRLF_dos_or_LF_unix_6060", "Specify the end of line sequence to be used when emitting files: 'CRLF' (dos) or 'LF' (unix)."), | |
| NEWLINE: diag(6061, ts_DiagnosticCategory.Message, "NEWLINE_6061", "NEWLINE"), | |
| Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line: diag(6064, ts_DiagnosticCategory.Error, "Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_null_on_command_line_6064", "Option '{0}' can only be specified in 'tsconfig.json' file or set to 'null' on command line."), | |
| Enables_experimental_support_for_ES7_decorators: diag(6065, ts_DiagnosticCategory.Message, "Enables_experimental_support_for_ES7_decorators_6065", "Enables experimental support for ES7 decorators."), | |
| Enables_experimental_support_for_emitting_type_metadata_for_decorators: diag(6066, ts_DiagnosticCategory.Message, "Enables_experimental_support_for_emitting_type_metadata_for_decorators_6066", "Enables experimental support for emitting type metadata for decorators."), | |
| Enables_experimental_support_for_ES7_async_functions: diag(6068, ts_DiagnosticCategory.Message, "Enables_experimental_support_for_ES7_async_functions_6068", "Enables experimental support for ES7 async functions."), | |
| Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6: diag(6069, ts_DiagnosticCategory.Message, "Specify_module_resolution_strategy_Colon_node_Node_js_or_classic_TypeScript_pre_1_6_6069", "Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6)."), | |
| Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file: diag(6070, ts_DiagnosticCategory.Message, "Initializes_a_TypeScript_project_and_creates_a_tsconfig_json_file_6070", "Initializes a TypeScript project and creates a tsconfig.json file."), | |
| Successfully_created_a_tsconfig_json_file: diag(6071, ts_DiagnosticCategory.Message, "Successfully_created_a_tsconfig_json_file_6071", "Successfully created a tsconfig.json file."), | |
| Suppress_excess_property_checks_for_object_literals: diag(6072, ts_DiagnosticCategory.Message, "Suppress_excess_property_checks_for_object_literals_6072", "Suppress excess property checks for object literals."), | |
| Stylize_errors_and_messages_using_color_and_context_experimental: diag(6073, ts_DiagnosticCategory.Message, "Stylize_errors_and_messages_using_color_and_context_experimental_6073", "Stylize errors and messages using color and context (experimental)."), | |
| Do_not_report_errors_on_unused_labels: diag(6074, ts_DiagnosticCategory.Message, "Do_not_report_errors_on_unused_labels_6074", "Do not report errors on unused labels."), | |
| Report_error_when_not_all_code_paths_in_function_return_a_value: diag(6075, ts_DiagnosticCategory.Message, "Report_error_when_not_all_code_paths_in_function_return_a_value_6075", "Report error when not all code paths in function return a value."), | |
| Report_errors_for_fallthrough_cases_in_switch_statement: diag(6076, ts_DiagnosticCategory.Message, "Report_errors_for_fallthrough_cases_in_switch_statement_6076", "Report errors for fallthrough cases in switch statement."), | |
| Do_not_report_errors_on_unreachable_code: diag(6077, ts_DiagnosticCategory.Message, "Do_not_report_errors_on_unreachable_code_6077", "Do not report errors on unreachable code."), | |
| Disallow_inconsistently_cased_references_to_the_same_file: diag(6078, ts_DiagnosticCategory.Message, "Disallow_inconsistently_cased_references_to_the_same_file_6078", "Disallow inconsistently-cased references to the same file."), | |
| Specify_library_files_to_be_included_in_the_compilation: diag(6079, ts_DiagnosticCategory.Message, "Specify_library_files_to_be_included_in_the_compilation_6079", "Specify library files to be included in the compilation."), | |
| Specify_JSX_code_generation_Colon_preserve_react_native_or_react: diag(6080, ts_DiagnosticCategory.Message, "Specify_JSX_code_generation_Colon_preserve_react_native_or_react_6080", "Specify JSX code generation: 'preserve', 'react-native', or 'react'."), | |
| File_0_has_an_unsupported_extension_so_skipping_it: diag(6081, ts_DiagnosticCategory.Message, "File_0_has_an_unsupported_extension_so_skipping_it_6081", "File '{0}' has an unsupported extension, so skipping it."), | |
| Only_amd_and_system_modules_are_supported_alongside_0: diag(6082, ts_DiagnosticCategory.Error, "Only_amd_and_system_modules_are_supported_alongside_0_6082", "Only 'amd' and 'system' modules are supported alongside --{0}."), | |
| Base_directory_to_resolve_non_absolute_module_names: diag(6083, ts_DiagnosticCategory.Message, "Base_directory_to_resolve_non_absolute_module_names_6083", "Base directory to resolve non-absolute module names."), | |
| Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react_JSX_emit: diag(6084, ts_DiagnosticCategory.Message, "Deprecated_Use_jsxFactory_instead_Specify_the_object_invoked_for_createElement_when_targeting_react__6084", "[Deprecated] Use '--jsxFactory' instead. Specify the object invoked for createElement when targeting 'react' JSX emit"), | |
| Enable_tracing_of_the_name_resolution_process: diag(6085, ts_DiagnosticCategory.Message, "Enable_tracing_of_the_name_resolution_process_6085", "Enable tracing of the name resolution process."), | |
| Resolving_module_0_from_1: diag(6086, ts_DiagnosticCategory.Message, "Resolving_module_0_from_1_6086", "======== Resolving module '{0}' from '{1}'. ========"), | |
| Explicitly_specified_module_resolution_kind_Colon_0: diag(6087, ts_DiagnosticCategory.Message, "Explicitly_specified_module_resolution_kind_Colon_0_6087", "Explicitly specified module resolution kind: '{0}'."), | |
| Module_resolution_kind_is_not_specified_using_0: diag(6088, ts_DiagnosticCategory.Message, "Module_resolution_kind_is_not_specified_using_0_6088", "Module resolution kind is not specified, using '{0}'."), | |
| Module_name_0_was_successfully_resolved_to_1: diag(6089, ts_DiagnosticCategory.Message, "Module_name_0_was_successfully_resolved_to_1_6089", "======== Module name '{0}' was successfully resolved to '{1}'. ========"), | |
| Module_name_0_was_not_resolved: diag(6090, ts_DiagnosticCategory.Message, "Module_name_0_was_not_resolved_6090", "======== Module name '{0}' was not resolved. ========"), | |
| paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0: diag(6091, ts_DiagnosticCategory.Message, "paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0_6091", "'paths' option is specified, looking for a pattern to match module name '{0}'."), | |
| Module_name_0_matched_pattern_1: diag(6092, ts_DiagnosticCategory.Message, "Module_name_0_matched_pattern_1_6092", "Module name '{0}', matched pattern '{1}'."), | |
| Trying_substitution_0_candidate_module_location_Colon_1: diag(6093, ts_DiagnosticCategory.Message, "Trying_substitution_0_candidate_module_location_Colon_1_6093", "Trying substitution '{0}', candidate module location: '{1}'."), | |
| Resolving_module_name_0_relative_to_base_url_1_2: diag(6094, ts_DiagnosticCategory.Message, "Resolving_module_name_0_relative_to_base_url_1_2_6094", "Resolving module name '{0}' relative to base url '{1}' - '{2}'."), | |
| Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1: diag(6095, ts_DiagnosticCategory.Message, "Loading_module_as_file_Slash_folder_candidate_module_location_0_target_file_type_1_6095", "Loading module as file / folder, candidate module location '{0}', target file type '{1}'."), | |
| File_0_does_not_exist: diag(6096, ts_DiagnosticCategory.Message, "File_0_does_not_exist_6096", "File '{0}' does not exist."), | |
| File_0_exist_use_it_as_a_name_resolution_result: diag(6097, ts_DiagnosticCategory.Message, "File_0_exist_use_it_as_a_name_resolution_result_6097", "File '{0}' exist - use it as a name resolution result."), | |
| Loading_module_0_from_node_modules_folder_target_file_type_1: diag(6098, ts_DiagnosticCategory.Message, "Loading_module_0_from_node_modules_folder_target_file_type_1_6098", "Loading module '{0}' from 'node_modules' folder, target file type '{1}'."), | |
| Found_package_json_at_0: diag(6099, ts_DiagnosticCategory.Message, "Found_package_json_at_0_6099", "Found 'package.json' at '{0}'."), | |
| package_json_does_not_have_a_0_field: diag(6100, ts_DiagnosticCategory.Message, "package_json_does_not_have_a_0_field_6100", "'package.json' does not have a '{0}' field."), | |
| package_json_has_0_field_1_that_references_2: diag(6101, ts_DiagnosticCategory.Message, "package_json_has_0_field_1_that_references_2_6101", "'package.json' has '{0}' field '{1}' that references '{2}'."), | |
| Allow_javascript_files_to_be_compiled: diag(6102, ts_DiagnosticCategory.Message, "Allow_javascript_files_to_be_compiled_6102", "Allow javascript files to be compiled."), | |
| Option_0_should_have_array_of_strings_as_a_value: diag(6103, ts_DiagnosticCategory.Error, "Option_0_should_have_array_of_strings_as_a_value_6103", "Option '{0}' should have array of strings as a value."), | |
| Checking_if_0_is_the_longest_matching_prefix_for_1_2: diag(6104, ts_DiagnosticCategory.Message, "Checking_if_0_is_the_longest_matching_prefix_for_1_2_6104", "Checking if '{0}' is the longest matching prefix for '{1}' - '{2}'."), | |
| Expected_type_of_0_field_in_package_json_to_be_1_got_2: diag(6105, ts_DiagnosticCategory.Message, "Expected_type_of_0_field_in_package_json_to_be_1_got_2_6105", "Expected type of '{0}' field in 'package.json' to be '{1}', got '{2}'."), | |
| baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1: diag(6106, ts_DiagnosticCategory.Message, "baseUrl_option_is_set_to_0_using_this_value_to_resolve_non_relative_module_name_1_6106", "'baseUrl' option is set to '{0}', using this value to resolve non-relative module name '{1}'."), | |
| rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0: diag(6107, ts_DiagnosticCategory.Message, "rootDirs_option_is_set_using_it_to_resolve_relative_module_name_0_6107", "'rootDirs' option is set, using it to resolve relative module name '{0}'."), | |
| Longest_matching_prefix_for_0_is_1: diag(6108, ts_DiagnosticCategory.Message, "Longest_matching_prefix_for_0_is_1_6108", "Longest matching prefix for '{0}' is '{1}'."), | |
| Loading_0_from_the_root_dir_1_candidate_location_2: diag(6109, ts_DiagnosticCategory.Message, "Loading_0_from_the_root_dir_1_candidate_location_2_6109", "Loading '{0}' from the root dir '{1}', candidate location '{2}'."), | |
| Trying_other_entries_in_rootDirs: diag(6110, ts_DiagnosticCategory.Message, "Trying_other_entries_in_rootDirs_6110", "Trying other entries in 'rootDirs'."), | |
| Module_resolution_using_rootDirs_has_failed: diag(6111, ts_DiagnosticCategory.Message, "Module_resolution_using_rootDirs_has_failed_6111", "Module resolution using 'rootDirs' has failed."), | |
| Do_not_emit_use_strict_directives_in_module_output: diag(6112, ts_DiagnosticCategory.Message, "Do_not_emit_use_strict_directives_in_module_output_6112", "Do not emit 'use strict' directives in module output."), | |
| Enable_strict_null_checks: diag(6113, ts_DiagnosticCategory.Message, "Enable_strict_null_checks_6113", "Enable strict null checks."), | |
| Unknown_option_excludes_Did_you_mean_exclude: diag(6114, ts_DiagnosticCategory.Error, "Unknown_option_excludes_Did_you_mean_exclude_6114", "Unknown option 'excludes'. Did you mean 'exclude'?"), | |
| Raise_error_on_this_expressions_with_an_implied_any_type: diag(6115, ts_DiagnosticCategory.Message, "Raise_error_on_this_expressions_with_an_implied_any_type_6115", "Raise error on 'this' expressions with an implied 'any' type."), | |
| Resolving_type_reference_directive_0_containing_file_1_root_directory_2: diag(6116, ts_DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_1_root_directory_2_6116", "======== Resolving type reference directive '{0}', containing file '{1}', root directory '{2}'. ========"), | |
| Resolving_using_primary_search_paths: diag(6117, ts_DiagnosticCategory.Message, "Resolving_using_primary_search_paths_6117", "Resolving using primary search paths..."), | |
| Resolving_from_node_modules_folder: diag(6118, ts_DiagnosticCategory.Message, "Resolving_from_node_modules_folder_6118", "Resolving from node_modules folder..."), | |
| Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2: diag(6119, ts_DiagnosticCategory.Message, "Type_reference_directive_0_was_successfully_resolved_to_1_primary_Colon_2_6119", "======== Type reference directive '{0}' was successfully resolved to '{1}', primary: {2}. ========"), | |
| Type_reference_directive_0_was_not_resolved: diag(6120, ts_DiagnosticCategory.Message, "Type_reference_directive_0_was_not_resolved_6120", "======== Type reference directive '{0}' was not resolved. ========"), | |
| Resolving_with_primary_search_path_0: diag(6121, ts_DiagnosticCategory.Message, "Resolving_with_primary_search_path_0_6121", "Resolving with primary search path '{0}'."), | |
| Root_directory_cannot_be_determined_skipping_primary_search_paths: diag(6122, ts_DiagnosticCategory.Message, "Root_directory_cannot_be_determined_skipping_primary_search_paths_6122", "Root directory cannot be determined, skipping primary search paths."), | |
| Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set: diag(6123, ts_DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_1_root_directory_not_set_6123", "======== Resolving type reference directive '{0}', containing file '{1}', root directory not set. ========"), | |
| Type_declaration_files_to_be_included_in_compilation: diag(6124, ts_DiagnosticCategory.Message, "Type_declaration_files_to_be_included_in_compilation_6124", "Type declaration files to be included in compilation."), | |
| Looking_up_in_node_modules_folder_initial_location_0: diag(6125, ts_DiagnosticCategory.Message, "Looking_up_in_node_modules_folder_initial_location_0_6125", "Looking up in 'node_modules' folder, initial location '{0}'."), | |
| Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_modules_folder: diag(6126, ts_DiagnosticCategory.Message, "Containing_file_is_not_specified_and_root_directory_cannot_be_determined_skipping_lookup_in_node_mod_6126", "Containing file is not specified and root directory cannot be determined, skipping lookup in 'node_modules' folder."), | |
| Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1: diag(6127, ts_DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_1_6127", "======== Resolving type reference directive '{0}', containing file not set, root directory '{1}'. ========"), | |
| Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set: diag(6128, ts_DiagnosticCategory.Message, "Resolving_type_reference_directive_0_containing_file_not_set_root_directory_not_set_6128", "======== Resolving type reference directive '{0}', containing file not set, root directory not set. ========"), | |
| Resolving_real_path_for_0_result_1: diag(6130, ts_DiagnosticCategory.Message, "Resolving_real_path_for_0_result_1_6130", "Resolving real path for '{0}', result '{1}'."), | |
| Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system: diag(6131, ts_DiagnosticCategory.Error, "Cannot_compile_modules_using_option_0_unless_the_module_flag_is_amd_or_system_6131", "Cannot compile modules using option '{0}' unless the '--module' flag is 'amd' or 'system'."), | |
| File_name_0_has_a_1_extension_stripping_it: diag(6132, ts_DiagnosticCategory.Message, "File_name_0_has_a_1_extension_stripping_it_6132", "File name '{0}' has a '{1}' extension - stripping it."), | |
| _0_is_declared_but_its_value_is_never_read: diag(6133, ts_DiagnosticCategory.Error, "_0_is_declared_but_its_value_is_never_read_6133", "'{0}' is declared but its value is never read.", true), | |
| Report_errors_on_unused_locals: diag(6134, ts_DiagnosticCategory.Message, "Report_errors_on_unused_locals_6134", "Report errors on unused locals."), | |
| Report_errors_on_unused_parameters: diag(6135, ts_DiagnosticCategory.Message, "Report_errors_on_unused_parameters_6135", "Report errors on unused parameters."), | |
| The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files: diag(6136, ts_DiagnosticCategory.Message, "The_maximum_dependency_depth_to_search_under_node_modules_and_load_JavaScript_files_6136", "The maximum dependency depth to search under node_modules and load JavaScript files."), | |
| Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1: diag(6137, ts_DiagnosticCategory.Error, "Cannot_import_type_declaration_files_Consider_importing_0_instead_of_1_6137", "Cannot import type declaration files. Consider importing '{0}' instead of '{1}'."), | |
| Property_0_is_declared_but_its_value_is_never_read: diag(6138, ts_DiagnosticCategory.Error, "Property_0_is_declared_but_its_value_is_never_read_6138", "Property '{0}' is declared but its value is never read.", true), | |
| Import_emit_helpers_from_tslib: diag(6139, ts_DiagnosticCategory.Message, "Import_emit_helpers_from_tslib_6139", "Import emit helpers from 'tslib'."), | |
| Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2: diag(6140, ts_DiagnosticCategory.Error, "Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using__6140", "Auto discovery for typings is enabled in project '{0}'. Running extra resolution pass for module '{1}' using cache location '{2}'."), | |
| Parse_in_strict_mode_and_emit_use_strict_for_each_source_file: diag(6141, ts_DiagnosticCategory.Message, "Parse_in_strict_mode_and_emit_use_strict_for_each_source_file_6141", "Parse in strict mode and emit \"use strict\" for each source file."), | |
| Module_0_was_resolved_to_1_but_jsx_is_not_set: diag(6142, ts_DiagnosticCategory.Error, "Module_0_was_resolved_to_1_but_jsx_is_not_set_6142", "Module '{0}' was resolved to '{1}', but '--jsx' is not set."), | |
| Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1: diag(6144, ts_DiagnosticCategory.Message, "Module_0_was_resolved_as_locally_declared_ambient_module_in_file_1_6144", "Module '{0}' was resolved as locally declared ambient module in file '{1}'."), | |
| Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified: diag(6145, ts_DiagnosticCategory.Message, "Module_0_was_resolved_as_ambient_module_declared_in_1_since_this_file_was_not_modified_6145", "Module '{0}' was resolved as ambient module declared in '{1}' since this file was not modified."), | |
| Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h: diag(6146, ts_DiagnosticCategory.Message, "Specify_the_JSX_factory_function_to_use_when_targeting_react_JSX_emit_e_g_React_createElement_or_h_6146", "Specify the JSX factory function to use when targeting 'react' JSX emit, e.g. 'React.createElement' or 'h'."), | |
| Resolution_for_module_0_was_found_in_cache_from_location_1: diag(6147, ts_DiagnosticCategory.Message, "Resolution_for_module_0_was_found_in_cache_from_location_1_6147", "Resolution for module '{0}' was found in cache from location '{1}'."), | |
| Directory_0_does_not_exist_skipping_all_lookups_in_it: diag(6148, ts_DiagnosticCategory.Message, "Directory_0_does_not_exist_skipping_all_lookups_in_it_6148", "Directory '{0}' does not exist, skipping all lookups in it."), | |
| Show_diagnostic_information: diag(6149, ts_DiagnosticCategory.Message, "Show_diagnostic_information_6149", "Show diagnostic information."), | |
| Show_verbose_diagnostic_information: diag(6150, ts_DiagnosticCategory.Message, "Show_verbose_diagnostic_information_6150", "Show verbose diagnostic information."), | |
| Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file: diag(6151, ts_DiagnosticCategory.Message, "Emit_a_single_file_with_source_maps_instead_of_having_a_separate_file_6151", "Emit a single file with source maps instead of having a separate file."), | |
| Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap_to_be_set: diag(6152, ts_DiagnosticCategory.Message, "Emit_the_source_alongside_the_sourcemaps_within_a_single_file_requires_inlineSourceMap_or_sourceMap__6152", "Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set."), | |
| Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule: diag(6153, ts_DiagnosticCategory.Message, "Transpile_each_file_as_a_separate_module_similar_to_ts_transpileModule_6153", "Transpile each file as a separate module (similar to 'ts_transpileModule')."), | |
| Print_names_of_generated_files_part_of_the_compilation: diag(6154, ts_DiagnosticCategory.Message, "Print_names_of_generated_files_part_of_the_compilation_6154", "Print names of generated files part of the compilation."), | |
| Print_names_of_files_part_of_the_compilation: diag(6155, ts_DiagnosticCategory.Message, "Print_names_of_files_part_of_the_compilation_6155", "Print names of files part of the compilation."), | |
| The_locale_used_when_displaying_messages_to_the_user_e_g_en_us: diag(6156, ts_DiagnosticCategory.Message, "The_locale_used_when_displaying_messages_to_the_user_e_g_en_us_6156", "The locale used when displaying messages to the user (e.g. 'en-us')"), | |
| Do_not_generate_custom_helper_functions_like_extends_in_compiled_output: diag(6157, ts_DiagnosticCategory.Message, "Do_not_generate_custom_helper_functions_like_extends_in_compiled_output_6157", "Do not generate custom helper functions like '__extends' in compiled output."), | |
| Do_not_include_the_default_library_file_lib_d_ts: diag(6158, ts_DiagnosticCategory.Message, "Do_not_include_the_default_library_file_lib_d_ts_6158", "Do not include the default library file (lib.d.ts)."), | |
| Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files: diag(6159, ts_DiagnosticCategory.Message, "Do_not_add_triple_slash_references_or_imported_modules_to_the_list_of_compiled_files_6159", "Do not add triple-slash references or imported modules to the list of compiled files."), | |
| Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files: diag(6160, ts_DiagnosticCategory.Message, "Deprecated_Use_skipLibCheck_instead_Skip_type_checking_of_default_library_declaration_files_6160", "[Deprecated] Use '--skipLibCheck' instead. Skip type checking of default library declaration files."), | |
| List_of_folders_to_include_type_definitions_from: diag(6161, ts_DiagnosticCategory.Message, "List_of_folders_to_include_type_definitions_from_6161", "List of folders to include type definitions from."), | |
| Disable_size_limitations_on_JavaScript_projects: diag(6162, ts_DiagnosticCategory.Message, "Disable_size_limitations_on_JavaScript_projects_6162", "Disable size limitations on JavaScript projects."), | |
| The_character_set_of_the_input_files: diag(6163, ts_DiagnosticCategory.Message, "The_character_set_of_the_input_files_6163", "The character set of the input files."), | |
| Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files: diag(6164, ts_DiagnosticCategory.Message, "Emit_a_UTF_8_Byte_Order_Mark_BOM_in_the_beginning_of_output_files_6164", "Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files."), | |
| Do_not_truncate_error_messages: diag(6165, ts_DiagnosticCategory.Message, "Do_not_truncate_error_messages_6165", "Do not truncate error messages."), | |
| Output_directory_for_generated_declaration_files: diag(6166, ts_DiagnosticCategory.Message, "Output_directory_for_generated_declaration_files_6166", "Output directory for generated declaration files."), | |
| A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl: diag(6167, ts_DiagnosticCategory.Message, "A_series_of_entries_which_re_map_imports_to_lookup_locations_relative_to_the_baseUrl_6167", "A series of entries which re-map imports to lookup locations relative to the 'baseUrl'."), | |
| List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime: diag(6168, ts_DiagnosticCategory.Message, "List_of_root_folders_whose_combined_content_represents_the_structure_of_the_project_at_runtime_6168", "List of root folders whose combined content represents the structure of the project at runtime."), | |
| Show_all_compiler_options: diag(6169, ts_DiagnosticCategory.Message, "Show_all_compiler_options_6169", "Show all compiler options."), | |
| Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file: diag(6170, ts_DiagnosticCategory.Message, "Deprecated_Use_outFile_instead_Concatenate_and_emit_output_to_single_file_6170", "[Deprecated] Use '--outFile' instead. Concatenate and emit output to single file"), | |
| Command_line_Options: diag(6171, ts_DiagnosticCategory.Message, "Command_line_Options_6171", "Command-line Options"), | |
| Basic_Options: diag(6172, ts_DiagnosticCategory.Message, "Basic_Options_6172", "Basic Options"), | |
| Strict_Type_Checking_Options: diag(6173, ts_DiagnosticCategory.Message, "Strict_Type_Checking_Options_6173", "Strict Type-Checking Options"), | |
| Module_Resolution_Options: diag(6174, ts_DiagnosticCategory.Message, "Module_Resolution_Options_6174", "Module Resolution Options"), | |
| Source_Map_Options: diag(6175, ts_DiagnosticCategory.Message, "Source_Map_Options_6175", "Source Map Options"), | |
| Additional_Checks: diag(6176, ts_DiagnosticCategory.Message, "Additional_Checks_6176", "Additional Checks"), | |
| Experimental_Options: diag(6177, ts_DiagnosticCategory.Message, "Experimental_Options_6177", "Experimental Options"), | |
| Advanced_Options: diag(6178, ts_DiagnosticCategory.Message, "Advanced_Options_6178", "Advanced Options"), | |
| Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3: diag(6179, ts_DiagnosticCategory.Message, "Provide_full_support_for_iterables_in_for_of_spread_and_destructuring_when_targeting_ES5_or_ES3_6179", "Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'."), | |
| Enable_all_strict_type_checking_options: diag(6180, ts_DiagnosticCategory.Message, "Enable_all_strict_type_checking_options_6180", "Enable all strict type-checking options."), | |
| List_of_language_service_plugins: diag(6181, ts_DiagnosticCategory.Message, "List_of_language_service_plugins_6181", "List of language service plugins."), | |
| Scoped_package_detected_looking_in_0: diag(6182, ts_DiagnosticCategory.Message, "Scoped_package_detected_looking_in_0_6182", "Scoped package detected, looking in '{0}'"), | |
| Reusing_resolution_of_module_0_to_file_1_from_old_program: diag(6183, ts_DiagnosticCategory.Message, "Reusing_resolution_of_module_0_to_file_1_from_old_program_6183", "Reusing resolution of module '{0}' to file '{1}' from old program."), | |
| Reusing_module_resolutions_originating_in_0_since_resolutions_are_unchanged_from_old_program: diag(6184, ts_DiagnosticCategory.Message, "Reusing_module_resolutions_originating_in_0_since_resolutions_are_unchanged_from_old_program_6184", "Reusing module resolutions originating in '{0}' since resolutions are unchanged from old program."), | |
| Disable_strict_checking_of_generic_signatures_in_function_types: diag(6185, ts_DiagnosticCategory.Message, "Disable_strict_checking_of_generic_signatures_in_function_types_6185", "Disable strict checking of generic signatures in function types."), | |
| Enable_strict_checking_of_function_types: diag(6186, ts_DiagnosticCategory.Message, "Enable_strict_checking_of_function_types_6186", "Enable strict checking of function types."), | |
| Enable_strict_checking_of_property_initialization_in_classes: diag(6187, ts_DiagnosticCategory.Message, "Enable_strict_checking_of_property_initialization_in_classes_6187", "Enable strict checking of property initialization in classes."), | |
| Numeric_separators_are_not_allowed_here: diag(6188, ts_DiagnosticCategory.Error, "Numeric_separators_are_not_allowed_here_6188", "Numeric separators are not allowed here."), | |
| Multiple_consecutive_numeric_separators_are_not_permitted: diag(6189, ts_DiagnosticCategory.Error, "Multiple_consecutive_numeric_separators_are_not_permitted_6189", "Multiple consecutive numeric separators are not permitted."), | |
| Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen: diag(6191, ts_DiagnosticCategory.Message, "Whether_to_keep_outdated_console_output_in_watch_mode_instead_of_clearing_the_screen_6191", "Whether to keep outdated console output in watch mode instead of clearing the screen."), | |
| All_imports_in_import_declaration_are_unused: diag(6192, ts_DiagnosticCategory.Error, "All_imports_in_import_declaration_are_unused_6192", "All imports in import declaration are unused.", true), | |
| Found_1_error_Watching_for_file_changes: diag(6193, ts_DiagnosticCategory.Message, "Found_1_error_Watching_for_file_changes_6193", "Found 1 error. Watching for file changes."), | |
| Found_0_errors_Watching_for_file_changes: diag(6194, ts_DiagnosticCategory.Message, "Found_0_errors_Watching_for_file_changes_6194", "Found {0} errors. Watching for file changes."), | |
| Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols: diag(6195, ts_DiagnosticCategory.Message, "Resolve_keyof_to_string_valued_property_names_only_no_numbers_or_symbols_6195", "Resolve 'keyof' to string valued property names only (no numbers or symbols)."), | |
| _0_is_declared_but_never_used: diag(6196, ts_DiagnosticCategory.Error, "_0_is_declared_but_never_used_6196", "'{0}' is declared but never used.", true), | |
| Include_modules_imported_with_json_extension: diag(6197, ts_DiagnosticCategory.Message, "Include_modules_imported_with_json_extension_6197", "Include modules imported with '.json' extension"), | |
| All_destructured_elements_are_unused: diag(6198, ts_DiagnosticCategory.Error, "All_destructured_elements_are_unused_6198", "All destructured elements are unused.", true), | |
| All_variables_are_unused: diag(6199, ts_DiagnosticCategory.Error, "All_variables_are_unused_6199", "All variables are unused.", true), | |
| Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0: diag(6200, ts_DiagnosticCategory.Error, "Definitions_of_the_following_identifiers_conflict_with_those_in_another_file_Colon_0_6200", "Definitions of the following identifiers conflict with those in another file: {0}"), | |
| Conflicts_are_in_this_file: diag(6201, ts_DiagnosticCategory.Message, "Conflicts_are_in_this_file_6201", "Conflicts are in this file."), | |
| Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0: diag(6202, ts_DiagnosticCategory.Error, "Project_references_may_not_form_a_circular_graph_Cycle_detected_Colon_0_6202", "Project references may not form a circular graph. Cycle detected: {0}"), | |
| _0_was_also_declared_here: diag(6203, ts_DiagnosticCategory.Message, "_0_was_also_declared_here_6203", "'{0}' was also declared here."), | |
| and_here: diag(6204, ts_DiagnosticCategory.Message, "and_here_6204", "and here."), | |
| All_type_parameters_are_unused: diag(6205, ts_DiagnosticCategory.Error, "All_type_parameters_are_unused_6205", "All type parameters are unused"), | |
| package_json_has_a_typesVersions_field_with_version_specific_path_mappings: diag(6206, ts_DiagnosticCategory.Message, "package_json_has_a_typesVersions_field_with_version_specific_path_mappings_6206", "'package.json' has a 'typesVersions' field with version-specific path mappings."), | |
| package_json_does_not_have_a_typesVersions_entry_that_matches_version_0: diag(6207, ts_DiagnosticCategory.Message, "package_json_does_not_have_a_typesVersions_entry_that_matches_version_0_6207", "'package.json' does not have a 'typesVersions' entry that matches version '{0}'."), | |
| package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2: diag(6208, ts_DiagnosticCategory.Message, "package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_ma_6208", "'package.json' has a 'typesVersions' entry '{0}' that matches compiler version '{1}', looking for a pattern to match module name '{2}'."), | |
| package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range: diag(6209, ts_DiagnosticCategory.Message, "package_json_has_a_typesVersions_entry_0_that_is_not_a_valid_semver_range_6209", "'package.json' has a 'typesVersions' entry '{0}' that is not a valid semver range."), | |
| An_argument_for_0_was_not_provided: diag(6210, ts_DiagnosticCategory.Message, "An_argument_for_0_was_not_provided_6210", "An argument for '{0}' was not provided."), | |
| An_argument_matching_this_binding_pattern_was_not_provided: diag(6211, ts_DiagnosticCategory.Message, "An_argument_matching_this_binding_pattern_was_not_provided_6211", "An argument matching this binding pattern was not provided."), | |
| Did_you_mean_to_call_this_expression: diag(6212, ts_DiagnosticCategory.Message, "Did_you_mean_to_call_this_expression_6212", "Did you mean to call this expression?"), | |
| Did_you_mean_to_use_new_with_this_expression: diag(6213, ts_DiagnosticCategory.Message, "Did_you_mean_to_use_new_with_this_expression_6213", "Did you mean to use 'new' with this expression?"), | |
| Enable_strict_bind_call_and_apply_methods_on_functions: diag(6214, ts_DiagnosticCategory.Message, "Enable_strict_bind_call_and_apply_methods_on_functions_6214", "Enable strict 'bind', 'call', and 'apply' methods on functions."), | |
| Using_compiler_options_of_project_reference_redirect_0: diag(6215, ts_DiagnosticCategory.Message, "Using_compiler_options_of_project_reference_redirect_0_6215", "Using compiler options of project reference redirect '{0}'."), | |
| Found_1_error: diag(6216, ts_DiagnosticCategory.Message, "Found_1_error_6216", "Found 1 error."), | |
| Found_0_errors: diag(6217, ts_DiagnosticCategory.Message, "Found_0_errors_6217", "Found {0} errors."), | |
| Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2: diag(6218, ts_DiagnosticCategory.Message, "Module_name_0_was_successfully_resolved_to_1_with_Package_ID_2_6218", "======== Module name '{0}' was successfully resolved to '{1}' with Package ID '{2}'. ========"), | |
| Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3: diag(6219, ts_DiagnosticCategory.Message, "Type_reference_directive_0_was_successfully_resolved_to_1_with_Package_ID_2_primary_Colon_3_6219", "======== Type reference directive '{0}' was successfully resolved to '{1}' with Package ID '{2}', primary: {3}. ========"), | |
| package_json_had_a_falsy_0_field: diag(6220, ts_DiagnosticCategory.Message, "package_json_had_a_falsy_0_field_6220", "'package.json' had a falsy '{0}' field."), | |
| Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects: diag(6221, ts_DiagnosticCategory.Message, "Disable_use_of_source_files_instead_of_declaration_files_from_referenced_projects_6221", "Disable use of source files instead of declaration files from referenced projects."), | |
| Emit_class_fields_with_Define_instead_of_Set: diag(6222, ts_DiagnosticCategory.Message, "Emit_class_fields_with_Define_instead_of_Set_6222", "Emit class fields with Define instead of Set."), | |
| Generates_a_CPU_profile: diag(6223, ts_DiagnosticCategory.Message, "Generates_a_CPU_profile_6223", "Generates a CPU profile."), | |
| Disable_solution_searching_for_this_project: diag(6224, ts_DiagnosticCategory.Message, "Disable_solution_searching_for_this_project_6224", "Disable solution searching for this project."), | |
| Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_DynamicPriorityPolling_UseFsEvents_UseFsEventsOnParentDirectory: diag(6225, ts_DiagnosticCategory.Message, "Specify_strategy_for_watching_file_Colon_FixedPollingInterval_default_PriorityPollingInterval_Dynami_6225", "Specify strategy for watching file: 'FixedPollingInterval' (default), 'PriorityPollingInterval', 'DynamicPriorityPolling', 'UseFsEvents', 'UseFsEventsOnParentDirectory'."), | |
| Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively_Colon_UseFsEvents_default_FixedPollingInterval_DynamicPriorityPolling: diag(6226, ts_DiagnosticCategory.Message, "Specify_strategy_for_watching_directory_on_platforms_that_don_t_support_recursive_watching_natively__6226", "Specify strategy for watching directory on platforms that don't support recursive watching natively: 'UseFsEvents' (default), 'FixedPollingInterval', 'DynamicPriorityPolling'."), | |
| Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_FixedInterval_default_PriorityInterval_DynamicPriority: diag(6227, ts_DiagnosticCategory.Message, "Specify_strategy_for_creating_a_polling_watch_when_it_fails_to_create_using_file_system_events_Colon_6227", "Specify strategy for creating a polling watch when it fails to create using file system events: 'FixedInterval' (default), 'PriorityInterval', 'DynamicPriority'."), | |
| Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_support_recursive_watching_natively: diag(6228, ts_DiagnosticCategory.Message, "Synchronously_call_callbacks_and_update_the_state_of_directory_watchers_on_platforms_that_don_t_supp_6228", "Synchronously call callbacks and update the state of directory watchers on platforms that don't support recursive watching natively."), | |
| Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line: diag(6230, ts_DiagnosticCategory.Error, "Option_0_can_only_be_specified_in_tsconfig_json_file_or_set_to_false_or_null_on_command_line_6230", "Option '{0}' can only be specified in 'tsconfig.json' file or set to 'false' or 'null' on command line."), | |
| Projects_to_reference: diag(6300, ts_DiagnosticCategory.Message, "Projects_to_reference_6300", "Projects to reference"), | |
| Enable_project_compilation: diag(6302, ts_DiagnosticCategory.Message, "Enable_project_compilation_6302", "Enable project compilation"), | |
| Composite_projects_may_not_disable_declaration_emit: diag(6304, ts_DiagnosticCategory.Error, "Composite_projects_may_not_disable_declaration_emit_6304", "Composite projects may not disable declaration emit."), | |
| Output_file_0_has_not_been_built_from_source_file_1: diag(6305, ts_DiagnosticCategory.Error, "Output_file_0_has_not_been_built_from_source_file_1_6305", "Output file '{0}' has not been built from source file '{1}'."), | |
| Referenced_project_0_must_have_setting_composite_Colon_true: diag(6306, ts_DiagnosticCategory.Error, "Referenced_project_0_must_have_setting_composite_Colon_true_6306", "Referenced project '{0}' must have setting \"composite\": true."), | |
| File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_include_pattern: diag(6307, ts_DiagnosticCategory.Error, "File_0_is_not_listed_within_the_file_list_of_project_1_Projects_must_list_all_files_or_use_an_includ_6307", "File '{0}' is not listed within the file list of project '{1}'. Projects must list all files or use an 'include' pattern."), | |
| Cannot_prepend_project_0_because_it_does_not_have_outFile_set: diag(6308, ts_DiagnosticCategory.Error, "Cannot_prepend_project_0_because_it_does_not_have_outFile_set_6308", "Cannot prepend project '{0}' because it does not have 'outFile' set"), | |
| Output_file_0_from_project_1_does_not_exist: diag(6309, ts_DiagnosticCategory.Error, "Output_file_0_from_project_1_does_not_exist_6309", "Output file '{0}' from project '{1}' does not exist"), | |
| Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2: diag(6350, ts_DiagnosticCategory.Message, "Project_0_is_out_of_date_because_oldest_output_1_is_older_than_newest_input_2_6350", "Project '{0}' is out of date because oldest output '{1}' is older than newest input '{2}'"), | |
| Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2: diag(6351, ts_DiagnosticCategory.Message, "Project_0_is_up_to_date_because_newest_input_1_is_older_than_oldest_output_2_6351", "Project '{0}' is up to date because newest input '{1}' is older than oldest output '{2}'"), | |
| Project_0_is_out_of_date_because_output_file_1_does_not_exist: diag(6352, ts_DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_file_1_does_not_exist_6352", "Project '{0}' is out of date because output file '{1}' does not exist"), | |
| Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date: diag(6353, ts_DiagnosticCategory.Message, "Project_0_is_out_of_date_because_its_dependency_1_is_out_of_date_6353", "Project '{0}' is out of date because its dependency '{1}' is out of date"), | |
| Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies: diag(6354, ts_DiagnosticCategory.Message, "Project_0_is_up_to_date_with_d_ts_files_from_its_dependencies_6354", "Project '{0}' is up to date with .d.ts files from its dependencies"), | |
| Projects_in_this_build_Colon_0: diag(6355, ts_DiagnosticCategory.Message, "Projects_in_this_build_Colon_0_6355", "Projects in this build: {0}"), | |
| A_non_dry_build_would_delete_the_following_files_Colon_0: diag(6356, ts_DiagnosticCategory.Message, "A_non_dry_build_would_delete_the_following_files_Colon_0_6356", "A non-dry build would delete the following files: {0}"), | |
| A_non_dry_build_would_build_project_0: diag(6357, ts_DiagnosticCategory.Message, "A_non_dry_build_would_build_project_0_6357", "A non-dry build would build project '{0}'"), | |
| Building_project_0: diag(6358, ts_DiagnosticCategory.Message, "Building_project_0_6358", "Building project '{0}'..."), | |
| Updating_output_timestamps_of_project_0: diag(6359, ts_DiagnosticCategory.Message, "Updating_output_timestamps_of_project_0_6359", "Updating output timestamps of project '{0}'..."), | |
| delete_this_Project_0_is_up_to_date_because_it_was_previously_built: diag(6360, ts_DiagnosticCategory.Message, "delete_this_Project_0_is_up_to_date_because_it_was_previously_built_6360", "delete this - Project '{0}' is up to date because it was previously built"), | |
| Project_0_is_up_to_date: diag(6361, ts_DiagnosticCategory.Message, "Project_0_is_up_to_date_6361", "Project '{0}' is up to date"), | |
| Skipping_build_of_project_0_because_its_dependency_1_has_errors: diag(6362, ts_DiagnosticCategory.Message, "Skipping_build_of_project_0_because_its_dependency_1_has_errors_6362", "Skipping build of project '{0}' because its dependency '{1}' has errors"), | |
| Project_0_can_t_be_built_because_its_dependency_1_has_errors: diag(6363, ts_DiagnosticCategory.Message, "Project_0_can_t_be_built_because_its_dependency_1_has_errors_6363", "Project '{0}' can't be built because its dependency '{1}' has errors"), | |
| Build_one_or_more_projects_and_their_dependencies_if_out_of_date: diag(6364, ts_DiagnosticCategory.Message, "Build_one_or_more_projects_and_their_dependencies_if_out_of_date_6364", "Build one or more projects and their dependencies, if out of date"), | |
| Delete_the_outputs_of_all_projects: diag(6365, ts_DiagnosticCategory.Message, "Delete_the_outputs_of_all_projects_6365", "Delete the outputs of all projects"), | |
| Enable_verbose_logging: diag(6366, ts_DiagnosticCategory.Message, "Enable_verbose_logging_6366", "Enable verbose logging"), | |
| Show_what_would_be_built_or_deleted_if_specified_with_clean: diag(6367, ts_DiagnosticCategory.Message, "Show_what_would_be_built_or_deleted_if_specified_with_clean_6367", "Show what would be built (or deleted, if specified with '--clean')"), | |
| Build_all_projects_including_those_that_appear_to_be_up_to_date: diag(6368, ts_DiagnosticCategory.Message, "Build_all_projects_including_those_that_appear_to_be_up_to_date_6368", "Build all projects, including those that appear to be up to date"), | |
| Option_build_must_be_the_first_command_line_argument: diag(6369, ts_DiagnosticCategory.Error, "Option_build_must_be_the_first_command_line_argument_6369", "Option '--build' must be the first command line argument."), | |
| Options_0_and_1_cannot_be_combined: diag(6370, ts_DiagnosticCategory.Error, "Options_0_and_1_cannot_be_combined_6370", "Options '{0}' and '{1}' cannot be combined."), | |
| Updating_unchanged_output_timestamps_of_project_0: diag(6371, ts_DiagnosticCategory.Message, "Updating_unchanged_output_timestamps_of_project_0_6371", "Updating unchanged output timestamps of project '{0}'..."), | |
| Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed: diag(6372, ts_DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_of_its_dependency_1_has_changed_6372", "Project '{0}' is out of date because output of its dependency '{1}' has changed"), | |
| Updating_output_of_project_0: diag(6373, ts_DiagnosticCategory.Message, "Updating_output_of_project_0_6373", "Updating output of project '{0}'..."), | |
| A_non_dry_build_would_update_timestamps_for_output_of_project_0: diag(6374, ts_DiagnosticCategory.Message, "A_non_dry_build_would_update_timestamps_for_output_of_project_0_6374", "A non-dry build would update timestamps for output of project '{0}'"), | |
| A_non_dry_build_would_update_output_of_project_0: diag(6375, ts_DiagnosticCategory.Message, "A_non_dry_build_would_update_output_of_project_0_6375", "A non-dry build would update output of project '{0}'"), | |
| Cannot_update_output_of_project_0_because_there_was_error_reading_file_1: diag(6376, ts_DiagnosticCategory.Message, "Cannot_update_output_of_project_0_because_there_was_error_reading_file_1_6376", "Cannot update output of project '{0}' because there was error reading file '{1}'"), | |
| Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1: diag(6377, ts_DiagnosticCategory.Error, "Cannot_write_file_0_because_it_will_overwrite_tsbuildinfo_file_generated_by_referenced_project_1_6377", "Cannot write file '{0}' because it will overwrite '.tsbuildinfo' file generated by referenced project '{1}'"), | |
| Enable_incremental_compilation: diag(6378, ts_DiagnosticCategory.Message, "Enable_incremental_compilation_6378", "Enable incremental compilation"), | |
| Composite_projects_may_not_disable_incremental_compilation: diag(6379, ts_DiagnosticCategory.Error, "Composite_projects_may_not_disable_incremental_compilation_6379", "Composite projects may not disable incremental compilation."), | |
| Specify_file_to_store_incremental_compilation_information: diag(6380, ts_DiagnosticCategory.Message, "Specify_file_to_store_incremental_compilation_information_6380", "Specify file to store incremental compilation information"), | |
| Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_current_version_2: diag(6381, ts_DiagnosticCategory.Message, "Project_0_is_out_of_date_because_output_for_it_was_generated_with_version_1_that_differs_with_curren_6381", "Project '{0}' is out of date because output for it was generated with version '{1}' that differs with current version '{2}'"), | |
| Skipping_build_of_project_0_because_its_dependency_1_was_not_built: diag(6382, ts_DiagnosticCategory.Message, "Skipping_build_of_project_0_because_its_dependency_1_was_not_built_6382", "Skipping build of project '{0}' because its dependency '{1}' was not built"), | |
| Project_0_can_t_be_built_because_its_dependency_1_was_not_built: diag(6383, ts_DiagnosticCategory.Message, "Project_0_can_t_be_built_because_its_dependency_1_was_not_built_6383", "Project '{0}' can't be built because its dependency '{1}' was not built"), | |
| Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_directly_depending_on_it: diag(6384, ts_DiagnosticCategory.Message, "Have_recompiles_in_incremental_and_watch_assume_that_changes_within_a_file_will_only_affect_files_di_6384", "Have recompiles in '--incremental' and '--watch' assume that changes within a file will only affect files directly depending on it."), | |
| The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, ts_DiagnosticCategory.Message, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"), | |
| The_expected_type_comes_from_this_index_signature: diag(6501, ts_DiagnosticCategory.Message, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."), | |
| The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, ts_DiagnosticCategory.Message, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."), | |
| Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing: diag(6503, ts_DiagnosticCategory.Message, "Print_names_of_files_that_are_part_of_the_compilation_and_then_stop_processing_6503", "Print names of files that are part of the compilation and then stop processing."), | |
| File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option: diag(6504, ts_DiagnosticCategory.Error, "File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option_6504", "File '{0}' is a JavaScript file. Did you mean to enable the 'allowJs' option?"), | |
| Variable_0_implicitly_has_an_1_type: diag(7005, ts_DiagnosticCategory.Error, "Variable_0_implicitly_has_an_1_type_7005", "Variable '{0}' implicitly has an '{1}' type."), | |
| Parameter_0_implicitly_has_an_1_type: diag(7006, ts_DiagnosticCategory.Error, "Parameter_0_implicitly_has_an_1_type_7006", "Parameter '{0}' implicitly has an '{1}' type."), | |
| Member_0_implicitly_has_an_1_type: diag(7008, ts_DiagnosticCategory.Error, "Member_0_implicitly_has_an_1_type_7008", "Member '{0}' implicitly has an '{1}' type."), | |
| new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type: diag(7009, ts_DiagnosticCategory.Error, "new_expression_whose_target_lacks_a_construct_signature_implicitly_has_an_any_type_7009", "'new' expression, whose target lacks a construct signature, implicitly has an 'any' type."), | |
| _0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type: diag(7010, ts_DiagnosticCategory.Error, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type_7010", "'{0}', which lacks return-type annotation, implicitly has an '{1}' return type."), | |
| Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: diag(7011, ts_DiagnosticCategory.Error, "Function_expression_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7011", "Function expression, which lacks return-type annotation, implicitly has an '{0}' return type."), | |
| Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: diag(7013, ts_DiagnosticCategory.Error, "Construct_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7013", "Construct signature, which lacks return-type annotation, implicitly has an 'any' return type."), | |
| Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type: diag(7014, ts_DiagnosticCategory.Error, "Function_type_which_lacks_return_type_annotation_implicitly_has_an_0_return_type_7014", "Function type, which lacks return-type annotation, implicitly has an '{0}' return type."), | |
| Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number: diag(7015, ts_DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_index_expression_is_not_of_type_number_7015", "Element implicitly has an 'any' type because index expression is not of type 'number'."), | |
| Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type: diag(7016, ts_DiagnosticCategory.Error, "Could_not_find_a_declaration_file_for_module_0_1_implicitly_has_an_any_type_7016", "Could not find a declaration file for module '{0}'. '{1}' implicitly has an 'any' type."), | |
| Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature: diag(7017, ts_DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_7017", "Element implicitly has an 'any' type because type '{0}' has no index signature."), | |
| Object_literal_s_property_0_implicitly_has_an_1_type: diag(7018, ts_DiagnosticCategory.Error, "Object_literal_s_property_0_implicitly_has_an_1_type_7018", "Object literal's property '{0}' implicitly has an '{1}' type."), | |
| Rest_parameter_0_implicitly_has_an_any_type: diag(7019, ts_DiagnosticCategory.Error, "Rest_parameter_0_implicitly_has_an_any_type_7019", "Rest parameter '{0}' implicitly has an 'any[]' type."), | |
| Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type: diag(7020, ts_DiagnosticCategory.Error, "Call_signature_which_lacks_return_type_annotation_implicitly_has_an_any_return_type_7020", "Call signature, which lacks return-type annotation, implicitly has an 'any' return type."), | |
| _0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or_indirectly_in_its_own_initializer: diag(7022, ts_DiagnosticCategory.Error, "_0_implicitly_has_type_any_because_it_does_not_have_a_type_annotation_and_is_referenced_directly_or__7022", "'{0}' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer."), | |
| _0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7023, ts_DiagnosticCategory.Error, "_0_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_reference_7023", "'{0}' implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."), | |
| Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_referenced_directly_or_indirectly_in_one_of_its_return_expressions: diag(7024, ts_DiagnosticCategory.Error, "Function_implicitly_has_return_type_any_because_it_does_not_have_a_return_type_annotation_and_is_ref_7024", "Function implicitly has return type 'any' because it does not have a return type annotation and is referenced directly or indirectly in one of its return expressions."), | |
| Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_return_type_annotation: diag(7025, ts_DiagnosticCategory.Error, "Generator_implicitly_has_yield_type_0_because_it_does_not_yield_any_values_Consider_supplying_a_retu_7025", "Generator implicitly has yield type '{0}' because it does not yield any values. Consider supplying a return type annotation."), | |
| JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists: diag(7026, ts_DiagnosticCategory.Error, "JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists_7026", "JSX element implicitly has type 'any' because no interface 'JSX.{0}' exists."), | |
| Unreachable_code_detected: diag(7027, ts_DiagnosticCategory.Error, "Unreachable_code_detected_7027", "Unreachable code detected.", true), | |
| Unused_label: diag(7028, ts_DiagnosticCategory.Error, "Unused_label_7028", "Unused label.", true), | |
| Fallthrough_case_in_switch: diag(7029, ts_DiagnosticCategory.Error, "Fallthrough_case_in_switch_7029", "Fallthrough case in switch."), | |
| Not_all_code_paths_return_a_value: diag(7030, ts_DiagnosticCategory.Error, "Not_all_code_paths_return_a_value_7030", "Not all code paths return a value."), | |
| Binding_element_0_implicitly_has_an_1_type: diag(7031, ts_DiagnosticCategory.Error, "Binding_element_0_implicitly_has_an_1_type_7031", "Binding element '{0}' implicitly has an '{1}' type."), | |
| Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation: diag(7032, ts_DiagnosticCategory.Error, "Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation_7032", "Property '{0}' implicitly has type 'any', because its set accessor lacks a parameter type annotation."), | |
| Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation: diag(7033, ts_DiagnosticCategory.Error, "Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation_7033", "Property '{0}' implicitly has type 'any', because its get accessor lacks a return type annotation."), | |
| Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined: diag(7034, ts_DiagnosticCategory.Error, "Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined_7034", "Variable '{0}' implicitly has type '{1}' in some locations where its type cannot be determined."), | |
| Try_npm_install_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0: diag(7035, ts_DiagnosticCategory.Error, "Try_npm_install_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_mod_7035", "Try `npm install @types/{1}` if it exists or add a new declaration (.d.ts) file containing `declare module '{0}';`"), | |
| Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0: diag(7036, ts_DiagnosticCategory.Error, "Dynamic_import_s_specifier_must_be_of_type_string_but_here_has_type_0_7036", "Dynamic import's specifier must be of type 'string', but here has type '{0}'."), | |
| Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for_all_imports_Implies_allowSyntheticDefaultImports: diag(7037, ts_DiagnosticCategory.Message, "Enables_emit_interoperability_between_CommonJS_and_ES_Modules_via_creation_of_namespace_objects_for__7037", "Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'."), | |
| Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cause_a_failure_at_runtime_Consider_using_a_default_import_or_import_require_here_instead: diag(7038, ts_DiagnosticCategory.Message, "Type_originates_at_this_import_A_namespace_style_import_cannot_be_called_or_constructed_and_will_cau_7038", "Type originates at this import. A namespace-style import cannot be called or constructed, and will cause a failure at runtime. Consider using a default import or import require here instead."), | |
| Mapped_object_type_implicitly_has_an_any_template_type: diag(7039, ts_DiagnosticCategory.Error, "Mapped_object_type_implicitly_has_an_any_template_type_7039", "Mapped object type implicitly has an 'any' template type."), | |
| If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1: diag(7040, ts_DiagnosticCategory.Error, "If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_S_7040", "If the '{0}' package actually exposes this module, consider sending a pull request to amend 'https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/{1}`"), | |
| The_containing_arrow_function_captures_the_global_value_of_this: diag(7041, ts_DiagnosticCategory.Error, "The_containing_arrow_function_captures_the_global_value_of_this_7041", "The containing arrow function captures the global value of 'this'."), | |
| Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used: diag(7042, ts_DiagnosticCategory.Error, "Module_0_was_resolved_to_1_but_resolveJsonModule_is_not_used_7042", "Module '{0}' was resolved to '{1}', but '--resolveJsonModule' is not used."), | |
| Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7043, ts_DiagnosticCategory.Suggestion, "Variable_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7043", "Variable '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), | |
| Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7044, ts_DiagnosticCategory.Suggestion, "Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7044", "Parameter '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), | |
| Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage: diag(7045, ts_DiagnosticCategory.Suggestion, "Member_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage_7045", "Member '{0}' implicitly has an '{1}' type, but a better type may be inferred from usage."), | |
| Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage: diag(7046, ts_DiagnosticCategory.Suggestion, "Variable_0_implicitly_has_type_1_in_some_locations_but_a_better_type_may_be_inferred_from_usage_7046", "Variable '{0}' implicitly has type '{1}' in some locations, but a better type may be inferred from usage."), | |
| Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage: diag(7047, ts_DiagnosticCategory.Suggestion, "Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage_7047", "Rest parameter '{0}' implicitly has an 'any[]' type, but a better type may be inferred from usage."), | |
| Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage: diag(7048, ts_DiagnosticCategory.Suggestion, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_get_accessor_may_be_inferred_from_usage_7048", "Property '{0}' implicitly has type 'any', but a better type for its get accessor may be inferred from usage."), | |
| Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage: diag(7049, ts_DiagnosticCategory.Suggestion, "Property_0_implicitly_has_type_any_but_a_better_type_for_its_set_accessor_may_be_inferred_from_usage_7049", "Property '{0}' implicitly has type 'any', but a better type for its set accessor may be inferred from usage."), | |
| _0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage: diag(7050, ts_DiagnosticCategory.Suggestion, "_0_implicitly_has_an_1_return_type_but_a_better_type_may_be_inferred_from_usage_7050", "'{0}' implicitly has an '{1}' return type, but a better type may be inferred from usage."), | |
| Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1: diag(7051, ts_DiagnosticCategory.Error, "Parameter_has_a_name_but_no_type_Did_you_mean_0_Colon_1_7051", "Parameter has a name but no type. Did you mean '{0}: {1}'?"), | |
| Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1: diag(7052, ts_DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_type_0_has_no_index_signature_Did_you_mean_to_call_1_7052", "Element implicitly has an 'any' type because type '{0}' has no index signature. Did you mean to call '{1}'?"), | |
| Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1: diag(7053, ts_DiagnosticCategory.Error, "Element_implicitly_has_an_any_type_because_expression_of_type_0_can_t_be_used_to_index_type_1_7053", "Element implicitly has an 'any' type because expression of type '{0}' can't be used to index type '{1}'."), | |
| No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1: diag(7054, ts_DiagnosticCategory.Error, "No_index_signature_with_a_parameter_of_type_0_was_found_on_type_1_7054", "No index signature with a parameter of type '{0}' was found on type '{1}'."), | |
| _0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type: diag(7055, ts_DiagnosticCategory.Error, "_0_which_lacks_return_type_annotation_implicitly_has_an_1_yield_type_7055", "'{0}', which lacks return-type annotation, implicitly has an '{1}' yield type."), | |
| You_cannot_rename_this_element: diag(8000, ts_DiagnosticCategory.Error, "You_cannot_rename_this_element_8000", "You cannot rename this element."), | |
| You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library: diag(8001, ts_DiagnosticCategory.Error, "You_cannot_rename_elements_that_are_defined_in_the_standard_TypeScript_library_8001", "You cannot rename elements that are defined in the standard TypeScript library."), | |
| import_can_only_be_used_in_TypeScript_files: diag(8002, ts_DiagnosticCategory.Error, "import_can_only_be_used_in_TypeScript_files_8002", "'import ... =' can only be used in TypeScript files."), | |
| export_can_only_be_used_in_TypeScript_files: diag(8003, ts_DiagnosticCategory.Error, "export_can_only_be_used_in_TypeScript_files_8003", "'export =' can only be used in TypeScript files."), | |
| Type_parameter_declarations_can_only_be_used_in_TypeScript_files: diag(8004, ts_DiagnosticCategory.Error, "Type_parameter_declarations_can_only_be_used_in_TypeScript_files_8004", "Type parameter declarations can only be used in TypeScript files."), | |
| implements_clauses_can_only_be_used_in_TypeScript_files: diag(8005, ts_DiagnosticCategory.Error, "implements_clauses_can_only_be_used_in_TypeScript_files_8005", "'implements' clauses can only be used in TypeScript files."), | |
| _0_declarations_can_only_be_used_in_TypeScript_files: diag(8006, ts_DiagnosticCategory.Error, "_0_declarations_can_only_be_used_in_TypeScript_files_8006", "'{0}' declarations can only be used in TypeScript files."), | |
| Type_aliases_can_only_be_used_in_TypeScript_files: diag(8008, ts_DiagnosticCategory.Error, "Type_aliases_can_only_be_used_in_TypeScript_files_8008", "Type aliases can only be used in TypeScript files."), | |
| The_0_modifier_can_only_be_used_in_TypeScript_files: diag(8009, ts_DiagnosticCategory.Error, "The_0_modifier_can_only_be_used_in_TypeScript_files_8009", "The '{0}' modifier can only be used in TypeScript files."), | |
| Type_annotations_can_only_be_used_in_TypeScript_files: diag(8010, ts_DiagnosticCategory.Error, "Type_annotations_can_only_be_used_in_TypeScript_files_8010", "Type annotations can only be used in TypeScript files."), | |
| Type_arguments_can_only_be_used_in_TypeScript_files: diag(8011, ts_DiagnosticCategory.Error, "Type_arguments_can_only_be_used_in_TypeScript_files_8011", "Type arguments can only be used in TypeScript files."), | |
| Parameter_modifiers_can_only_be_used_in_TypeScript_files: diag(8012, ts_DiagnosticCategory.Error, "Parameter_modifiers_can_only_be_used_in_TypeScript_files_8012", "Parameter modifiers can only be used in TypeScript files."), | |
| Non_null_assertions_can_only_be_used_in_TypeScript_files: diag(8013, ts_DiagnosticCategory.Error, "Non_null_assertions_can_only_be_used_in_TypeScript_files_8013", "Non-null assertions can only be used in TypeScript files."), | |
| Type_assertion_expressions_can_only_be_used_in_TypeScript_files: diag(8016, ts_DiagnosticCategory.Error, "Type_assertion_expressions_can_only_be_used_in_TypeScript_files_8016", "Type assertion expressions can only be used in TypeScript files."), | |
| Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0: diag(8017, ts_DiagnosticCategory.Error, "Octal_literal_types_must_use_ES2015_syntax_Use_the_syntax_0_8017", "Octal literal types must use ES2015 syntax. Use the syntax '{0}'."), | |
| Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0: diag(8018, ts_DiagnosticCategory.Error, "Octal_literals_are_not_allowed_in_enums_members_initializer_Use_the_syntax_0_8018", "Octal literals are not allowed in enums members initializer. Use the syntax '{0}'."), | |
| Report_errors_in_js_files: diag(8019, ts_DiagnosticCategory.Message, "Report_errors_in_js_files_8019", "Report errors in .js files."), | |
| JSDoc_types_can_only_be_used_inside_documentation_comments: diag(8020, ts_DiagnosticCategory.Error, "JSDoc_types_can_only_be_used_inside_documentation_comments_8020", "JSDoc types can only be used inside documentation comments."), | |
| JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags: diag(8021, ts_DiagnosticCategory.Error, "JSDoc_typedef_tag_should_either_have_a_type_annotation_or_be_followed_by_property_or_member_tags_8021", "JSDoc '@typedef' tag should either have a type annotation or be followed by '@property' or '@member' tags."), | |
| JSDoc_0_is_not_attached_to_a_class: diag(8022, ts_DiagnosticCategory.Error, "JSDoc_0_is_not_attached_to_a_class_8022", "JSDoc '@{0}' is not attached to a class."), | |
| JSDoc_0_1_does_not_match_the_extends_2_clause: diag(8023, ts_DiagnosticCategory.Error, "JSDoc_0_1_does_not_match_the_extends_2_clause_8023", "JSDoc '@{0} {1}' does not match the 'extends {2}' clause."), | |
| JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name: diag(8024, ts_DiagnosticCategory.Error, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_8024", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name."), | |
| Class_declarations_cannot_have_more_than_one_augments_or_extends_tag: diag(8025, ts_DiagnosticCategory.Error, "Class_declarations_cannot_have_more_than_one_augments_or_extends_tag_8025", "Class declarations cannot have more than one `@augments` or `@extends` tag."), | |
| Expected_0_type_arguments_provide_these_with_an_extends_tag: diag(8026, ts_DiagnosticCategory.Error, "Expected_0_type_arguments_provide_these_with_an_extends_tag_8026", "Expected {0} type arguments; provide these with an '@extends' tag."), | |
| Expected_0_1_type_arguments_provide_these_with_an_extends_tag: diag(8027, ts_DiagnosticCategory.Error, "Expected_0_1_type_arguments_provide_these_with_an_extends_tag_8027", "Expected {0}-{1} type arguments; provide these with an '@extends' tag."), | |
| JSDoc_may_only_appear_in_the_last_parameter_of_a_signature: diag(8028, ts_DiagnosticCategory.Error, "JSDoc_may_only_appear_in_the_last_parameter_of_a_signature_8028", "JSDoc '...' may only appear in the last parameter of a signature."), | |
| JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_had_an_array_type: diag(8029, ts_DiagnosticCategory.Error, "JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name_It_would_match_arguments_if_it_h_8029", "JSDoc '@param' tag has name '{0}', but there is no parameter with that name. It would match 'arguments' if it had an array type."), | |
| The_type_of_a_function_declaration_must_match_the_function_s_signature: diag(8030, ts_DiagnosticCategory.Error, "The_type_of_a_function_declaration_must_match_the_function_s_signature_8030", "The type of a function declaration must match the function's signature."), | |
| You_cannot_rename_a_module_via_a_global_import: diag(8031, ts_DiagnosticCategory.Error, "You_cannot_rename_a_module_via_a_global_import_8031", "You cannot rename a module via a global import."), | |
| Qualified_name_0_is_not_allowed_without_a_leading_param_object_1: diag(8032, ts_DiagnosticCategory.Error, "Qualified_name_0_is_not_allowed_without_a_leading_param_object_1_8032", "Qualified name '{0}' is not allowed without a leading '@param {object} {1}'."), | |
| Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clause: diag(9002, ts_DiagnosticCategory.Error, "Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_clas_9002", "Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clause."), | |
| class_expressions_are_not_currently_supported: diag(9003, ts_DiagnosticCategory.Error, "class_expressions_are_not_currently_supported_9003", "'class' expressions are not currently supported."), | |
| Language_service_is_disabled: diag(9004, ts_DiagnosticCategory.Error, "Language_service_is_disabled_9004", "Language service is disabled."), | |
| Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9005, ts_DiagnosticCategory.Error, "Declaration_emit_for_this_file_requires_using_private_name_0_An_explicit_type_annotation_may_unblock_9005", "Declaration emit for this file requires using private name '{0}'. An explicit type annotation may unblock declaration emit."), | |
| Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotation_may_unblock_declaration_emit: diag(9006, ts_DiagnosticCategory.Error, "Declaration_emit_for_this_file_requires_using_private_name_0_from_module_1_An_explicit_type_annotati_9006", "Declaration emit for this file requires using private name '{0}' from module '{1}'. An explicit type annotation may unblock declaration emit."), | |
| JSX_attributes_must_only_be_assigned_a_non_empty_expression: diag(17000, ts_DiagnosticCategory.Error, "JSX_attributes_must_only_be_assigned_a_non_empty_expression_17000", "JSX attributes must only be assigned a non-empty 'expression'."), | |
| JSX_elements_cannot_have_multiple_attributes_with_the_same_name: diag(17001, ts_DiagnosticCategory.Error, "JSX_elements_cannot_have_multiple_attributes_with_the_same_name_17001", "JSX elements cannot have multiple attributes with the same name."), | |
| Expected_corresponding_JSX_closing_tag_for_0: diag(17002, ts_DiagnosticCategory.Error, "Expected_corresponding_JSX_closing_tag_for_0_17002", "Expected corresponding JSX closing tag for '{0}'."), | |
| JSX_attribute_expected: diag(17003, ts_DiagnosticCategory.Error, "JSX_attribute_expected_17003", "JSX attribute expected."), | |
| Cannot_use_JSX_unless_the_jsx_flag_is_provided: diag(17004, ts_DiagnosticCategory.Error, "Cannot_use_JSX_unless_the_jsx_flag_is_provided_17004", "Cannot use JSX unless the '--jsx' flag is provided."), | |
| A_constructor_cannot_contain_a_super_call_when_its_class_extends_null: diag(17005, ts_DiagnosticCategory.Error, "A_constructor_cannot_contain_a_super_call_when_its_class_extends_null_17005", "A constructor cannot contain a 'super' call when its class extends 'null'."), | |
| An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: diag(17006, ts_DiagnosticCategory.Error, "An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_ex_17006", "An unary expression with the '{0}' operator is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."), | |
| A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses: diag(17007, ts_DiagnosticCategory.Error, "A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Con_17007", "A type assertion expression is not allowed in the left-hand side of an exponentiation expression. Consider enclosing the expression in parentheses."), | |
| JSX_element_0_has_no_corresponding_closing_tag: diag(17008, ts_DiagnosticCategory.Error, "JSX_element_0_has_no_corresponding_closing_tag_17008", "JSX element '{0}' has no corresponding closing tag."), | |
| super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class: diag(17009, ts_DiagnosticCategory.Error, "super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class_17009", "'super' must be called before accessing 'this' in the constructor of a derived class."), | |
| Unknown_type_acquisition_option_0: diag(17010, ts_DiagnosticCategory.Error, "Unknown_type_acquisition_option_0_17010", "Unknown type acquisition option '{0}'."), | |
| super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class: diag(17011, ts_DiagnosticCategory.Error, "super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class_17011", "'super' must be called before accessing a property of 'super' in the constructor of a derived class."), | |
| _0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2: diag(17012, ts_DiagnosticCategory.Error, "_0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2_17012", "'{0}' is not a valid meta-property for keyword '{1}'. Did you mean '{2}'?"), | |
| Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constructor: diag(17013, ts_DiagnosticCategory.Error, "Meta_property_0_is_only_allowed_in_the_body_of_a_function_declaration_function_expression_or_constru_17013", "Meta-property '{0}' is only allowed in the body of a function declaration, function expression, or constructor."), | |
| JSX_fragment_has_no_corresponding_closing_tag: diag(17014, ts_DiagnosticCategory.Error, "JSX_fragment_has_no_corresponding_closing_tag_17014", "JSX fragment has no corresponding closing tag."), | |
| Expected_corresponding_closing_tag_for_JSX_fragment: diag(17015, ts_DiagnosticCategory.Error, "Expected_corresponding_closing_tag_for_JSX_fragment_17015", "Expected corresponding closing tag for JSX fragment."), | |
| JSX_fragment_is_not_supported_when_using_jsxFactory: diag(17016, ts_DiagnosticCategory.Error, "JSX_fragment_is_not_supported_when_using_jsxFactory_17016", "JSX fragment is not supported when using --jsxFactory"), | |
| JSX_fragment_is_not_supported_when_using_an_inline_JSX_factory_pragma: diag(17017, ts_DiagnosticCategory.Error, "JSX_fragment_is_not_supported_when_using_an_inline_JSX_factory_pragma_17017", "JSX fragment is not supported when using an inline JSX factory pragma"), | |
| Unknown_type_acquisition_option_0_Did_you_mean_1: diag(17018, ts_DiagnosticCategory.Error, "Unknown_type_acquisition_option_0_Did_you_mean_1_17018", "Unknown type acquisition option '{0}'. Did you mean '{1}'?"), | |
| Circularity_detected_while_resolving_configuration_Colon_0: diag(18000, ts_DiagnosticCategory.Error, "Circularity_detected_while_resolving_configuration_Colon_0_18000", "Circularity detected while resolving configuration: {0}"), | |
| A_path_in_an_extends_option_must_be_relative_or_rooted_but_0_is_not: diag(18001, ts_DiagnosticCategory.Error, "A_path_in_an_extends_option_must_be_relative_or_rooted_but_0_is_not_18001", "A path in an 'extends' option must be relative or rooted, but '{0}' is not."), | |
| The_files_list_in_config_file_0_is_empty: diag(18002, ts_DiagnosticCategory.Error, "The_files_list_in_config_file_0_is_empty_18002", "The 'files' list in config file '{0}' is empty."), | |
| No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2: diag(18003, ts_DiagnosticCategory.Error, "No_inputs_were_found_in_config_file_0_Specified_include_paths_were_1_and_exclude_paths_were_2_18003", "No inputs were found in config file '{0}'. Specified 'include' paths were '{1}' and 'exclude' paths were '{2}'."), | |
| File_is_a_CommonJS_module_it_may_be_converted_to_an_ES6_module: diag(80001, ts_DiagnosticCategory.Suggestion, "File_is_a_CommonJS_module_it_may_be_converted_to_an_ES6_module_80001", "File is a CommonJS module; it may be converted to an ES6 module."), | |
| This_constructor_function_may_be_converted_to_a_class_declaration: diag(80002, ts_DiagnosticCategory.Suggestion, "This_constructor_function_may_be_converted_to_a_class_declaration_80002", "This constructor function may be converted to a class declaration."), | |
| Import_may_be_converted_to_a_default_import: diag(80003, ts_DiagnosticCategory.Suggestion, "Import_may_be_converted_to_a_default_import_80003", "Import may be converted to a default import."), | |
| JSDoc_types_may_be_moved_to_TypeScript_types: diag(80004, ts_DiagnosticCategory.Suggestion, "JSDoc_types_may_be_moved_to_TypeScript_types_80004", "JSDoc types may be moved to TypeScript types."), | |
| require_call_may_be_converted_to_an_import: diag(80005, ts_DiagnosticCategory.Suggestion, "require_call_may_be_converted_to_an_import_80005", "'require' call may be converted to an import."), | |
| This_may_be_converted_to_an_async_function: diag(80006, ts_DiagnosticCategory.Suggestion, "This_may_be_converted_to_an_async_function_80006", "This may be converted to an async function."), | |
| await_has_no_effect_on_the_type_of_this_expression: diag(80007, ts_DiagnosticCategory.Suggestion, "await_has_no_effect_on_the_type_of_this_expression_80007", "'await' has no effect on the type of this expression."), | |
| Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accurately_as_integers: diag(80008, ts_DiagnosticCategory.Suggestion, "Numeric_literals_with_absolute_values_equal_to_2_53_or_greater_are_too_large_to_be_represented_accur_80008", "Numeric literals with absolute values equal to 2^53 or greater are too large to be represented accurately as integers."), | |
| Add_missing_super_call: diag(90001, ts_DiagnosticCategory.Message, "Add_missing_super_call_90001", "Add missing 'super()' call"), | |
| Make_super_call_the_first_statement_in_the_constructor: diag(90002, ts_DiagnosticCategory.Message, "Make_super_call_the_first_statement_in_the_constructor_90002", "Make 'super()' call the first statement in the constructor"), | |
| Change_extends_to_implements: diag(90003, ts_DiagnosticCategory.Message, "Change_extends_to_implements_90003", "Change 'extends' to 'implements'"), | |
| Remove_unused_declaration_for_Colon_0: diag(90004, ts_DiagnosticCategory.Message, "Remove_unused_declaration_for_Colon_0_90004", "Remove unused declaration for: '{0}'"), | |
| Remove_import_from_0: diag(90005, ts_DiagnosticCategory.Message, "Remove_import_from_0_90005", "Remove import from '{0}'"), | |
| Implement_interface_0: diag(90006, ts_DiagnosticCategory.Message, "Implement_interface_0_90006", "Implement interface '{0}'"), | |
| Implement_inherited_abstract_class: diag(90007, ts_DiagnosticCategory.Message, "Implement_inherited_abstract_class_90007", "Implement inherited abstract class"), | |
| Add_0_to_unresolved_variable: diag(90008, ts_DiagnosticCategory.Message, "Add_0_to_unresolved_variable_90008", "Add '{0}.' to unresolved variable"), | |
| Remove_destructuring: diag(90009, ts_DiagnosticCategory.Message, "Remove_destructuring_90009", "Remove destructuring"), | |
| Remove_variable_statement: diag(90010, ts_DiagnosticCategory.Message, "Remove_variable_statement_90010", "Remove variable statement"), | |
| Remove_template_tag: diag(90011, ts_DiagnosticCategory.Message, "Remove_template_tag_90011", "Remove template tag"), | |
| Remove_type_parameters: diag(90012, ts_DiagnosticCategory.Message, "Remove_type_parameters_90012", "Remove type parameters"), | |
| Import_0_from_module_1: diag(90013, ts_DiagnosticCategory.Message, "Import_0_from_module_1_90013", "Import '{0}' from module \"{1}\""), | |
| Change_0_to_1: diag(90014, ts_DiagnosticCategory.Message, "Change_0_to_1_90014", "Change '{0}' to '{1}'"), | |
| Add_0_to_existing_import_declaration_from_1: diag(90015, ts_DiagnosticCategory.Message, "Add_0_to_existing_import_declaration_from_1_90015", "Add '{0}' to existing import declaration from \"{1}\""), | |
| Declare_property_0: diag(90016, ts_DiagnosticCategory.Message, "Declare_property_0_90016", "Declare property '{0}'"), | |
| Add_index_signature_for_property_0: diag(90017, ts_DiagnosticCategory.Message, "Add_index_signature_for_property_0_90017", "Add index signature for property '{0}'"), | |
| Disable_checking_for_this_file: diag(90018, ts_DiagnosticCategory.Message, "Disable_checking_for_this_file_90018", "Disable checking for this file"), | |
| Ignore_this_error_message: diag(90019, ts_DiagnosticCategory.Message, "Ignore_this_error_message_90019", "Ignore this error message"), | |
| Initialize_property_0_in_the_constructor: diag(90020, ts_DiagnosticCategory.Message, "Initialize_property_0_in_the_constructor_90020", "Initialize property '{0}' in the constructor"), | |
| Initialize_static_property_0: diag(90021, ts_DiagnosticCategory.Message, "Initialize_static_property_0_90021", "Initialize static property '{0}'"), | |
| Change_spelling_to_0: diag(90022, ts_DiagnosticCategory.Message, "Change_spelling_to_0_90022", "Change spelling to '{0}'"), | |
| Declare_method_0: diag(90023, ts_DiagnosticCategory.Message, "Declare_method_0_90023", "Declare method '{0}'"), | |
| Declare_static_method_0: diag(90024, ts_DiagnosticCategory.Message, "Declare_static_method_0_90024", "Declare static method '{0}'"), | |
| Prefix_0_with_an_underscore: diag(90025, ts_DiagnosticCategory.Message, "Prefix_0_with_an_underscore_90025", "Prefix '{0}' with an underscore"), | |
| Rewrite_as_the_indexed_access_type_0: diag(90026, ts_DiagnosticCategory.Message, "Rewrite_as_the_indexed_access_type_0_90026", "Rewrite as the indexed access type '{0}'"), | |
| Declare_static_property_0: diag(90027, ts_DiagnosticCategory.Message, "Declare_static_property_0_90027", "Declare static property '{0}'"), | |
| Call_decorator_expression: diag(90028, ts_DiagnosticCategory.Message, "Call_decorator_expression_90028", "Call decorator expression"), | |
| Add_async_modifier_to_containing_function: diag(90029, ts_DiagnosticCategory.Message, "Add_async_modifier_to_containing_function_90029", "Add async modifier to containing function"), | |
| Replace_infer_0_with_unknown: diag(90030, ts_DiagnosticCategory.Message, "Replace_infer_0_with_unknown_90030", "Replace 'infer {0}' with 'unknown'"), | |
| Replace_all_unused_infer_with_unknown: diag(90031, ts_DiagnosticCategory.Message, "Replace_all_unused_infer_with_unknown_90031", "Replace all unused 'infer' with 'unknown'"), | |
| Import_default_0_from_module_1: diag(90032, ts_DiagnosticCategory.Message, "Import_default_0_from_module_1_90032", "Import default '{0}' from module \"{1}\""), | |
| Add_default_import_0_to_existing_import_declaration_from_1: diag(90033, ts_DiagnosticCategory.Message, "Add_default_import_0_to_existing_import_declaration_from_1_90033", "Add default import '{0}' to existing import declaration from \"{1}\""), | |
| Add_parameter_name: diag(90034, ts_DiagnosticCategory.Message, "Add_parameter_name_90034", "Add parameter name"), | |
| Declare_a_private_field_named_0: diag(90053, ts_DiagnosticCategory.Message, "Declare_a_private_field_named_0_90053", "Declare a private field named '{0}'."), | |
| Convert_function_to_an_ES2015_class: diag(95001, ts_DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"), | |
| Convert_function_0_to_class: diag(95002, ts_DiagnosticCategory.Message, "Convert_function_0_to_class_95002", "Convert function '{0}' to class"), | |
| Extract_to_0_in_1: diag(95004, ts_DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"), | |
| Extract_function: diag(95005, ts_DiagnosticCategory.Message, "Extract_function_95005", "Extract function"), | |
| Extract_constant: diag(95006, ts_DiagnosticCategory.Message, "Extract_constant_95006", "Extract constant"), | |
| Extract_to_0_in_enclosing_scope: diag(95007, ts_DiagnosticCategory.Message, "Extract_to_0_in_enclosing_scope_95007", "Extract to {0} in enclosing scope"), | |
| Extract_to_0_in_1_scope: diag(95008, ts_DiagnosticCategory.Message, "Extract_to_0_in_1_scope_95008", "Extract to {0} in {1} scope"), | |
| Annotate_with_type_from_JSDoc: diag(95009, ts_DiagnosticCategory.Message, "Annotate_with_type_from_JSDoc_95009", "Annotate with type from JSDoc"), | |
| Annotate_with_types_from_JSDoc: diag(95010, ts_DiagnosticCategory.Message, "Annotate_with_types_from_JSDoc_95010", "Annotate with types from JSDoc"), | |
| Infer_type_of_0_from_usage: diag(95011, ts_DiagnosticCategory.Message, "Infer_type_of_0_from_usage_95011", "Infer type of '{0}' from usage"), | |
| Infer_parameter_types_from_usage: diag(95012, ts_DiagnosticCategory.Message, "Infer_parameter_types_from_usage_95012", "Infer parameter types from usage"), | |
| Convert_to_default_import: diag(95013, ts_DiagnosticCategory.Message, "Convert_to_default_import_95013", "Convert to default import"), | |
| Install_0: diag(95014, ts_DiagnosticCategory.Message, "Install_0_95014", "Install '{0}'"), | |
| Replace_import_with_0: diag(95015, ts_DiagnosticCategory.Message, "Replace_import_with_0_95015", "Replace import with '{0}'."), | |
| Use_synthetic_default_member: diag(95016, ts_DiagnosticCategory.Message, "Use_synthetic_default_member_95016", "Use synthetic 'default' member."), | |
| Convert_to_ES6_module: diag(95017, ts_DiagnosticCategory.Message, "Convert_to_ES6_module_95017", "Convert to ES6 module"), | |
| Add_undefined_type_to_property_0: diag(95018, ts_DiagnosticCategory.Message, "Add_undefined_type_to_property_0_95018", "Add 'undefined' type to property '{0}'"), | |
| Add_initializer_to_property_0: diag(95019, ts_DiagnosticCategory.Message, "Add_initializer_to_property_0_95019", "Add initializer to property '{0}'"), | |
| Add_definite_assignment_assertion_to_property_0: diag(95020, ts_DiagnosticCategory.Message, "Add_definite_assignment_assertion_to_property_0_95020", "Add definite assignment assertion to property '{0}'"), | |
| Add_all_missing_members: diag(95022, ts_DiagnosticCategory.Message, "Add_all_missing_members_95022", "Add all missing members"), | |
| Infer_all_types_from_usage: diag(95023, ts_DiagnosticCategory.Message, "Infer_all_types_from_usage_95023", "Infer all types from usage"), | |
| Delete_all_unused_declarations: diag(95024, ts_DiagnosticCategory.Message, "Delete_all_unused_declarations_95024", "Delete all unused declarations"), | |
| Prefix_all_unused_declarations_with_where_possible: diag(95025, ts_DiagnosticCategory.Message, "Prefix_all_unused_declarations_with_where_possible_95025", "Prefix all unused declarations with '_' where possible"), | |
| Fix_all_detected_spelling_errors: diag(95026, ts_DiagnosticCategory.Message, "Fix_all_detected_spelling_errors_95026", "Fix all detected spelling errors"), | |
| Add_initializers_to_all_uninitialized_properties: diag(95027, ts_DiagnosticCategory.Message, "Add_initializers_to_all_uninitialized_properties_95027", "Add initializers to all uninitialized properties"), | |
| Add_definite_assignment_assertions_to_all_uninitialized_properties: diag(95028, ts_DiagnosticCategory.Message, "Add_definite_assignment_assertions_to_all_uninitialized_properties_95028", "Add definite assignment assertions to all uninitialized properties"), | |
| Add_undefined_type_to_all_uninitialized_properties: diag(95029, ts_DiagnosticCategory.Message, "Add_undefined_type_to_all_uninitialized_properties_95029", "Add undefined type to all uninitialized properties"), | |
| Change_all_jsdoc_style_types_to_TypeScript: diag(95030, ts_DiagnosticCategory.Message, "Change_all_jsdoc_style_types_to_TypeScript_95030", "Change all jsdoc-style types to TypeScript"), | |
| Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types: diag(95031, ts_DiagnosticCategory.Message, "Change_all_jsdoc_style_types_to_TypeScript_and_add_undefined_to_nullable_types_95031", "Change all jsdoc-style types to TypeScript (and add '| undefined' to nullable types)"), | |
| Implement_all_unimplemented_interfaces: diag(95032, ts_DiagnosticCategory.Message, "Implement_all_unimplemented_interfaces_95032", "Implement all unimplemented interfaces"), | |
| Install_all_missing_types_packages: diag(95033, ts_DiagnosticCategory.Message, "Install_all_missing_types_packages_95033", "Install all missing types packages"), | |
| Rewrite_all_as_indexed_access_types: diag(95034, ts_DiagnosticCategory.Message, "Rewrite_all_as_indexed_access_types_95034", "Rewrite all as indexed access types"), | |
| Convert_all_to_default_imports: diag(95035, ts_DiagnosticCategory.Message, "Convert_all_to_default_imports_95035", "Convert all to default imports"), | |
| Make_all_super_calls_the_first_statement_in_their_constructor: diag(95036, ts_DiagnosticCategory.Message, "Make_all_super_calls_the_first_statement_in_their_constructor_95036", "Make all 'super()' calls the first statement in their constructor"), | |
| Add_qualifier_to_all_unresolved_variables_matching_a_member_name: diag(95037, ts_DiagnosticCategory.Message, "Add_qualifier_to_all_unresolved_variables_matching_a_member_name_95037", "Add qualifier to all unresolved variables matching a member name"), | |
| Change_all_extended_interfaces_to_implements: diag(95038, ts_DiagnosticCategory.Message, "Change_all_extended_interfaces_to_implements_95038", "Change all extended interfaces to 'implements'"), | |
| Add_all_missing_super_calls: diag(95039, ts_DiagnosticCategory.Message, "Add_all_missing_super_calls_95039", "Add all missing super calls"), | |
| Implement_all_inherited_abstract_classes: diag(95040, ts_DiagnosticCategory.Message, "Implement_all_inherited_abstract_classes_95040", "Implement all inherited abstract classes"), | |
| Add_all_missing_async_modifiers: diag(95041, ts_DiagnosticCategory.Message, "Add_all_missing_async_modifiers_95041", "Add all missing 'async' modifiers"), | |
| Add_ts_ignore_to_all_error_messages: diag(95042, ts_DiagnosticCategory.Message, "Add_ts_ignore_to_all_error_messages_95042", "Add '@ts-ignore' to all error messages"), | |
| Annotate_everything_with_types_from_JSDoc: diag(95043, ts_DiagnosticCategory.Message, "Annotate_everything_with_types_from_JSDoc_95043", "Annotate everything with types from JSDoc"), | |
| Add_to_all_uncalled_decorators: diag(95044, ts_DiagnosticCategory.Message, "Add_to_all_uncalled_decorators_95044", "Add '()' to all uncalled decorators"), | |
| Convert_all_constructor_functions_to_classes: diag(95045, ts_DiagnosticCategory.Message, "Convert_all_constructor_functions_to_classes_95045", "Convert all constructor functions to classes"), | |
| Generate_get_and_set_accessors: diag(95046, ts_DiagnosticCategory.Message, "Generate_get_and_set_accessors_95046", "Generate 'get' and 'set' accessors"), | |
| Convert_require_to_import: diag(95047, ts_DiagnosticCategory.Message, "Convert_require_to_import_95047", "Convert 'require' to 'import'"), | |
| Convert_all_require_to_import: diag(95048, ts_DiagnosticCategory.Message, "Convert_all_require_to_import_95048", "Convert all 'require' to 'import'"), | |
| Move_to_a_new_file: diag(95049, ts_DiagnosticCategory.Message, "Move_to_a_new_file_95049", "Move to a new file"), | |
| Remove_unreachable_code: diag(95050, ts_DiagnosticCategory.Message, "Remove_unreachable_code_95050", "Remove unreachable code"), | |
| Remove_all_unreachable_code: diag(95051, ts_DiagnosticCategory.Message, "Remove_all_unreachable_code_95051", "Remove all unreachable code"), | |
| Add_missing_typeof: diag(95052, ts_DiagnosticCategory.Message, "Add_missing_typeof_95052", "Add missing 'typeof'"), | |
| Remove_unused_label: diag(95053, ts_DiagnosticCategory.Message, "Remove_unused_label_95053", "Remove unused label"), | |
| Remove_all_unused_labels: diag(95054, ts_DiagnosticCategory.Message, "Remove_all_unused_labels_95054", "Remove all unused labels"), | |
| Convert_0_to_mapped_object_type: diag(95055, ts_DiagnosticCategory.Message, "Convert_0_to_mapped_object_type_95055", "Convert '{0}' to mapped object type"), | |
| Convert_namespace_import_to_named_imports: diag(95056, ts_DiagnosticCategory.Message, "Convert_namespace_import_to_named_imports_95056", "Convert namespace import to named imports"), | |
| Convert_named_imports_to_namespace_import: diag(95057, ts_DiagnosticCategory.Message, "Convert_named_imports_to_namespace_import_95057", "Convert named imports to namespace import"), | |
| Add_or_remove_braces_in_an_arrow_function: diag(95058, ts_DiagnosticCategory.Message, "Add_or_remove_braces_in_an_arrow_function_95058", "Add or remove braces in an arrow function"), | |
| Add_braces_to_arrow_function: diag(95059, ts_DiagnosticCategory.Message, "Add_braces_to_arrow_function_95059", "Add braces to arrow function"), | |
| Remove_braces_from_arrow_function: diag(95060, ts_DiagnosticCategory.Message, "Remove_braces_from_arrow_function_95060", "Remove braces from arrow function"), | |
| Convert_default_export_to_named_export: diag(95061, ts_DiagnosticCategory.Message, "Convert_default_export_to_named_export_95061", "Convert default export to named export"), | |
| Convert_named_export_to_default_export: diag(95062, ts_DiagnosticCategory.Message, "Convert_named_export_to_default_export_95062", "Convert named export to default export"), | |
| Add_missing_enum_member_0: diag(95063, ts_DiagnosticCategory.Message, "Add_missing_enum_member_0_95063", "Add missing enum member '{0}'"), | |
| Add_all_missing_imports: diag(95064, ts_DiagnosticCategory.Message, "Add_all_missing_imports_95064", "Add all missing imports"), | |
| Convert_to_async_function: diag(95065, ts_DiagnosticCategory.Message, "Convert_to_async_function_95065", "Convert to async function"), | |
| Convert_all_to_async_functions: diag(95066, ts_DiagnosticCategory.Message, "Convert_all_to_async_functions_95066", "Convert all to async functions"), | |
| Add_unknown_conversion_for_non_overlapping_types: diag(95069, ts_DiagnosticCategory.Message, "Add_unknown_conversion_for_non_overlapping_types_95069", "Add 'unknown' conversion for non-overlapping types"), | |
| Add_unknown_to_all_conversions_of_non_overlapping_types: diag(95070, ts_DiagnosticCategory.Message, "Add_unknown_to_all_conversions_of_non_overlapping_types_95070", "Add 'unknown' to all conversions of non-overlapping types"), | |
| Add_missing_new_operator_to_call: diag(95071, ts_DiagnosticCategory.Message, "Add_missing_new_operator_to_call_95071", "Add missing 'new' operator to call"), | |
| Add_missing_new_operator_to_all_calls: diag(95072, ts_DiagnosticCategory.Message, "Add_missing_new_operator_to_all_calls_95072", "Add missing 'new' operator to all calls"), | |
| Add_names_to_all_parameters_without_names: diag(95073, ts_DiagnosticCategory.Message, "Add_names_to_all_parameters_without_names_95073", "Add names to all parameters without names"), | |
| Enable_the_experimentalDecorators_option_in_your_configuration_file: diag(95074, ts_DiagnosticCategory.Message, "Enable_the_experimentalDecorators_option_in_your_configuration_file_95074", "Enable the 'experimentalDecorators' option in your configuration file"), | |
| Convert_parameters_to_destructured_object: diag(95075, ts_DiagnosticCategory.Message, "Convert_parameters_to_destructured_object_95075", "Convert parameters to destructured object"), | |
| Allow_accessing_UMD_globals_from_modules: diag(95076, ts_DiagnosticCategory.Message, "Allow_accessing_UMD_globals_from_modules_95076", "Allow accessing UMD globals from modules."), | |
| Extract_type: diag(95077, ts_DiagnosticCategory.Message, "Extract_type_95077", "Extract type"), | |
| Extract_to_type_alias: diag(95078, ts_DiagnosticCategory.Message, "Extract_to_type_alias_95078", "Extract to type alias"), | |
| Extract_to_typedef: diag(95079, ts_DiagnosticCategory.Message, "Extract_to_typedef_95079", "Extract to typedef"), | |
| Infer_this_type_of_0_from_usage: diag(95080, ts_DiagnosticCategory.Message, "Infer_this_type_of_0_from_usage_95080", "Infer 'this' type of '{0}' from usage"), | |
| Add_const_to_unresolved_variable: diag(95081, ts_DiagnosticCategory.Message, "Add_const_to_unresolved_variable_95081", "Add 'const' to unresolved variable"), | |
| Add_const_to_all_unresolved_variables: diag(95082, ts_DiagnosticCategory.Message, "Add_const_to_all_unresolved_variables_95082", "Add 'const' to all unresolved variables"), | |
| Add_await: diag(95083, ts_DiagnosticCategory.Message, "Add_await_95083", "Add 'await'"), | |
| Add_await_to_initializer_for_0: diag(95084, ts_DiagnosticCategory.Message, "Add_await_to_initializer_for_0_95084", "Add 'await' to initializer for '{0}'"), | |
| Fix_all_expressions_possibly_missing_await: diag(95085, ts_DiagnosticCategory.Message, "Fix_all_expressions_possibly_missing_await_95085", "Fix all expressions possibly missing 'await'"), | |
| Remove_unnecessary_await: diag(95086, ts_DiagnosticCategory.Message, "Remove_unnecessary_await_95086", "Remove unnecessary 'await'"), | |
| Remove_all_unnecessary_uses_of_await: diag(95087, ts_DiagnosticCategory.Message, "Remove_all_unnecessary_uses_of_await_95087", "Remove all unnecessary uses of 'await'"), | |
| Enable_the_jsx_flag_in_your_configuration_file: diag(95088, ts_DiagnosticCategory.Message, "Enable_the_jsx_flag_in_your_configuration_file_95088", "Enable the '--jsx' flag in your configuration file"), | |
| Add_await_to_initializers: diag(95089, ts_DiagnosticCategory.Message, "Add_await_to_initializers_95089", "Add 'await' to initializers"), | |
| Extract_to_interface: diag(95090, ts_DiagnosticCategory.Message, "Extract_to_interface_95090", "Extract to interface"), | |
| Convert_to_a_bigint_numeric_literal: diag(95091, ts_DiagnosticCategory.Message, "Convert_to_a_bigint_numeric_literal_95091", "Convert to a bigint numeric literal"), | |
| Convert_all_to_bigint_numeric_literals: diag(95092, ts_DiagnosticCategory.Message, "Convert_all_to_bigint_numeric_literals_95092", "Convert all to bigint numeric literals"), | |
| Convert_const_to_let: diag(95093, ts_DiagnosticCategory.Message, "Convert_const_to_let_95093", "Convert 'const' to 'let'"), | |
| Prefix_with_declare: diag(95094, ts_DiagnosticCategory.Message, "Prefix_with_declare_95094", "Prefix with 'declare'"), | |
| Prefix_all_incorrect_property_declarations_with_declare: diag(95095, ts_DiagnosticCategory.Message, "Prefix_all_incorrect_property_declarations_with_declare_95095", "Prefix all incorrect property declarations with 'declare'"), | |
| Convert_to_template_string: diag(95096, ts_DiagnosticCategory.Message, "Convert_to_template_string_95096", "Convert to template string"), | |
| Add_export_to_make_this_file_into_a_module: diag(95097, ts_DiagnosticCategory.Message, "Add_export_to_make_this_file_into_a_module_95097", "Add 'export {}' to make this file into a module"), | |
| Set_the_target_option_in_your_configuration_file_to_0: diag(95098, ts_DiagnosticCategory.Message, "Set_the_target_option_in_your_configuration_file_to_0_95098", "Set the 'target' option in your configuration file to '{0}'"), | |
| Set_the_module_option_in_your_configuration_file_to_0: diag(95099, ts_DiagnosticCategory.Message, "Set_the_module_option_in_your_configuration_file_to_0_95099", "Set the 'module' option in your configuration file to '{0}'"), | |
| No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, ts_DiagnosticCategory.Error, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."), | |
| Classes_may_not_have_a_field_named_constructor: diag(18006, ts_DiagnosticCategory.Error, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."), | |
| JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, ts_DiagnosticCategory.Error, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"), | |
| Private_identifiers_cannot_be_used_as_parameters: diag(18009, ts_DiagnosticCategory.Error, "Private_identifiers_cannot_be_used_as_parameters_18009", "Private identifiers cannot be used as parameters"), | |
| An_accessibility_modifier_cannot_be_used_with_a_private_identifier: diag(18010, ts_DiagnosticCategory.Error, "An_accessibility_modifier_cannot_be_used_with_a_private_identifier_18010", "An accessibility modifier cannot be used with a private identifier."), | |
| The_operand_of_a_delete_operator_cannot_be_a_private_identifier: diag(18011, ts_DiagnosticCategory.Error, "The_operand_of_a_delete_operator_cannot_be_a_private_identifier_18011", "The operand of a 'delete' operator cannot be a private identifier."), | |
| constructor_is_a_reserved_word: diag(18012, ts_DiagnosticCategory.Error, "constructor_is_a_reserved_word_18012", "'#constructor' is a reserved word."), | |
| Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier: diag(18013, ts_DiagnosticCategory.Error, "Property_0_is_not_accessible_outside_class_1_because_it_has_a_private_identifier_18013", "Property '{0}' is not accessible outside class '{1}' because it has a private identifier."), | |
| The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_private_identifier_with_the_same_spelling: diag(18014, ts_DiagnosticCategory.Error, "The_property_0_cannot_be_accessed_on_type_1_within_this_class_because_it_is_shadowed_by_another_priv_18014", "The property '{0}' cannot be accessed on type '{1}' within this class because it is shadowed by another private identifier with the same spelling."), | |
| Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2: diag(18015, ts_DiagnosticCategory.Error, "Property_0_in_type_1_refers_to_a_different_member_that_cannot_be_accessed_from_within_type_2_18015", "Property '{0}' in type '{1}' refers to a different member that cannot be accessed from within type '{2}'."), | |
| Private_identifiers_are_not_allowed_outside_class_bodies: diag(18016, ts_DiagnosticCategory.Error, "Private_identifiers_are_not_allowed_outside_class_bodies_18016", "Private identifiers are not allowed outside class bodies."), | |
| The_shadowing_declaration_of_0_is_defined_here: diag(18017, ts_DiagnosticCategory.Error, "The_shadowing_declaration_of_0_is_defined_here_18017", "The shadowing declaration of '{0}' is defined here"), | |
| The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here: diag(18018, ts_DiagnosticCategory.Error, "The_declaration_of_0_that_you_probably_intended_to_use_is_defined_here_18018", "The declaration of '{0}' that you probably intended to use is defined here"), | |
| _0_modifier_cannot_be_used_with_a_private_identifier: diag(18019, ts_DiagnosticCategory.Error, "_0_modifier_cannot_be_used_with_a_private_identifier_18019", "'{0}' modifier cannot be used with a private identifier"), | |
| A_method_cannot_be_named_with_a_private_identifier: diag(18022, ts_DiagnosticCategory.Error, "A_method_cannot_be_named_with_a_private_identifier_18022", "A method cannot be named with a private identifier."), | |
| An_accessor_cannot_be_named_with_a_private_identifier: diag(18023, ts_DiagnosticCategory.Error, "An_accessor_cannot_be_named_with_a_private_identifier_18023", "An accessor cannot be named with a private identifier."), | |
| An_enum_member_cannot_be_named_with_a_private_identifier: diag(18024, ts_DiagnosticCategory.Error, "An_enum_member_cannot_be_named_with_a_private_identifier_18024", "An enum member cannot be named with a private identifier."), | |
| can_only_be_used_at_the_start_of_a_file: diag(18026, ts_DiagnosticCategory.Error, "can_only_be_used_at_the_start_of_a_file_18026", "'#!' can only be used at the start of a file."), | |
| Compiler_reserves_name_0_when_emitting_private_identifier_downlevel: diag(18027, ts_DiagnosticCategory.Error, "Compiler_reserves_name_0_when_emitting_private_identifier_downlevel_18027", "Compiler reserves name '{0}' when emitting private identifier downlevel."), | |
| Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher: diag(18028, ts_DiagnosticCategory.Error, "Private_identifiers_are_only_available_when_targeting_ECMAScript_2015_and_higher_18028", "Private identifiers are only available when targeting ECMAScript 2015 and higher."), | |
| Private_identifiers_are_not_allowed_in_variable_declarations: diag(18029, ts_DiagnosticCategory.Error, "Private_identifiers_are_not_allowed_in_variable_declarations_18029", "Private identifiers are not allowed in variable declarations."), | |
| An_optional_chain_cannot_contain_private_identifiers: diag(18030, ts_DiagnosticCategory.Error, "An_optional_chain_cannot_contain_private_identifiers_18030", "An optional chain cannot contain private identifiers."), | |
| }; | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| var _a; | |
| function tokenIsIdentifierOrKeyword(token) { | |
| return token >= 75; | |
| } | |
| ts_tokenIsIdentifierOrKeyword = tokenIsIdentifierOrKeyword; | |
| function tokenIsIdentifierOrKeywordOrGreaterThan(token) { | |
| return token === 31 || tokenIsIdentifierOrKeyword(token); | |
| } | |
| ts_tokenIsIdentifierOrKeywordOrGreaterThan = tokenIsIdentifierOrKeywordOrGreaterThan; | |
| var textToKeywordObj = (_a = { | |
| abstract: 122, | |
| any: 125, | |
| as: 123, | |
| asserts: 124, | |
| bigint: 151, | |
| boolean: 128, | |
| break: 77, | |
| case: 78, | |
| catch: 79, | |
| class: 80, | |
| continue: 82, | |
| const: 81 | |
| }, | |
| _a["" + "constructor"] = 129, | |
| _a.debugger = 83, | |
| _a.declare = 130, | |
| _a.default = 84, | |
| _a.delete = 85, | |
| _a.do = 86, | |
| _a.else = 87, | |
| _a.enum = 88, | |
| _a.export = 89, | |
| _a.extends = 90, | |
| _a.false = 91, | |
| _a.finally = 92, | |
| _a.for = 93, | |
| _a.from = 149, | |
| _a.function = 94, | |
| _a.get = 131, | |
| _a.if = 95, | |
| _a.implements = 113, | |
| _a.import = 96, | |
| _a.in = 97, | |
| _a.infer = 132, | |
| _a.instanceof = 98, | |
| _a.interface = 114, | |
| _a.is = 133, | |
| _a.keyof = 134, | |
| _a.let = 115, | |
| _a.module = 135, | |
| _a.namespace = 136, | |
| _a.never = 137, | |
| _a.new = 99, | |
| _a.null = 100, | |
| _a.number = 140, | |
| _a.object = 141, | |
| _a.package = 116, | |
| _a.private = 117, | |
| _a.protected = 118, | |
| _a.public = 119, | |
| _a.readonly = 138, | |
| _a.require = 139, | |
| _a.global = 150, | |
| _a.return = 101, | |
| _a.set = 142, | |
| _a.static = 120, | |
| _a.string = 143, | |
| _a.super = 102, | |
| _a.switch = 103, | |
| _a.symbol = 144, | |
| _a.this = 104, | |
| _a.throw = 105, | |
| _a.true = 106, | |
| _a.try = 107, | |
| _a.type = 145, | |
| _a.typeof = 108, | |
| _a.undefined = 146, | |
| _a.unique = 147, | |
| _a.unknown = 148, | |
| _a.var = 109, | |
| _a.void = 110, | |
| _a.while = 111, | |
| _a.with = 112, | |
| _a.yield = 121, | |
| _a.async = 126, | |
| _a.await = 127, | |
| _a.of = 152, | |
| _a); | |
| var textToKeyword = ts_createMapFromTemplate(textToKeywordObj); | |
| var textToToken = ts_createMapFromTemplate(__assign(__assign({}, textToKeywordObj), { "{": 18, "}": 19, "(": 20, ")": 21, "[": 22, "]": 23, ".": 24, "...": 25, ";": 26, ",": 27, "<": 29, ">": 31, "<=": 32, ">=": 33, "==": 34, "!=": 35, "===": 36, "!==": 37, "=>": 38, "+": 39, "-": 40, "**": 42, "*": 41, "/": 43, "%": 44, "++": 45, "--": 46, "<<": 47, "</": 30, ">>": 48, ">>>": 49, "&": 50, "|": 51, "^": 52, "!": 53, "~": 54, "&&": 55, "||": 56, "?": 57, "??": 60, "?.": 28, ":": 58, "=": 62, "+=": 63, "-=": 64, "*=": 65, "**=": 66, "/=": 67, "%=": 68, "<<=": 69, ">>=": 70, ">>>=": 71, "&=": 72, "|=": 73, "^=": 74, "@": 59, "`": 61 })); | |
| var unicodeES3IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1610, 1649, 1747, 1749, 1749, 1765, 1766, 1786, 1788, 1808, 1808, 1810, 1836, 1920, 1957, 2309, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2784, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3294, 3294, 3296, 3297, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3424, 3425, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3805, 3840, 3840, 3904, 3911, 3913, 3946, 3976, 3979, 4096, 4129, 4131, 4135, 4137, 4138, 4176, 4181, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6067, 6176, 6263, 6272, 6312, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8319, 8319, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12346, 12353, 12436, 12445, 12446, 12449, 12538, 12540, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65138, 65140, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; | |
| var unicodeES3IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 543, 546, 563, 592, 685, 688, 696, 699, 705, 720, 721, 736, 740, 750, 750, 768, 846, 864, 866, 890, 890, 902, 902, 904, 906, 908, 908, 910, 929, 931, 974, 976, 983, 986, 1011, 1024, 1153, 1155, 1158, 1164, 1220, 1223, 1224, 1227, 1228, 1232, 1269, 1272, 1273, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1441, 1443, 1465, 1467, 1469, 1471, 1471, 1473, 1474, 1476, 1476, 1488, 1514, 1520, 1522, 1569, 1594, 1600, 1621, 1632, 1641, 1648, 1747, 1749, 1756, 1759, 1768, 1770, 1773, 1776, 1788, 1808, 1836, 1840, 1866, 1920, 1968, 2305, 2307, 2309, 2361, 2364, 2381, 2384, 2388, 2392, 2403, 2406, 2415, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2492, 2494, 2500, 2503, 2504, 2507, 2509, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2562, 2562, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2649, 2652, 2654, 2654, 2662, 2676, 2689, 2691, 2693, 2699, 2701, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2784, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2870, 2873, 2876, 2883, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2913, 2918, 2927, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 2997, 2999, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3031, 3031, 3047, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3134, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3168, 3169, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3262, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3297, 3302, 3311, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3368, 3370, 3385, 3390, 3395, 3398, 3400, 3402, 3405, 3415, 3415, 3424, 3425, 3430, 3439, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3805, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3946, 3953, 3972, 3974, 3979, 3984, 3991, 3993, 4028, 4038, 4038, 4096, 4129, 4131, 4135, 4137, 4138, 4140, 4146, 4150, 4153, 4160, 4169, 4176, 4185, 4256, 4293, 4304, 4342, 4352, 4441, 4447, 4514, 4520, 4601, 4608, 4614, 4616, 4678, 4680, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4742, 4744, 4744, 4746, 4749, 4752, 4782, 4784, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4814, 4816, 4822, 4824, 4846, 4848, 4878, 4880, 4880, 4882, 4885, 4888, 4894, 4896, 4934, 4936, 4954, 4969, 4977, 5024, 5108, 5121, 5740, 5743, 5750, 5761, 5786, 5792, 5866, 6016, 6099, 6112, 6121, 6160, 6169, 6176, 6263, 6272, 6313, 7680, 7835, 7840, 7929, 7936, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8319, 8319, 8400, 8412, 8417, 8417, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8497, 8499, 8505, 8544, 8579, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12346, 12353, 12436, 12441, 12442, 12445, 12446, 12449, 12542, 12549, 12588, 12593, 12686, 12704, 12727, 13312, 19893, 19968, 40869, 40960, 42124, 44032, 55203, 63744, 64045, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65056, 65059, 65075, 65076, 65101, 65103, 65136, 65138, 65140, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65381, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; | |
| var unicodeES5IdentifierStart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1488, 1514, 1520, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2208, 2208, 2210, 2220, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2423, 2425, 2431, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3133, 3160, 3161, 3168, 3169, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3424, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6263, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6428, 6480, 6509, 6512, 6516, 6528, 6571, 6593, 6599, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7401, 7404, 7406, 7409, 7413, 7414, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42647, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43648, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; | |
| var unicodeES5IdentifierPart = [170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1319, 1329, 1366, 1369, 1369, 1377, 1415, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1520, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2048, 2093, 2112, 2139, 2208, 2208, 2210, 2220, 2276, 2302, 2304, 2403, 2406, 2415, 2417, 2423, 2425, 2431, 2433, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3073, 3075, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3123, 3125, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3161, 3168, 3171, 3174, 3183, 3202, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3330, 3331, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3396, 3398, 3400, 3402, 3406, 3415, 3415, 3424, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3719, 3720, 3722, 3722, 3725, 3725, 3732, 3735, 3737, 3743, 3745, 3747, 3749, 3749, 3751, 3751, 3754, 3755, 3757, 3769, 3771, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4992, 5007, 5024, 5108, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5872, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6263, 6272, 6314, 6320, 6389, 6400, 6428, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6617, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7376, 7378, 7380, 7414, 7424, 7654, 7676, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8204, 8205, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 11823, 11823, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12442, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12589, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40908, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42647, 42655, 42737, 42775, 42783, 42786, 42888, 42891, 42894, 42896, 42899, 42912, 42922, 43000, 43047, 43072, 43123, 43136, 43204, 43216, 43225, 43232, 43255, 43259, 43259, 43264, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43643, 43648, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43968, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65062, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500,]; | |
| var unicodeESNextIdentifierStart = [65, 90, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 1519, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2144, 2154, 2208, 2228, 2230, 2237, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2556, 2556, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2809, 2809, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3168, 3169, 3200, 3200, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3294, 3294, 3296, 3297, 3313, 3314, 3333, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3412, 3414, 3423, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5900, 5902, 5905, 5920, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6264, 6272, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6987, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7401, 7404, 7406, 7411, 7413, 7414, 7418, 7418, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 12293, 12295, 12321, 12329, 12337, 12341, 12344, 12348, 12353, 12438, 12443, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40943, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42653, 42656, 42735, 42775, 42783, 42786, 42888, 42891, 42943, 42946, 42950, 42999, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43262, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43879, 43888, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66176, 66204, 66208, 66256, 66304, 66335, 66349, 66378, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68149, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68899, 69376, 69404, 69415, 69415, 69424, 69445, 69600, 69622, 69635, 69687, 69763, 69807, 69840, 69864, 69891, 69926, 69956, 69956, 69968, 70002, 70006, 70006, 70019, 70066, 70081, 70084, 70106, 70106, 70108, 70108, 70144, 70161, 70163, 70187, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70480, 70480, 70493, 70497, 70656, 70708, 70727, 70730, 70751, 70751, 70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71128, 71131, 71168, 71215, 71236, 71236, 71296, 71338, 71352, 71352, 71424, 71450, 71680, 71723, 71840, 71903, 71935, 71935, 72096, 72103, 72106, 72144, 72161, 72161, 72163, 72163, 72192, 72192, 72203, 72242, 72250, 72250, 72272, 72272, 72284, 72329, 72349, 72349, 72384, 72440, 72704, 72712, 72714, 72750, 72768, 72768, 72818, 72847, 72960, 72966, 72968, 72969, 72971, 73008, 73030, 73030, 73056, 73061, 73063, 73064, 73066, 73097, 73112, 73112, 73440, 73458, 73728, 74649, 74752, 74862, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92766, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101106, 110592, 110878, 110928, 110930, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 123136, 123180, 123191, 123197, 123214, 123214, 123584, 123627, 124928, 125124, 125184, 125251, 125259, 125259, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101]; | |
| var unicodeESNextIdentifierPart = [48, 57, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 183, 183, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 768, 884, 886, 887, 890, 893, 895, 895, 902, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1155, 1159, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1488, 1514, 1519, 1522, 1552, 1562, 1568, 1641, 1646, 1747, 1749, 1756, 1759, 1768, 1770, 1788, 1791, 1791, 1808, 1866, 1869, 1969, 1984, 2037, 2042, 2042, 2045, 2045, 2048, 2093, 2112, 2139, 2144, 2154, 2208, 2228, 2230, 2237, 2259, 2273, 2275, 2403, 2406, 2415, 2417, 2435, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2492, 2500, 2503, 2504, 2507, 2510, 2519, 2519, 2524, 2525, 2527, 2531, 2534, 2545, 2556, 2556, 2558, 2558, 2561, 2563, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2620, 2620, 2622, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2649, 2652, 2654, 2654, 2662, 2677, 2689, 2691, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2748, 2757, 2759, 2761, 2763, 2765, 2768, 2768, 2784, 2787, 2790, 2799, 2809, 2815, 2817, 2819, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2876, 2884, 2887, 2888, 2891, 2893, 2902, 2903, 2908, 2909, 2911, 2915, 2918, 2927, 2929, 2929, 2946, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3006, 3010, 3014, 3016, 3018, 3021, 3024, 3024, 3031, 3031, 3046, 3055, 3072, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3140, 3142, 3144, 3146, 3149, 3157, 3158, 3160, 3162, 3168, 3171, 3174, 3183, 3200, 3203, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3260, 3268, 3270, 3272, 3274, 3277, 3285, 3286, 3294, 3294, 3296, 3299, 3302, 3311, 3313, 3314, 3328, 3331, 3333, 3340, 3342, 3344, 3346, 3396, 3398, 3400, 3402, 3406, 3412, 3415, 3423, 3427, 3430, 3439, 3450, 3455, 3458, 3459, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3530, 3530, 3535, 3540, 3542, 3542, 3544, 3551, 3558, 3567, 3570, 3571, 3585, 3642, 3648, 3662, 3664, 3673, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3773, 3776, 3780, 3782, 3782, 3784, 3789, 3792, 3801, 3804, 3807, 3840, 3840, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3902, 3911, 3913, 3948, 3953, 3972, 3974, 3991, 3993, 4028, 4038, 4038, 4096, 4169, 4176, 4253, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4957, 4959, 4969, 4977, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5870, 5880, 5888, 5900, 5902, 5908, 5920, 5940, 5952, 5971, 5984, 5996, 5998, 6000, 6002, 6003, 6016, 6099, 6103, 6103, 6108, 6109, 6112, 6121, 6155, 6157, 6160, 6169, 6176, 6264, 6272, 6314, 6320, 6389, 6400, 6430, 6432, 6443, 6448, 6459, 6470, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6608, 6618, 6656, 6683, 6688, 6750, 6752, 6780, 6783, 6793, 6800, 6809, 6823, 6823, 6832, 6845, 6912, 6987, 6992, 7001, 7019, 7027, 7040, 7155, 7168, 7223, 7232, 7241, 7245, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7376, 7378, 7380, 7418, 7424, 7673, 7675, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8255, 8256, 8276, 8276, 8305, 8305, 8319, 8319, 8336, 8348, 8400, 8412, 8417, 8417, 8421, 8432, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8472, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8544, 8584, 11264, 11310, 11312, 11358, 11360, 11492, 11499, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11647, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11744, 11775, 12293, 12295, 12321, 12335, 12337, 12341, 12344, 12348, 12353, 12438, 12441, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12730, 12784, 12799, 13312, 19893, 19968, 40943, 40960, 42124, 42192, 42237, 42240, 42508, 42512, 42539, 42560, 42607, 42612, 42621, 42623, 42737, 42775, 42783, 42786, 42888, 42891, 42943, 42946, 42950, 42999, 43047, 43072, 43123, 43136, 43205, 43216, 43225, 43232, 43255, 43259, 43259, 43261, 43309, 43312, 43347, 43360, 43388, 43392, 43456, 43471, 43481, 43488, 43518, 43520, 43574, 43584, 43597, 43600, 43609, 43616, 43638, 43642, 43714, 43739, 43741, 43744, 43759, 43762, 43766, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43879, 43888, 44010, 44012, 44013, 44016, 44025, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65024, 65039, 65056, 65071, 65075, 65076, 65101, 65103, 65136, 65140, 65142, 65276, 65296, 65305, 65313, 65338, 65343, 65343, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 65856, 65908, 66045, 66045, 66176, 66204, 66208, 66256, 66272, 66272, 66304, 66335, 66349, 66378, 66384, 66426, 66432, 66461, 66464, 66499, 66504, 66511, 66513, 66517, 66560, 66717, 66720, 66729, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 67072, 67382, 67392, 67413, 67424, 67431, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68099, 68101, 68102, 68108, 68115, 68117, 68119, 68121, 68149, 68152, 68154, 68159, 68159, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68326, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68903, 68912, 68921, 69376, 69404, 69415, 69415, 69424, 69456, 69600, 69622, 69632, 69702, 69734, 69743, 69759, 69818, 69840, 69864, 69872, 69881, 69888, 69940, 69942, 69951, 69956, 69958, 69968, 70003, 70006, 70006, 70016, 70084, 70089, 70092, 70096, 70106, 70108, 70108, 70144, 70161, 70163, 70199, 70206, 70206, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70378, 70384, 70393, 70400, 70403, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70459, 70468, 70471, 70472, 70475, 70477, 70480, 70480, 70487, 70487, 70493, 70499, 70502, 70508, 70512, 70516, 70656, 70730, 70736, 70745, 70750, 70751, 70784, 70853, 70855, 70855, 70864, 70873, 71040, 71093, 71096, 71104, 71128, 71133, 71168, 71232, 71236, 71236, 71248, 71257, 71296, 71352, 71360, 71369, 71424, 71450, 71453, 71467, 71472, 71481, 71680, 71738, 71840, 71913, 71935, 71935, 72096, 72103, 72106, 72151, 72154, 72161, 72163, 72164, 72192, 72254, 72263, 72263, 72272, 72345, 72349, 72349, 72384, 72440, 72704, 72712, 72714, 72758, 72760, 72768, 72784, 72793, 72818, 72847, 72850, 72871, 72873, 72886, 72960, 72966, 72968, 72969, 72971, 73014, 73018, 73018, 73020, 73021, 73023, 73031, 73040, 73049, 73056, 73061, 73063, 73064, 73066, 73102, 73104, 73105, 73107, 73112, 73120, 73129, 73440, 73462, 73728, 74649, 74752, 74862, 74880, 75075, 77824, 78894, 82944, 83526, 92160, 92728, 92736, 92766, 92768, 92777, 92880, 92909, 92912, 92916, 92928, 92982, 92992, 92995, 93008, 93017, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94031, 94087, 94095, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101106, 110592, 110878, 110928, 110930, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 113821, 113822, 119141, 119145, 119149, 119154, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 123136, 123180, 123184, 123197, 123200, 123209, 123214, 123214, 123584, 123641, 124928, 125124, 125136, 125142, 125184, 125259, 125264, 125273, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173782, 173824, 177972, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 917760, 917999]; | |
| function lookupInUnicodeMap(code, map) { | |
| if (code < map[0]) { | |
| return false; | |
| } | |
| var lo = 0; | |
| var hi = map.length; | |
| var mid; | |
| while (lo + 1 < hi) { | |
| mid = lo + (hi - lo) / 2; | |
| mid -= mid % 2; | |
| if (map[mid] <= code && code <= map[mid + 1]) { | |
| return true; | |
| } | |
| if (code < map[mid]) { | |
| hi = mid; | |
| } | |
| else { | |
| lo = mid + 2; | |
| } | |
| } | |
| return false; | |
| } | |
| function isUnicodeIdentifierStart(code, languageVersion) { | |
| return languageVersion >= 2 ? | |
| lookupInUnicodeMap(code, unicodeESNextIdentifierStart) : | |
| languageVersion === 1 ? lookupInUnicodeMap(code, unicodeES5IdentifierStart) : | |
| lookupInUnicodeMap(code, unicodeES3IdentifierStart); | |
| } | |
| ts_isUnicodeIdentifierStart = isUnicodeIdentifierStart; | |
| function isUnicodeIdentifierPart(code, languageVersion) { | |
| return languageVersion >= 2 ? | |
| lookupInUnicodeMap(code, unicodeESNextIdentifierPart) : | |
| languageVersion === 1 ? lookupInUnicodeMap(code, unicodeES5IdentifierPart) : | |
| lookupInUnicodeMap(code, unicodeES3IdentifierPart); | |
| } | |
| function makeReverseMap(source) { | |
| var result = []; | |
| source.forEach(function (value, name) { | |
| result[value] = name; | |
| }); | |
| return result; | |
| } | |
| var tokenStrings = makeReverseMap(textToToken); | |
| function tokenToString(t) { | |
| return tokenStrings[t]; | |
| } | |
| ts_tokenToString = tokenToString; | |
| function stringToToken(s) { | |
| return textToToken.get(s); | |
| } | |
| ts_stringToToken = stringToToken; | |
| function computeLineStarts(text) { | |
| var result = new Array(); | |
| var pos = 0; | |
| var lineStart = 0; | |
| while (pos < text.length) { | |
| var ch = text.charCodeAt(pos); | |
| pos++; | |
| switch (ch) { | |
| case 13: | |
| if (text.charCodeAt(pos) === 10) { | |
| pos++; | |
| } | |
| case 10: | |
| result.push(lineStart); | |
| lineStart = pos; | |
| break; | |
| default: | |
| if (ch > 127 && isLineBreak(ch)) { | |
| result.push(lineStart); | |
| lineStart = pos; | |
| } | |
| break; | |
| } | |
| } | |
| result.push(lineStart); | |
| return result; | |
| } | |
| ts_computeLineStarts = computeLineStarts; | |
| function getPositionOfLineAndCharacter(sourceFile, line, character, allowEdits) { | |
| return sourceFile.getPositionOfLineAndCharacter ? | |
| sourceFile.getPositionOfLineAndCharacter(line, character, allowEdits) : | |
| computePositionOfLineAndCharacter(getLineStarts(sourceFile), line, character, sourceFile.text, allowEdits); | |
| } | |
| ts_getPositionOfLineAndCharacter = getPositionOfLineAndCharacter; | |
| function computePositionOfLineAndCharacter(lineStarts, line, character, debugText, allowEdits) { | |
| if (line < 0 || line >= lineStarts.length) { | |
| if (allowEdits) { | |
| line = line < 0 ? 0 : line >= lineStarts.length ? lineStarts.length - 1 : line; | |
| } | |
| else { | |
| ts_Debug.fail("Bad line number. Line: " + line + ", lineStarts.length: " + lineStarts.length + " , line map is correct? " + (debugText !== undefined ? ts_arraysEqual(lineStarts, computeLineStarts(debugText)) : "unknown")); | |
| } | |
| } | |
| var res = lineStarts[line] + character; | |
| if (allowEdits) { | |
| return res > lineStarts[line + 1] ? lineStarts[line + 1] : typeof debugText === "string" && res > debugText.length ? debugText.length : res; | |
| } | |
| if (line < lineStarts.length - 1) { | |
| ts_Debug.assert(res < lineStarts[line + 1]); | |
| } | |
| else if (debugText !== undefined) { | |
| ts_Debug.assert(res <= debugText.length); | |
| } | |
| return res; | |
| } | |
| ts_computePositionOfLineAndCharacter = computePositionOfLineAndCharacter; | |
| function getLineStarts(sourceFile) { | |
| return sourceFile.lineMap || (sourceFile.lineMap = computeLineStarts(sourceFile.text)); | |
| } | |
| ts_getLineStarts = getLineStarts; | |
| function computeLineAndCharacterOfPosition(lineStarts, position) { | |
| var lineNumber = ts_binarySearch(lineStarts, position, ts_identity, ts_compareValues); | |
| if (lineNumber < 0) { | |
| lineNumber = ~lineNumber - 1; | |
| ts_Debug.assert(lineNumber !== -1, "position cannot precede the beginning of the file"); | |
| } | |
| return { | |
| line: lineNumber, | |
| character: position - lineStarts[lineNumber] | |
| }; | |
| } | |
| ts_computeLineAndCharacterOfPosition = computeLineAndCharacterOfPosition; | |
| function getLineAndCharacterOfPosition(sourceFile, position) { | |
| return computeLineAndCharacterOfPosition(getLineStarts(sourceFile), position); | |
| } | |
| ts_getLineAndCharacterOfPosition = getLineAndCharacterOfPosition; | |
| function isWhiteSpaceLike(ch) { | |
| return isWhiteSpaceSingleLine(ch) || isLineBreak(ch); | |
| } | |
| ts_isWhiteSpaceLike = isWhiteSpaceLike; | |
| function isWhiteSpaceSingleLine(ch) { | |
| return ch === 32 || | |
| ch === 9 || | |
| ch === 11 || | |
| ch === 12 || | |
| ch === 160 || | |
| ch === 133 || | |
| ch === 5760 || | |
| ch >= 8192 && ch <= 8203 || | |
| ch === 8239 || | |
| ch === 8287 || | |
| ch === 12288 || | |
| ch === 65279; | |
| } | |
| ts_isWhiteSpaceSingleLine = isWhiteSpaceSingleLine; | |
| function isLineBreak(ch) { | |
| return ch === 10 || | |
| ch === 13 || | |
| ch === 8232 || | |
| ch === 8233; | |
| } | |
| ts_isLineBreak = isLineBreak; | |
| function isDigit(ch) { | |
| return ch >= 48 && ch <= 57; | |
| } | |
| function isOctalDigit(ch) { | |
| return ch >= 48 && ch <= 55; | |
| } | |
| ts_isOctalDigit = isOctalDigit; | |
| function couldStartTrivia(text, pos) { | |
| var ch = text.charCodeAt(pos); | |
| switch (ch) { | |
| case 13: | |
| case 10: | |
| case 9: | |
| case 11: | |
| case 12: | |
| case 32: | |
| case 47: | |
| case 60: | |
| case 124: | |
| case 61: | |
| case 62: | |
| return true; | |
| case 35: | |
| return pos === 0; | |
| default: | |
| return ch > 127; | |
| } | |
| } | |
| ts_couldStartTrivia = couldStartTrivia; | |
| function skipTrivia(text, pos, stopAfterLineBreak, stopAtComments) { | |
| if (stopAtComments === void 0) { stopAtComments = false; } | |
| if (ts_positionIsSynthesized(pos)) { | |
| return pos; | |
| } | |
| while (true) { | |
| var ch = text.charCodeAt(pos); | |
| switch (ch) { | |
| case 13: | |
| if (text.charCodeAt(pos + 1) === 10) { | |
| pos++; | |
| } | |
| case 10: | |
| pos++; | |
| if (stopAfterLineBreak) { | |
| return pos; | |
| } | |
| continue; | |
| case 9: | |
| case 11: | |
| case 12: | |
| case 32: | |
| pos++; | |
| continue; | |
| case 47: | |
| if (stopAtComments) { | |
| break; | |
| } | |
| if (text.charCodeAt(pos + 1) === 47) { | |
| pos += 2; | |
| while (pos < text.length) { | |
| if (isLineBreak(text.charCodeAt(pos))) { | |
| break; | |
| } | |
| pos++; | |
| } | |
| continue; | |
| } | |
| if (text.charCodeAt(pos + 1) === 42) { | |
| pos += 2; | |
| while (pos < text.length) { | |
| if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) === 47) { | |
| pos += 2; | |
| break; | |
| } | |
| pos++; | |
| } | |
| continue; | |
| } | |
| break; | |
| case 60: | |
| case 124: | |
| case 61: | |
| case 62: | |
| if (isConflictMarkerTrivia(text, pos)) { | |
| pos = scanConflictMarkerTrivia(text, pos); | |
| continue; | |
| } | |
| break; | |
| case 35: | |
| if (pos === 0 && isShebangTrivia(text, pos)) { | |
| pos = scanShebangTrivia(text, pos); | |
| continue; | |
| } | |
| break; | |
| default: | |
| if (ch > 127 && (isWhiteSpaceLike(ch))) { | |
| pos++; | |
| continue; | |
| } | |
| break; | |
| } | |
| return pos; | |
| } | |
| } | |
| ts_skipTrivia = skipTrivia; | |
| var mergeConflictMarkerLength = "<<<<<<<".length; | |
| function isConflictMarkerTrivia(text, pos) { | |
| ts_Debug.assert(pos >= 0); | |
| if (pos === 0 || isLineBreak(text.charCodeAt(pos - 1))) { | |
| var ch = text.charCodeAt(pos); | |
| if ((pos + mergeConflictMarkerLength) < text.length) { | |
| for (var i = 0; i < mergeConflictMarkerLength; i++) { | |
| if (text.charCodeAt(pos + i) !== ch) { | |
| return false; | |
| } | |
| } | |
| return ch === 61 || | |
| text.charCodeAt(pos + mergeConflictMarkerLength) === 32; | |
| } | |
| } | |
| return false; | |
| } | |
| function scanConflictMarkerTrivia(text, pos, error) { | |
| if (error) { | |
| error(ts_Diagnostics.Merge_conflict_marker_encountered, pos, mergeConflictMarkerLength); | |
| } | |
| var ch = text.charCodeAt(pos); | |
| var len = text.length; | |
| if (ch === 60 || ch === 62) { | |
| while (pos < len && !isLineBreak(text.charCodeAt(pos))) { | |
| pos++; | |
| } | |
| } | |
| else { | |
| ts_Debug.assert(ch === 124 || ch === 61); | |
| while (pos < len) { | |
| var currentChar = text.charCodeAt(pos); | |
| if ((currentChar === 61 || currentChar === 62) && currentChar !== ch && isConflictMarkerTrivia(text, pos)) { | |
| break; | |
| } | |
| pos++; | |
| } | |
| } | |
| return pos; | |
| } | |
| var shebangTriviaRegex = /^#!.*/; | |
| function isShebangTrivia(text, pos) { | |
| ts_Debug.assert(pos === 0); | |
| return shebangTriviaRegex.test(text); | |
| } | |
| ts_isShebangTrivia = isShebangTrivia; | |
| function scanShebangTrivia(text, pos) { | |
| var shebang = shebangTriviaRegex.exec(text)[0]; | |
| pos = pos + shebang.length; | |
| return pos; | |
| } | |
| ts_scanShebangTrivia = scanShebangTrivia; | |
| function iterateCommentRanges(reduce, text, pos, trailing, cb, state, initial) { | |
| var pendingPos; | |
| var pendingEnd; | |
| var pendingKind; | |
| var pendingHasTrailingNewLine; | |
| var hasPendingCommentRange = false; | |
| var collecting = trailing; | |
| var accumulator = initial; | |
| if (pos === 0) { | |
| collecting = true; | |
| var shebang = getShebang(text); | |
| if (shebang) { | |
| pos = shebang.length; | |
| } | |
| } | |
| scan: while (pos >= 0 && pos < text.length) { | |
| var ch = text.charCodeAt(pos); | |
| switch (ch) { | |
| case 13: | |
| if (text.charCodeAt(pos + 1) === 10) { | |
| pos++; | |
| } | |
| case 10: | |
| pos++; | |
| if (trailing) { | |
| break scan; | |
| } | |
| collecting = true; | |
| if (hasPendingCommentRange) { | |
| pendingHasTrailingNewLine = true; | |
| } | |
| continue; | |
| case 9: | |
| case 11: | |
| case 12: | |
| case 32: | |
| pos++; | |
| continue; | |
| case 47: | |
| var nextChar = text.charCodeAt(pos + 1); | |
| var hasTrailingNewLine = false; | |
| if (nextChar === 47 || nextChar === 42) { | |
| var kind = nextChar === 47 ? 2 : 3; | |
| var startPos = pos; | |
| pos += 2; | |
| if (nextChar === 47) { | |
| while (pos < text.length) { | |
| if (isLineBreak(text.charCodeAt(pos))) { | |
| hasTrailingNewLine = true; | |
| break; | |
| } | |
| pos++; | |
| } | |
| } | |
| else { | |
| while (pos < text.length) { | |
| if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) === 47) { | |
| pos += 2; | |
| break; | |
| } | |
| pos++; | |
| } | |
| } | |
| if (collecting) { | |
| if (hasPendingCommentRange) { | |
| accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator); | |
| if (!reduce && accumulator) { | |
| return accumulator; | |
| } | |
| } | |
| pendingPos = startPos; | |
| pendingEnd = pos; | |
| pendingKind = kind; | |
| pendingHasTrailingNewLine = hasTrailingNewLine; | |
| hasPendingCommentRange = true; | |
| } | |
| continue; | |
| } | |
| break scan; | |
| default: | |
| if (ch > 127 && (isWhiteSpaceLike(ch))) { | |
| if (hasPendingCommentRange && isLineBreak(ch)) { | |
| pendingHasTrailingNewLine = true; | |
| } | |
| pos++; | |
| continue; | |
| } | |
| break scan; | |
| } | |
| } | |
| if (hasPendingCommentRange) { | |
| accumulator = cb(pendingPos, pendingEnd, pendingKind, pendingHasTrailingNewLine, state, accumulator); | |
| } | |
| return accumulator; | |
| } | |
| function forEachLeadingCommentRange(text, pos, cb, state) { | |
| return iterateCommentRanges(false, text, pos, false, cb, state); | |
| } | |
| ts_forEachLeadingCommentRange = forEachLeadingCommentRange; | |
| function forEachTrailingCommentRange(text, pos, cb, state) { | |
| return iterateCommentRanges(false, text, pos, true, cb, state); | |
| } | |
| ts_forEachTrailingCommentRange = forEachTrailingCommentRange; | |
| function reduceEachLeadingCommentRange(text, pos, cb, state, initial) { | |
| return iterateCommentRanges(true, text, pos, false, cb, state, initial); | |
| } | |
| ts_reduceEachLeadingCommentRange = reduceEachLeadingCommentRange; | |
| function reduceEachTrailingCommentRange(text, pos, cb, state, initial) { | |
| return iterateCommentRanges(true, text, pos, true, cb, state, initial); | |
| } | |
| ts_reduceEachTrailingCommentRange = reduceEachTrailingCommentRange; | |
| function appendCommentRange(pos, end, kind, hasTrailingNewLine, _state, comments) { | |
| if (!comments) { | |
| comments = []; | |
| } | |
| comments.push({ kind: kind, pos: pos, end: end, hasTrailingNewLine: hasTrailingNewLine }); | |
| return comments; | |
| } | |
| function getLeadingCommentRanges(text, pos) { | |
| return reduceEachLeadingCommentRange(text, pos, appendCommentRange, undefined, undefined); | |
| } | |
| ts_getLeadingCommentRanges = getLeadingCommentRanges; | |
| function getTrailingCommentRanges(text, pos) { | |
| return reduceEachTrailingCommentRange(text, pos, appendCommentRange, undefined, undefined); | |
| } | |
| ts_getTrailingCommentRanges = getTrailingCommentRanges; | |
| function getShebang(text) { | |
| var match = shebangTriviaRegex.exec(text); | |
| if (match) { | |
| return match[0]; | |
| } | |
| } | |
| ts_getShebang = getShebang; | |
| function isIdentifierStart(ch, languageVersion) { | |
| return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || | |
| ch === 36 || ch === 95 || | |
| ch > 127 && isUnicodeIdentifierStart(ch, languageVersion); | |
| } | |
| ts_isIdentifierStart = isIdentifierStart; | |
| function isIdentifierPart(ch, languageVersion) { | |
| return ch >= 65 && ch <= 90 || ch >= 97 && ch <= 122 || | |
| ch >= 48 && ch <= 57 || ch === 36 || ch === 95 || | |
| ch > 127 && isUnicodeIdentifierPart(ch, languageVersion); | |
| } | |
| ts_isIdentifierPart = isIdentifierPart; | |
| function isIdentifierText(name, languageVersion) { | |
| var ch = codePointAt(name, 0); | |
| if (!isIdentifierStart(ch, languageVersion)) { | |
| return false; | |
| } | |
| for (var i = charSize(ch); i < name.length; i += charSize(ch)) { | |
| if (!isIdentifierPart(ch = codePointAt(name, i), languageVersion)) { | |
| return false; | |
| } | |
| } | |
| return true; | |
| } | |
| ts_isIdentifierText = isIdentifierText; | |
| function createScanner(languageVersion, skipTrivia, languageVariant, textInitial, onError, start, length) { | |
| if (languageVariant === void 0) { languageVariant = 0; } | |
| var text = textInitial; | |
| var pos; | |
| var end; | |
| var startPos; | |
| var tokenPos; | |
| var token; | |
| var tokenValue; | |
| var tokenFlags; | |
| var inJSDocType = 0; | |
| setText(text, start, length); | |
| var scanner = { | |
| getStartPos: function () { return startPos; }, | |
| getTextPos: function () { return pos; }, | |
| getToken: function () { return token; }, | |
| getTokenPos: function () { return tokenPos; }, | |
| getTokenText: function () { return text.substring(tokenPos, pos); }, | |
| getTokenValue: function () { return tokenValue; }, | |
| hasUnicodeEscape: function () { return (tokenFlags & 1024) !== 0; }, | |
| hasExtendedUnicodeEscape: function () { return (tokenFlags & 8) !== 0; }, | |
| hasPrecedingLineBreak: function () { return (tokenFlags & 1) !== 0; }, | |
| isIdentifier: function () { return token === 75 || token > 112; }, | |
| isReservedWord: function () { return token >= 77 && token <= 112; }, | |
| isUnterminated: function () { return (tokenFlags & 4) !== 0; }, | |
| getTokenFlags: function () { return tokenFlags; }, | |
| reScanGreaterToken: reScanGreaterToken, | |
| reScanSlashToken: reScanSlashToken, | |
| reScanTemplateToken: reScanTemplateToken, | |
| scanJsxIdentifier: scanJsxIdentifier, | |
| scanJsxAttributeValue: scanJsxAttributeValue, | |
| reScanJsxAttributeValue: reScanJsxAttributeValue, | |
| reScanJsxToken: reScanJsxToken, | |
| reScanLessThanToken: reScanLessThanToken, | |
| reScanQuestionToken: reScanQuestionToken, | |
| scanJsxToken: scanJsxToken, | |
| scanJsDocToken: scanJsDocToken, | |
| scan: scan, | |
| getText: getText, | |
| setText: setText, | |
| setScriptTarget: setScriptTarget, | |
| setLanguageVariant: setLanguageVariant, | |
| setOnError: setOnError, | |
| setTextPos: setTextPos, | |
| setInJSDocType: setInJSDocType, | |
| tryScan: tryScan, | |
| lookAhead: lookAhead, | |
| scanRange: scanRange, | |
| }; | |
| if (ts_Debug.isDebugging) { | |
| Object.defineProperty(scanner, "__debugShowCurrentPositionInText", { | |
| get: function () { | |
| var text = scanner.getText(); | |
| return text.slice(0, scanner.getStartPos()) + "║" + text.slice(scanner.getStartPos()); | |
| }, | |
| }); | |
| } | |
| return scanner; | |
| function error(message, errPos, length) { | |
| if (errPos === void 0) { errPos = pos; } | |
| if (onError) { | |
| var oldPos = pos; | |
| pos = errPos; | |
| onError(message, length || 0); | |
| pos = oldPos; | |
| } | |
| } | |
| function scanNumberFragment() { | |
| var start = pos; | |
| var allowSeparator = false; | |
| var isPreviousTokenSeparator = false; | |
| var result = ""; | |
| while (true) { | |
| var ch = text.charCodeAt(pos); | |
| if (ch === 95) { | |
| tokenFlags |= 512; | |
| if (allowSeparator) { | |
| allowSeparator = false; | |
| isPreviousTokenSeparator = true; | |
| result += text.substring(start, pos); | |
| } | |
| else if (isPreviousTokenSeparator) { | |
| error(ts_Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1); | |
| } | |
| else { | |
| error(ts_Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1); | |
| } | |
| pos++; | |
| start = pos; | |
| continue; | |
| } | |
| if (isDigit(ch)) { | |
| allowSeparator = true; | |
| isPreviousTokenSeparator = false; | |
| pos++; | |
| continue; | |
| } | |
| break; | |
| } | |
| if (text.charCodeAt(pos - 1) === 95) { | |
| error(ts_Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1); | |
| } | |
| return result + text.substring(start, pos); | |
| } | |
| function scanNumber() { | |
| var start = pos; | |
| var mainFragment = scanNumberFragment(); | |
| var decimalFragment; | |
| var scientificFragment; | |
| if (text.charCodeAt(pos) === 46) { | |
| pos++; | |
| decimalFragment = scanNumberFragment(); | |
| } | |
| var end = pos; | |
| if (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101) { | |
| pos++; | |
| tokenFlags |= 16; | |
| if (text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) | |
| pos++; | |
| var preNumericPart = pos; | |
| var finalFragment = scanNumberFragment(); | |
| if (!finalFragment) { | |
| error(ts_Diagnostics.Digit_expected); | |
| } | |
| else { | |
| scientificFragment = text.substring(end, preNumericPart) + finalFragment; | |
| end = pos; | |
| } | |
| } | |
| var result; | |
| if (tokenFlags & 512) { | |
| result = mainFragment; | |
| if (decimalFragment) { | |
| result += "." + decimalFragment; | |
| } | |
| if (scientificFragment) { | |
| result += scientificFragment; | |
| } | |
| } | |
| else { | |
| result = text.substring(start, end); | |
| } | |
| if (decimalFragment !== undefined || tokenFlags & 16) { | |
| checkForIdentifierStartAfterNumericLiteral(start, decimalFragment === undefined && !!(tokenFlags & 16)); | |
| return { | |
| type: 8, | |
| value: "" + +result | |
| }; | |
| } | |
| else { | |
| tokenValue = result; | |
| var type = checkBigIntSuffix(); | |
| checkForIdentifierStartAfterNumericLiteral(start); | |
| return { type: type, value: tokenValue }; | |
| } | |
| } | |
| function checkForIdentifierStartAfterNumericLiteral(numericStart, isScientific) { | |
| if (!isIdentifierStart(codePointAt(text, pos), languageVersion)) { | |
| return; | |
| } | |
| var identifierStart = pos; | |
| var length = scanIdentifierParts().length; | |
| if (length === 1 && text[identifierStart] === "n") { | |
| if (isScientific) { | |
| error(ts_Diagnostics.A_bigint_literal_cannot_use_exponential_notation, numericStart, identifierStart - numericStart + 1); | |
| } | |
| else { | |
| error(ts_Diagnostics.A_bigint_literal_must_be_an_integer, numericStart, identifierStart - numericStart + 1); | |
| } | |
| } | |
| else { | |
| error(ts_Diagnostics.An_identifier_or_keyword_cannot_immediately_follow_a_numeric_literal, identifierStart, length); | |
| pos = identifierStart; | |
| } | |
| } | |
| function scanOctalDigits() { | |
| var start = pos; | |
| while (isOctalDigit(text.charCodeAt(pos))) { | |
| pos++; | |
| } | |
| return +(text.substring(start, pos)); | |
| } | |
| function scanExactNumberOfHexDigits(count, canHaveSeparators) { | |
| var valueString = scanHexDigits(count, false, canHaveSeparators); | |
| return valueString ? parseInt(valueString, 16) : -1; | |
| } | |
| function scanMinimumNumberOfHexDigits(count, canHaveSeparators) { | |
| return scanHexDigits(count, true, canHaveSeparators); | |
| } | |
| function scanHexDigits(minCount, scanAsManyAsPossible, canHaveSeparators) { | |
| var valueChars = []; | |
| var allowSeparator = false; | |
| var isPreviousTokenSeparator = false; | |
| while (valueChars.length < minCount || scanAsManyAsPossible) { | |
| var ch = text.charCodeAt(pos); | |
| if (canHaveSeparators && ch === 95) { | |
| tokenFlags |= 512; | |
| if (allowSeparator) { | |
| allowSeparator = false; | |
| isPreviousTokenSeparator = true; | |
| } | |
| else if (isPreviousTokenSeparator) { | |
| error(ts_Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1); | |
| } | |
| else { | |
| error(ts_Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1); | |
| } | |
| pos++; | |
| continue; | |
| } | |
| allowSeparator = canHaveSeparators; | |
| if (ch >= 65 && ch <= 70) { | |
| ch += 97 - 65; | |
| } | |
| else if (!((ch >= 48 && ch <= 57) || | |
| (ch >= 97 && ch <= 102))) { | |
| break; | |
| } | |
| valueChars.push(ch); | |
| pos++; | |
| isPreviousTokenSeparator = false; | |
| } | |
| if (valueChars.length < minCount) { | |
| valueChars = []; | |
| } | |
| if (text.charCodeAt(pos - 1) === 95) { | |
| error(ts_Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1); | |
| } | |
| return String.fromCharCode.apply(String, valueChars); | |
| } | |
| function scanString(jsxAttributeString) { | |
| if (jsxAttributeString === void 0) { jsxAttributeString = false; } | |
| var quote = text.charCodeAt(pos); | |
| pos++; | |
| var result = ""; | |
| var start = pos; | |
| while (true) { | |
| if (pos >= end) { | |
| result += text.substring(start, pos); | |
| tokenFlags |= 4; | |
| error(ts_Diagnostics.Unterminated_string_literal); | |
| break; | |
| } | |
| var ch = text.charCodeAt(pos); | |
| if (ch === quote) { | |
| result += text.substring(start, pos); | |
| pos++; | |
| break; | |
| } | |
| if (ch === 92 && !jsxAttributeString) { | |
| result += text.substring(start, pos); | |
| result += scanEscapeSequence(); | |
| start = pos; | |
| continue; | |
| } | |
| if (isLineBreak(ch) && !jsxAttributeString) { | |
| result += text.substring(start, pos); | |
| tokenFlags |= 4; | |
| error(ts_Diagnostics.Unterminated_string_literal); | |
| break; | |
| } | |
| pos++; | |
| } | |
| return result; | |
| } | |
| function scanTemplateAndSetTokenValue() { | |
| var startedWithBacktick = text.charCodeAt(pos) === 96; | |
| pos++; | |
| var start = pos; | |
| var contents = ""; | |
| var resultingToken; | |
| while (true) { | |
| if (pos >= end) { | |
| contents += text.substring(start, pos); | |
| tokenFlags |= 4; | |
| error(ts_Diagnostics.Unterminated_template_literal); | |
| resultingToken = startedWithBacktick ? 14 : 17; | |
| break; | |
| } | |
| var currChar = text.charCodeAt(pos); | |
| if (currChar === 96) { | |
| contents += text.substring(start, pos); | |
| pos++; | |
| resultingToken = startedWithBacktick ? 14 : 17; | |
| break; | |
| } | |
| if (currChar === 36 && pos + 1 < end && text.charCodeAt(pos + 1) === 123) { | |
| contents += text.substring(start, pos); | |
| pos += 2; | |
| resultingToken = startedWithBacktick ? 15 : 16; | |
| break; | |
| } | |
| if (currChar === 92) { | |
| contents += text.substring(start, pos); | |
| contents += scanEscapeSequence(); | |
| start = pos; | |
| continue; | |
| } | |
| if (currChar === 13) { | |
| contents += text.substring(start, pos); | |
| pos++; | |
| if (pos < end && text.charCodeAt(pos) === 10) { | |
| pos++; | |
| } | |
| contents += "\n"; | |
| start = pos; | |
| continue; | |
| } | |
| pos++; | |
| } | |
| ts_Debug.assert(resultingToken !== undefined); | |
| tokenValue = contents; | |
| return resultingToken; | |
| } | |
| function scanEscapeSequence() { | |
| pos++; | |
| if (pos >= end) { | |
| error(ts_Diagnostics.Unexpected_end_of_text); | |
| return ""; | |
| } | |
| var ch = text.charCodeAt(pos); | |
| pos++; | |
| switch (ch) { | |
| case 48: | |
| return "\0"; | |
| case 98: | |
| return "\b"; | |
| case 116: | |
| return "\t"; | |
| case 110: | |
| return "\n"; | |
| case 118: | |
| return "\v"; | |
| case 102: | |
| return "\f"; | |
| case 114: | |
| return "\r"; | |
| case 39: | |
| return "\'"; | |
| case 34: | |
| return "\""; | |
| case 117: | |
| if (pos < end && text.charCodeAt(pos) === 123) { | |
| tokenFlags |= 8; | |
| pos++; | |
| return scanExtendedUnicodeEscape(); | |
| } | |
| tokenFlags |= 1024; | |
| return scanHexadecimalEscape(4); | |
| case 120: | |
| return scanHexadecimalEscape(2); | |
| case 13: | |
| if (pos < end && text.charCodeAt(pos) === 10) { | |
| pos++; | |
| } | |
| case 10: | |
| case 8232: | |
| case 8233: | |
| return ""; | |
| default: | |
| return String.fromCharCode(ch); | |
| } | |
| } | |
| function scanHexadecimalEscape(numDigits) { | |
| var escapedValue = scanExactNumberOfHexDigits(numDigits, false); | |
| if (escapedValue >= 0) { | |
| return String.fromCharCode(escapedValue); | |
| } | |
| else { | |
| error(ts_Diagnostics.Hexadecimal_digit_expected); | |
| return ""; | |
| } | |
| } | |
| function scanExtendedUnicodeEscape() { | |
| var escapedValueString = scanMinimumNumberOfHexDigits(1, false); | |
| var escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1; | |
| var isInvalidExtendedEscape = false; | |
| if (escapedValue < 0) { | |
| error(ts_Diagnostics.Hexadecimal_digit_expected); | |
| isInvalidExtendedEscape = true; | |
| } | |
| else if (escapedValue > 0x10FFFF) { | |
| error(ts_Diagnostics.An_extended_Unicode_escape_value_must_be_between_0x0_and_0x10FFFF_inclusive); | |
| isInvalidExtendedEscape = true; | |
| } | |
| if (pos >= end) { | |
| error(ts_Diagnostics.Unexpected_end_of_text); | |
| isInvalidExtendedEscape = true; | |
| } | |
| else if (text.charCodeAt(pos) === 125) { | |
| pos++; | |
| } | |
| else { | |
| error(ts_Diagnostics.Unterminated_Unicode_escape_sequence); | |
| isInvalidExtendedEscape = true; | |
| } | |
| if (isInvalidExtendedEscape) { | |
| return ""; | |
| } | |
| return utf16EncodeAsString(escapedValue); | |
| } | |
| function peekUnicodeEscape() { | |
| if (pos + 5 < end && text.charCodeAt(pos + 1) === 117) { | |
| var start_1 = pos; | |
| pos += 2; | |
| var value = scanExactNumberOfHexDigits(4, false); | |
| pos = start_1; | |
| return value; | |
| } | |
| return -1; | |
| } | |
| function peekExtendedUnicodeEscape() { | |
| if (languageVersion >= 2 && codePointAt(text, pos + 1) === 117 && codePointAt(text, pos + 2) === 123) { | |
| var start_2 = pos; | |
| pos += 3; | |
| var escapedValueString = scanMinimumNumberOfHexDigits(1, false); | |
| var escapedValue = escapedValueString ? parseInt(escapedValueString, 16) : -1; | |
| pos = start_2; | |
| return escapedValue; | |
| } | |
| return -1; | |
| } | |
| function scanIdentifierParts() { | |
| var result = ""; | |
| var start = pos; | |
| while (pos < end) { | |
| var ch = codePointAt(text, pos); | |
| if (isIdentifierPart(ch, languageVersion)) { | |
| pos += charSize(ch); | |
| } | |
| else if (ch === 92) { | |
| ch = peekExtendedUnicodeEscape(); | |
| if (ch >= 0 && isIdentifierPart(ch, languageVersion)) { | |
| pos += 3; | |
| tokenFlags |= 8; | |
| result += scanExtendedUnicodeEscape(); | |
| start = pos; | |
| continue; | |
| } | |
| ch = peekUnicodeEscape(); | |
| if (!(ch >= 0 && isIdentifierPart(ch, languageVersion))) { | |
| break; | |
| } | |
| tokenFlags |= 1024; | |
| result += text.substring(start, pos); | |
| result += utf16EncodeAsString(ch); | |
| pos += 6; | |
| start = pos; | |
| } | |
| else { | |
| break; | |
| } | |
| } | |
| result += text.substring(start, pos); | |
| return result; | |
| } | |
| function getIdentifierToken() { | |
| var len = tokenValue.length; | |
| if (len >= 2 && len <= 11) { | |
| var ch = tokenValue.charCodeAt(0); | |
| if (ch >= 97 && ch <= 122) { | |
| var keyword = textToKeyword.get(tokenValue); | |
| if (keyword !== undefined) { | |
| return token = keyword; | |
| } | |
| } | |
| } | |
| return token = 75; | |
| } | |
| function scanBinaryOrOctalDigits(base) { | |
| var value = ""; | |
| var separatorAllowed = false; | |
| var isPreviousTokenSeparator = false; | |
| while (true) { | |
| var ch = text.charCodeAt(pos); | |
| if (ch === 95) { | |
| tokenFlags |= 512; | |
| if (separatorAllowed) { | |
| separatorAllowed = false; | |
| isPreviousTokenSeparator = true; | |
| } | |
| else if (isPreviousTokenSeparator) { | |
| error(ts_Diagnostics.Multiple_consecutive_numeric_separators_are_not_permitted, pos, 1); | |
| } | |
| else { | |
| error(ts_Diagnostics.Numeric_separators_are_not_allowed_here, pos, 1); | |
| } | |
| pos++; | |
| continue; | |
| } | |
| separatorAllowed = true; | |
| if (!isDigit(ch) || ch - 48 >= base) { | |
| break; | |
| } | |
| value += text[pos]; | |
| pos++; | |
| isPreviousTokenSeparator = false; | |
| } | |
| if (text.charCodeAt(pos - 1) === 95) { | |
| error(ts_Diagnostics.Numeric_separators_are_not_allowed_here, pos - 1, 1); | |
| } | |
| return value; | |
| } | |
| function checkBigIntSuffix() { | |
| if (text.charCodeAt(pos) === 110) { | |
| tokenValue += "n"; | |
| if (tokenFlags & 384) { | |
| tokenValue = ts_parsePseudoBigInt(tokenValue) + "n"; | |
| } | |
| pos++; | |
| return 9; | |
| } | |
| else { | |
| var numericValue = tokenFlags & 128 | |
| ? parseInt(tokenValue.slice(2), 2) | |
| : tokenFlags & 256 | |
| ? parseInt(tokenValue.slice(2), 8) | |
| : +tokenValue; | |
| tokenValue = "" + numericValue; | |
| return 8; | |
| } | |
| } | |
| function scan() { | |
| var _a; | |
| startPos = pos; | |
| tokenFlags = 0; | |
| var asteriskSeen = false; | |
| while (true) { | |
| tokenPos = pos; | |
| if (pos >= end) { | |
| return token = 1; | |
| } | |
| var ch = codePointAt(text, pos); | |
| if (ch === 35 && pos === 0 && isShebangTrivia(text, pos)) { | |
| pos = scanShebangTrivia(text, pos); | |
| if (skipTrivia) { | |
| continue; | |
| } | |
| else { | |
| return token = 6; | |
| } | |
| } | |
| switch (ch) { | |
| case 10: | |
| case 13: | |
| tokenFlags |= 1; | |
| if (skipTrivia) { | |
| pos++; | |
| continue; | |
| } | |
| else { | |
| if (ch === 13 && pos + 1 < end && text.charCodeAt(pos + 1) === 10) { | |
| pos += 2; | |
| } | |
| else { | |
| pos++; | |
| } | |
| return token = 4; | |
| } | |
| case 9: | |
| case 11: | |
| case 12: | |
| case 32: | |
| case 160: | |
| case 5760: | |
| case 8192: | |
| case 8193: | |
| case 8194: | |
| case 8195: | |
| case 8196: | |
| case 8197: | |
| case 8198: | |
| case 8199: | |
| case 8200: | |
| case 8201: | |
| case 8202: | |
| case 8203: | |
| case 8239: | |
| case 8287: | |
| case 12288: | |
| case 65279: | |
| if (skipTrivia) { | |
| pos++; | |
| continue; | |
| } | |
| else { | |
| while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) { | |
| pos++; | |
| } | |
| return token = 5; | |
| } | |
| case 33: | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| if (text.charCodeAt(pos + 2) === 61) { | |
| return pos += 3, token = 37; | |
| } | |
| return pos += 2, token = 35; | |
| } | |
| pos++; | |
| return token = 53; | |
| case 34: | |
| case 39: | |
| tokenValue = scanString(); | |
| return token = 10; | |
| case 96: | |
| return token = scanTemplateAndSetTokenValue(); | |
| case 37: | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| return pos += 2, token = 68; | |
| } | |
| pos++; | |
| return token = 44; | |
| case 38: | |
| if (text.charCodeAt(pos + 1) === 38) { | |
| return pos += 2, token = 55; | |
| } | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| return pos += 2, token = 72; | |
| } | |
| pos++; | |
| return token = 50; | |
| case 40: | |
| pos++; | |
| return token = 20; | |
| case 41: | |
| pos++; | |
| return token = 21; | |
| case 42: | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| return pos += 2, token = 65; | |
| } | |
| if (text.charCodeAt(pos + 1) === 42) { | |
| if (text.charCodeAt(pos + 2) === 61) { | |
| return pos += 3, token = 66; | |
| } | |
| return pos += 2, token = 42; | |
| } | |
| pos++; | |
| if (inJSDocType && !asteriskSeen && (tokenFlags & 1)) { | |
| asteriskSeen = true; | |
| continue; | |
| } | |
| return token = 41; | |
| case 43: | |
| if (text.charCodeAt(pos + 1) === 43) { | |
| return pos += 2, token = 45; | |
| } | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| return pos += 2, token = 63; | |
| } | |
| pos++; | |
| return token = 39; | |
| case 44: | |
| pos++; | |
| return token = 27; | |
| case 45: | |
| if (text.charCodeAt(pos + 1) === 45) { | |
| return pos += 2, token = 46; | |
| } | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| return pos += 2, token = 64; | |
| } | |
| pos++; | |
| return token = 40; | |
| case 46: | |
| if (isDigit(text.charCodeAt(pos + 1))) { | |
| tokenValue = scanNumber().value; | |
| return token = 8; | |
| } | |
| if (text.charCodeAt(pos + 1) === 46 && text.charCodeAt(pos + 2) === 46) { | |
| return pos += 3, token = 25; | |
| } | |
| pos++; | |
| return token = 24; | |
| case 47: | |
| if (text.charCodeAt(pos + 1) === 47) { | |
| pos += 2; | |
| while (pos < end) { | |
| if (isLineBreak(text.charCodeAt(pos))) { | |
| break; | |
| } | |
| pos++; | |
| } | |
| if (skipTrivia) { | |
| continue; | |
| } | |
| else { | |
| return token = 2; | |
| } | |
| } | |
| if (text.charCodeAt(pos + 1) === 42) { | |
| pos += 2; | |
| if (text.charCodeAt(pos) === 42 && text.charCodeAt(pos + 1) !== 47) { | |
| tokenFlags |= 2; | |
| } | |
| var commentClosed = false; | |
| while (pos < end) { | |
| var ch_1 = text.charCodeAt(pos); | |
| if (ch_1 === 42 && text.charCodeAt(pos + 1) === 47) { | |
| pos += 2; | |
| commentClosed = true; | |
| break; | |
| } | |
| if (isLineBreak(ch_1)) { | |
| tokenFlags |= 1; | |
| } | |
| pos++; | |
| } | |
| if (!commentClosed) { | |
| error(ts_Diagnostics.Asterisk_Slash_expected); | |
| } | |
| if (skipTrivia) { | |
| continue; | |
| } | |
| else { | |
| if (!commentClosed) { | |
| tokenFlags |= 4; | |
| } | |
| return token = 3; | |
| } | |
| } | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| return pos += 2, token = 67; | |
| } | |
| pos++; | |
| return token = 43; | |
| case 48: | |
| if (pos + 2 < end && (text.charCodeAt(pos + 1) === 88 || text.charCodeAt(pos + 1) === 120)) { | |
| pos += 2; | |
| tokenValue = scanMinimumNumberOfHexDigits(1, true); | |
| if (!tokenValue) { | |
| error(ts_Diagnostics.Hexadecimal_digit_expected); | |
| tokenValue = "0"; | |
| } | |
| tokenValue = "0x" + tokenValue; | |
| tokenFlags |= 64; | |
| return token = checkBigIntSuffix(); | |
| } | |
| else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 66 || text.charCodeAt(pos + 1) === 98)) { | |
| pos += 2; | |
| tokenValue = scanBinaryOrOctalDigits(2); | |
| if (!tokenValue) { | |
| error(ts_Diagnostics.Binary_digit_expected); | |
| tokenValue = "0"; | |
| } | |
| tokenValue = "0b" + tokenValue; | |
| tokenFlags |= 128; | |
| return token = checkBigIntSuffix(); | |
| } | |
| else if (pos + 2 < end && (text.charCodeAt(pos + 1) === 79 || text.charCodeAt(pos + 1) === 111)) { | |
| pos += 2; | |
| tokenValue = scanBinaryOrOctalDigits(8); | |
| if (!tokenValue) { | |
| error(ts_Diagnostics.Octal_digit_expected); | |
| tokenValue = "0"; | |
| } | |
| tokenValue = "0o" + tokenValue; | |
| tokenFlags |= 256; | |
| return token = checkBigIntSuffix(); | |
| } | |
| if (pos + 1 < end && isOctalDigit(text.charCodeAt(pos + 1))) { | |
| tokenValue = "" + scanOctalDigits(); | |
| tokenFlags |= 32; | |
| return token = 8; | |
| } | |
| case 49: | |
| case 50: | |
| case 51: | |
| case 52: | |
| case 53: | |
| case 54: | |
| case 55: | |
| case 56: | |
| case 57: | |
| (_a = scanNumber(), token = _a.type, tokenValue = _a.value); | |
| return token; | |
| case 58: | |
| pos++; | |
| return token = 58; | |
| case 59: | |
| pos++; | |
| return token = 26; | |
| case 60: | |
| if (isConflictMarkerTrivia(text, pos)) { | |
| pos = scanConflictMarkerTrivia(text, pos, error); | |
| if (skipTrivia) { | |
| continue; | |
| } | |
| else { | |
| return token = 7; | |
| } | |
| } | |
| if (text.charCodeAt(pos + 1) === 60) { | |
| if (text.charCodeAt(pos + 2) === 61) { | |
| return pos += 3, token = 69; | |
| } | |
| return pos += 2, token = 47; | |
| } | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| return pos += 2, token = 32; | |
| } | |
| if (languageVariant === 1 && | |
| text.charCodeAt(pos + 1) === 47 && | |
| text.charCodeAt(pos + 2) !== 42) { | |
| return pos += 2, token = 30; | |
| } | |
| pos++; | |
| return token = 29; | |
| case 61: | |
| if (isConflictMarkerTrivia(text, pos)) { | |
| pos = scanConflictMarkerTrivia(text, pos, error); | |
| if (skipTrivia) { | |
| continue; | |
| } | |
| else { | |
| return token = 7; | |
| } | |
| } | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| if (text.charCodeAt(pos + 2) === 61) { | |
| return pos += 3, token = 36; | |
| } | |
| return pos += 2, token = 34; | |
| } | |
| if (text.charCodeAt(pos + 1) === 62) { | |
| return pos += 2, token = 38; | |
| } | |
| pos++; | |
| return token = 62; | |
| case 62: | |
| if (isConflictMarkerTrivia(text, pos)) { | |
| pos = scanConflictMarkerTrivia(text, pos, error); | |
| if (skipTrivia) { | |
| continue; | |
| } | |
| else { | |
| return token = 7; | |
| } | |
| } | |
| pos++; | |
| return token = 31; | |
| case 63: | |
| pos++; | |
| if (text.charCodeAt(pos) === 46 && !isDigit(text.charCodeAt(pos + 1))) { | |
| pos++; | |
| return token = 28; | |
| } | |
| if (text.charCodeAt(pos) === 63) { | |
| pos++; | |
| return token = 60; | |
| } | |
| return token = 57; | |
| case 91: | |
| pos++; | |
| return token = 22; | |
| case 93: | |
| pos++; | |
| return token = 23; | |
| case 94: | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| return pos += 2, token = 74; | |
| } | |
| pos++; | |
| return token = 52; | |
| case 123: | |
| pos++; | |
| return token = 18; | |
| case 124: | |
| if (isConflictMarkerTrivia(text, pos)) { | |
| pos = scanConflictMarkerTrivia(text, pos, error); | |
| if (skipTrivia) { | |
| continue; | |
| } | |
| else { | |
| return token = 7; | |
| } | |
| } | |
| if (text.charCodeAt(pos + 1) === 124) { | |
| return pos += 2, token = 56; | |
| } | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| return pos += 2, token = 73; | |
| } | |
| pos++; | |
| return token = 51; | |
| case 125: | |
| pos++; | |
| return token = 19; | |
| case 126: | |
| pos++; | |
| return token = 54; | |
| case 64: | |
| pos++; | |
| return token = 59; | |
| case 92: | |
| var extendedCookedChar = peekExtendedUnicodeEscape(); | |
| if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) { | |
| pos += 3; | |
| tokenFlags |= 8; | |
| tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts(); | |
| return token = getIdentifierToken(); | |
| } | |
| var cookedChar = peekUnicodeEscape(); | |
| if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) { | |
| pos += 6; | |
| tokenFlags |= 1024; | |
| tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts(); | |
| return token = getIdentifierToken(); | |
| } | |
| error(ts_Diagnostics.Invalid_character); | |
| pos++; | |
| return token = 0; | |
| case 35: | |
| if (pos !== 0 && text[pos + 1] === "!") { | |
| error(ts_Diagnostics.can_only_be_used_at_the_start_of_a_file); | |
| pos++; | |
| return token = 0; | |
| } | |
| pos++; | |
| if (isIdentifierStart(ch = text.charCodeAt(pos), languageVersion)) { | |
| pos++; | |
| while (pos < end && isIdentifierPart(ch = text.charCodeAt(pos), languageVersion)) | |
| pos++; | |
| tokenValue = text.substring(tokenPos, pos); | |
| if (ch === 92) { | |
| tokenValue += scanIdentifierParts(); | |
| } | |
| } | |
| else { | |
| tokenValue = "#"; | |
| error(ts_Diagnostics.Invalid_character); | |
| } | |
| return token = 76; | |
| default: | |
| if (isIdentifierStart(ch, languageVersion)) { | |
| pos += charSize(ch); | |
| while (pos < end && isIdentifierPart(ch = codePointAt(text, pos), languageVersion)) | |
| pos += charSize(ch); | |
| tokenValue = text.substring(tokenPos, pos); | |
| if (ch === 92) { | |
| tokenValue += scanIdentifierParts(); | |
| } | |
| return token = getIdentifierToken(); | |
| } | |
| else if (isWhiteSpaceSingleLine(ch)) { | |
| pos += charSize(ch); | |
| continue; | |
| } | |
| else if (isLineBreak(ch)) { | |
| tokenFlags |= 1; | |
| pos += charSize(ch); | |
| continue; | |
| } | |
| error(ts_Diagnostics.Invalid_character); | |
| pos += charSize(ch); | |
| return token = 0; | |
| } | |
| } | |
| } | |
| function reScanGreaterToken() { | |
| if (token === 31) { | |
| if (text.charCodeAt(pos) === 62) { | |
| if (text.charCodeAt(pos + 1) === 62) { | |
| if (text.charCodeAt(pos + 2) === 61) { | |
| return pos += 3, token = 71; | |
| } | |
| return pos += 2, token = 49; | |
| } | |
| if (text.charCodeAt(pos + 1) === 61) { | |
| return pos += 2, token = 70; | |
| } | |
| pos++; | |
| return token = 48; | |
| } | |
| if (text.charCodeAt(pos) === 61) { | |
| pos++; | |
| return token = 33; | |
| } | |
| } | |
| return token; | |
| } | |
| function reScanSlashToken() { | |
| if (token === 43 || token === 67) { | |
| var p = tokenPos + 1; | |
| var inEscape = false; | |
| var inCharacterClass = false; | |
| while (true) { | |
| if (p >= end) { | |
| tokenFlags |= 4; | |
| error(ts_Diagnostics.Unterminated_regular_expression_literal); | |
| break; | |
| } | |
| var ch = text.charCodeAt(p); | |
| if (isLineBreak(ch)) { | |
| tokenFlags |= 4; | |
| error(ts_Diagnostics.Unterminated_regular_expression_literal); | |
| break; | |
| } | |
| if (inEscape) { | |
| inEscape = false; | |
| } | |
| else if (ch === 47 && !inCharacterClass) { | |
| p++; | |
| break; | |
| } | |
| else if (ch === 91) { | |
| inCharacterClass = true; | |
| } | |
| else if (ch === 92) { | |
| inEscape = true; | |
| } | |
| else if (ch === 93) { | |
| inCharacterClass = false; | |
| } | |
| p++; | |
| } | |
| while (p < end && isIdentifierPart(text.charCodeAt(p), languageVersion)) { | |
| p++; | |
| } | |
| pos = p; | |
| tokenValue = text.substring(tokenPos, pos); | |
| token = 13; | |
| } | |
| return token; | |
| } | |
| function reScanTemplateToken() { | |
| ts_Debug.assert(token === 19, "'reScanTemplateToken' should only be called on a '}'"); | |
| pos = tokenPos; | |
| return token = scanTemplateAndSetTokenValue(); | |
| } | |
| function reScanJsxToken() { | |
| pos = tokenPos = startPos; | |
| return token = scanJsxToken(); | |
| } | |
| function reScanLessThanToken() { | |
| if (token === 47) { | |
| pos = tokenPos + 1; | |
| return token = 29; | |
| } | |
| return token; | |
| } | |
| function reScanQuestionToken() { | |
| ts_Debug.assert(token === 60, "'reScanQuestionToken' should only be called on a '??'"); | |
| pos = tokenPos + 1; | |
| return token = 57; | |
| } | |
| function scanJsxToken() { | |
| startPos = tokenPos = pos; | |
| if (pos >= end) { | |
| return token = 1; | |
| } | |
| var char = text.charCodeAt(pos); | |
| if (char === 60) { | |
| if (text.charCodeAt(pos + 1) === 47) { | |
| pos += 2; | |
| return token = 30; | |
| } | |
| pos++; | |
| return token = 29; | |
| } | |
| if (char === 123) { | |
| pos++; | |
| return token = 18; | |
| } | |
| var firstNonWhitespace = 0; | |
| var lastNonWhitespace = -1; | |
| while (pos < end) { | |
| if (!isWhiteSpaceSingleLine(char)) { | |
| lastNonWhitespace = pos; | |
| } | |
| char = text.charCodeAt(pos); | |
| if (char === 123) { | |
| break; | |
| } | |
| if (char === 60) { | |
| if (isConflictMarkerTrivia(text, pos)) { | |
| pos = scanConflictMarkerTrivia(text, pos, error); | |
| return token = 7; | |
| } | |
| break; | |
| } | |
| if (lastNonWhitespace > 0) | |
| lastNonWhitespace++; | |
| if (isLineBreak(char) && firstNonWhitespace === 0) { | |
| firstNonWhitespace = -1; | |
| } | |
| else if (!isWhiteSpaceLike(char)) { | |
| firstNonWhitespace = pos; | |
| } | |
| pos++; | |
| } | |
| var endPosition = lastNonWhitespace === -1 ? pos : lastNonWhitespace; | |
| tokenValue = text.substring(startPos, endPosition); | |
| return firstNonWhitespace === -1 ? 12 : 11; | |
| } | |
| function scanJsxIdentifier() { | |
| if (tokenIsIdentifierOrKeyword(token)) { | |
| while (pos < end) { | |
| var ch = text.charCodeAt(pos); | |
| if (ch === 45) { | |
| tokenValue += "-"; | |
| pos++; | |
| continue; | |
| } | |
| var oldPos = pos; | |
| tokenValue += scanIdentifierParts(); | |
| if (pos === oldPos) { | |
| break; | |
| } | |
| } | |
| } | |
| return token; | |
| } | |
| function scanJsxAttributeValue() { | |
| startPos = pos; | |
| switch (text.charCodeAt(pos)) { | |
| case 34: | |
| case 39: | |
| tokenValue = scanString(true); | |
| return token = 10; | |
| default: | |
| return scan(); | |
| } | |
| } | |
| function reScanJsxAttributeValue() { | |
| pos = tokenPos = startPos; | |
| return scanJsxAttributeValue(); | |
| } | |
| function scanJsDocToken() { | |
| startPos = tokenPos = pos; | |
| tokenFlags = 0; | |
| if (pos >= end) { | |
| return token = 1; | |
| } | |
| var ch = codePointAt(text, pos); | |
| pos += charSize(ch); | |
| switch (ch) { | |
| case 9: | |
| case 11: | |
| case 12: | |
| case 32: | |
| while (pos < end && isWhiteSpaceSingleLine(text.charCodeAt(pos))) { | |
| pos++; | |
| } | |
| return token = 5; | |
| case 64: | |
| return token = 59; | |
| case 10: | |
| case 13: | |
| tokenFlags |= 1; | |
| return token = 4; | |
| case 42: | |
| return token = 41; | |
| case 123: | |
| return token = 18; | |
| case 125: | |
| return token = 19; | |
| case 91: | |
| return token = 22; | |
| case 93: | |
| return token = 23; | |
| case 60: | |
| return token = 29; | |
| case 62: | |
| return token = 31; | |
| case 61: | |
| return token = 62; | |
| case 44: | |
| return token = 27; | |
| case 46: | |
| return token = 24; | |
| case 96: | |
| return token = 61; | |
| case 92: | |
| pos--; | |
| var extendedCookedChar = peekExtendedUnicodeEscape(); | |
| if (extendedCookedChar >= 0 && isIdentifierStart(extendedCookedChar, languageVersion)) { | |
| pos += 3; | |
| tokenFlags |= 8; | |
| tokenValue = scanExtendedUnicodeEscape() + scanIdentifierParts(); | |
| return token = getIdentifierToken(); | |
| } | |
| var cookedChar = peekUnicodeEscape(); | |
| if (cookedChar >= 0 && isIdentifierStart(cookedChar, languageVersion)) { | |
| pos += 6; | |
| tokenFlags |= 1024; | |
| tokenValue = String.fromCharCode(cookedChar) + scanIdentifierParts(); | |
| return token = getIdentifierToken(); | |
| } | |
| pos++; | |
| return token = 0; | |
| } | |
| if (isIdentifierStart(ch, languageVersion)) { | |
| var char = ch; | |
| while (pos < end && isIdentifierPart(char = codePointAt(text, pos), languageVersion) || text.charCodeAt(pos) === 45) | |
| pos += charSize(char); | |
| tokenValue = text.substring(tokenPos, pos); | |
| if (char === 92) { | |
| tokenValue += scanIdentifierParts(); | |
| } | |
| return token = getIdentifierToken(); | |
| } | |
| else { | |
| return token = 0; | |
| } | |
| } | |
| function speculationHelper(callback, isLookahead) { | |
| var savePos = pos; | |
| var saveStartPos = startPos; | |
| var saveTokenPos = tokenPos; | |
| var saveToken = token; | |
| var saveTokenValue = tokenValue; | |
| var saveTokenFlags = tokenFlags; | |
| var result = callback(); | |
| if (!result || isLookahead) { | |
| pos = savePos; | |
| startPos = saveStartPos; | |
| tokenPos = saveTokenPos; | |
| token = saveToken; | |
| tokenValue = saveTokenValue; | |
| tokenFlags = saveTokenFlags; | |
| } | |
| return result; | |
| } | |
| function scanRange(start, length, callback) { | |
| var saveEnd = end; | |
| var savePos = pos; | |
| var saveStartPos = startPos; | |
| var saveTokenPos = tokenPos; | |
| var saveToken = token; | |
| var saveTokenValue = tokenValue; | |
| var saveTokenFlags = tokenFlags; | |
| setText(text, start, length); | |
| var result = callback(); | |
| end = saveEnd; | |
| pos = savePos; | |
| startPos = saveStartPos; | |
| tokenPos = saveTokenPos; | |
| token = saveToken; | |
| tokenValue = saveTokenValue; | |
| tokenFlags = saveTokenFlags; | |
| return result; | |
| } | |
| function lookAhead(callback) { | |
| return speculationHelper(callback, true); | |
| } | |
| function tryScan(callback) { | |
| return speculationHelper(callback, false); | |
| } | |
| function getText() { | |
| return text; | |
| } | |
| function setText(newText, start, length) { | |
| text = newText || ""; | |
| end = length === undefined ? text.length : start + length; | |
| setTextPos(start || 0); | |
| } | |
| function setOnError(errorCallback) { | |
| onError = errorCallback; | |
| } | |
| function setScriptTarget(scriptTarget) { | |
| languageVersion = scriptTarget; | |
| } | |
| function setLanguageVariant(variant) { | |
| languageVariant = variant; | |
| } | |
| function setTextPos(textPos) { | |
| ts_Debug.assert(textPos >= 0); | |
| pos = textPos; | |
| startPos = textPos; | |
| tokenPos = textPos; | |
| token = 0; | |
| tokenValue = undefined; | |
| tokenFlags = 0; | |
| } | |
| function setInJSDocType(inType) { | |
| inJSDocType += inType ? 1 : -1; | |
| } | |
| } | |
| ts_createScanner = createScanner; | |
| var codePointAt = String.prototype.codePointAt ? function (s, i) { return s.codePointAt(i); } : function codePointAt(str, i) { | |
| var size = str.length; | |
| if (i < 0 || i >= size) { | |
| return undefined; | |
| } | |
| var first = str.charCodeAt(i); | |
| if (first >= 0xD800 && first <= 0xDBFF && size > i + 1) { | |
| var second = str.charCodeAt(i + 1); | |
| if (second >= 0xDC00 && second <= 0xDFFF) { | |
| return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; | |
| } | |
| } | |
| return first; | |
| }; | |
| function charSize(ch) { | |
| if (ch >= 0x10000) { | |
| return 2; | |
| } | |
| return 1; | |
| } | |
| function utf16EncodeAsStringFallback(codePoint) { | |
| ts_Debug.assert(0x0 <= codePoint && codePoint <= 0x10FFFF); | |
| if (codePoint <= 65535) { | |
| return String.fromCharCode(codePoint); | |
| } | |
| var codeUnit1 = Math.floor((codePoint - 65536) / 1024) + 0xD800; | |
| var codeUnit2 = ((codePoint - 65536) % 1024) + 0xDC00; | |
| return String.fromCharCode(codeUnit1, codeUnit2); | |
| } | |
| var utf16EncodeAsStringWorker = String.fromCodePoint ? function (codePoint) { return String.fromCodePoint(codePoint); } : utf16EncodeAsStringFallback; | |
| function utf16EncodeAsString(codePoint) { | |
| return utf16EncodeAsStringWorker(codePoint); | |
| } | |
| ts_utf16EncodeAsString = utf16EncodeAsString; | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| function isExternalModuleNameRelative(moduleName) { | |
| return ts_pathIsRelative(moduleName) || ts_isRootedDiskPath(moduleName); | |
| } | |
| ts_isExternalModuleNameRelative = isExternalModuleNameRelative; | |
| function sortAndDeduplicateDiagnostics(diagnostics) { | |
| return ts_sortAndDeduplicate(diagnostics, ts_compareDiagnostics); | |
| } | |
| ts_sortAndDeduplicateDiagnostics = sortAndDeduplicateDiagnostics; | |
| function getDefaultLibFileName(options) { | |
| switch (options.target) { | |
| case 99: | |
| return "lib.esnext.full.d.ts"; | |
| case 7: | |
| return "lib.es2020.full.d.ts"; | |
| case 6: | |
| return "lib.es2019.full.d.ts"; | |
| case 5: | |
| return "lib.es2018.full.d.ts"; | |
| case 4: | |
| return "lib.es2017.full.d.ts"; | |
| case 3: | |
| return "lib.es2016.full.d.ts"; | |
| case 2: | |
| return "lib.es6.d.ts"; | |
| default: | |
| return "lib.d.ts"; | |
| } | |
| } | |
| ts_getDefaultLibFileName = getDefaultLibFileName; | |
| function textSpanEnd(span) { | |
| return span.start + span.length; | |
| } | |
| ts_textSpanEnd = textSpanEnd; | |
| function textSpanIsEmpty(span) { | |
| return span.length === 0; | |
| } | |
| ts_textSpanIsEmpty = textSpanIsEmpty; | |
| function textSpanContainsPosition(span, position) { | |
| return position >= span.start && position < textSpanEnd(span); | |
| } | |
| ts_textSpanContainsPosition = textSpanContainsPosition; | |
| function textRangeContainsPositionInclusive(span, position) { | |
| return position >= span.pos && position <= span.end; | |
| } | |
| ts_textRangeContainsPositionInclusive = textRangeContainsPositionInclusive; | |
| function textSpanContainsTextSpan(span, other) { | |
| return other.start >= span.start && textSpanEnd(other) <= textSpanEnd(span); | |
| } | |
| ts_textSpanContainsTextSpan = textSpanContainsTextSpan; | |
| function textSpanOverlapsWith(span, other) { | |
| return textSpanOverlap(span, other) !== undefined; | |
| } | |
| ts_textSpanOverlapsWith = textSpanOverlapsWith; | |
| function textSpanOverlap(span1, span2) { | |
| var overlap = textSpanIntersection(span1, span2); | |
| return overlap && overlap.length === 0 ? undefined : overlap; | |
| } | |
| ts_textSpanOverlap = textSpanOverlap; | |
| function textSpanIntersectsWithTextSpan(span, other) { | |
| return decodedTextSpanIntersectsWith(span.start, span.length, other.start, other.length); | |
| } | |
| ts_textSpanIntersectsWithTextSpan = textSpanIntersectsWithTextSpan; | |
| function textSpanIntersectsWith(span, start, length) { | |
| return decodedTextSpanIntersectsWith(span.start, span.length, start, length); | |
| } | |
| ts_textSpanIntersectsWith = textSpanIntersectsWith; | |
| function decodedTextSpanIntersectsWith(start1, length1, start2, length2) { | |
| var end1 = start1 + length1; | |
| var end2 = start2 + length2; | |
| return start2 <= end1 && end2 >= start1; | |
| } | |
| ts_decodedTextSpanIntersectsWith = decodedTextSpanIntersectsWith; | |
| function textSpanIntersectsWithPosition(span, position) { | |
| return position <= textSpanEnd(span) && position >= span.start; | |
| } | |
| ts_textSpanIntersectsWithPosition = textSpanIntersectsWithPosition; | |
| function textSpanIntersection(span1, span2) { | |
| var start = Math.max(span1.start, span2.start); | |
| var end = Math.min(textSpanEnd(span1), textSpanEnd(span2)); | |
| return start <= end ? createTextSpanFromBounds(start, end) : undefined; | |
| } | |
| ts_textSpanIntersection = textSpanIntersection; | |
| function createTextSpan(start, length) { | |
| if (start < 0) { | |
| throw new Error("start < 0"); | |
| } | |
| if (length < 0) { | |
| throw new Error("length < 0"); | |
| } | |
| return { start: start, length: length }; | |
| } | |
| ts_createTextSpan = createTextSpan; | |
| function createTextSpanFromBounds(start, end) { | |
| return createTextSpan(start, end - start); | |
| } | |
| ts_createTextSpanFromBounds = createTextSpanFromBounds; | |
| function textChangeRangeNewSpan(range) { | |
| return createTextSpan(range.span.start, range.newLength); | |
| } | |
| ts_textChangeRangeNewSpan = textChangeRangeNewSpan; | |
| function textChangeRangeIsUnchanged(range) { | |
| return textSpanIsEmpty(range.span) && range.newLength === 0; | |
| } | |
| ts_textChangeRangeIsUnchanged = textChangeRangeIsUnchanged; | |
| function createTextChangeRange(span, newLength) { | |
| if (newLength < 0) { | |
| throw new Error("newLength < 0"); | |
| } | |
| return { span: span, newLength: newLength }; | |
| } | |
| ts_createTextChangeRange = createTextChangeRange; | |
| ts_unchangedTextChangeRange = createTextChangeRange(createTextSpan(0, 0), 0); | |
| function collapseTextChangeRangesAcrossMultipleVersions(changes) { | |
| if (changes.length === 0) { | |
| return ts_unchangedTextChangeRange; | |
| } | |
| if (changes.length === 1) { | |
| return changes[0]; | |
| } | |
| var change0 = changes[0]; | |
| var oldStartN = change0.span.start; | |
| var oldEndN = textSpanEnd(change0.span); | |
| var newEndN = oldStartN + change0.newLength; | |
| for (var i = 1; i < changes.length; i++) { | |
| var nextChange = changes[i]; | |
| var oldStart1 = oldStartN; | |
| var oldEnd1 = oldEndN; | |
| var newEnd1 = newEndN; | |
| var oldStart2 = nextChange.span.start; | |
| var oldEnd2 = textSpanEnd(nextChange.span); | |
| var newEnd2 = oldStart2 + nextChange.newLength; | |
| oldStartN = Math.min(oldStart1, oldStart2); | |
| oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)); | |
| newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2)); | |
| } | |
| return createTextChangeRange(createTextSpanFromBounds(oldStartN, oldEndN), newEndN - oldStartN); | |
| } | |
| ts_collapseTextChangeRangesAcrossMultipleVersions = collapseTextChangeRangesAcrossMultipleVersions; | |
| function getTypeParameterOwner(d) { | |
| if (d && d.kind === 155) { | |
| for (var current = d; current; current = current.parent) { | |
| if (isFunctionLike(current) || isClassLike(current) || current.kind === 246) { | |
| return current; | |
| } | |
| } | |
| } | |
| } | |
| ts_getTypeParameterOwner = getTypeParameterOwner; | |
| function isParameterPropertyDeclaration(node, parent) { | |
| return ts_hasModifier(node, 92) && parent.kind === 162; | |
| } | |
| ts_isParameterPropertyDeclaration = isParameterPropertyDeclaration; | |
| function isEmptyBindingPattern(node) { | |
| if (isBindingPattern(node)) { | |
| return ts_every(node.elements, isEmptyBindingElement); | |
| } | |
| return false; | |
| } | |
| ts_isEmptyBindingPattern = isEmptyBindingPattern; | |
| function isEmptyBindingElement(node) { | |
| if (isOmittedExpression(node)) { | |
| return true; | |
| } | |
| return isEmptyBindingPattern(node.name); | |
| } | |
| ts_isEmptyBindingElement = isEmptyBindingElement; | |
| function walkUpBindingElementsAndPatterns(binding) { | |
| var node = binding.parent; | |
| while (isBindingElement(node.parent)) { | |
| node = node.parent.parent; | |
| } | |
| return node.parent; | |
| } | |
| ts_walkUpBindingElementsAndPatterns = walkUpBindingElementsAndPatterns; | |
| function getCombinedFlags(node, getFlags) { | |
| if (isBindingElement(node)) { | |
| node = walkUpBindingElementsAndPatterns(node); | |
| } | |
| var flags = getFlags(node); | |
| if (node.kind === 242) { | |
| node = node.parent; | |
| } | |
| if (node && node.kind === 243) { | |
| flags |= getFlags(node); | |
| node = node.parent; | |
| } | |
| if (node && node.kind === 225) { | |
| flags |= getFlags(node); | |
| } | |
| return flags; | |
| } | |
| function getCombinedModifierFlags(node) { | |
| return getCombinedFlags(node, ts_getModifierFlags); | |
| } | |
| ts_getCombinedModifierFlags = getCombinedModifierFlags; | |
| function getCombinedNodeFlags(node) { | |
| return getCombinedFlags(node, function (n) { return n.flags; }); | |
| } | |
| ts_getCombinedNodeFlags = getCombinedNodeFlags; | |
| function validateLocaleAndSetLanguage(locale, sys, errors) { | |
| var matchResult = /^([a-z]+)([_\-]([a-z]+))?$/.exec(locale.toLowerCase()); | |
| if (!matchResult) { | |
| if (errors) { | |
| errors.push(ts_createCompilerDiagnostic(ts_Diagnostics.Locale_must_be_of_the_form_language_or_language_territory_For_example_0_or_1, "en", "ja-jp")); | |
| } | |
| return; | |
| } | |
| var language = matchResult[1]; | |
| var territory = matchResult[3]; | |
| if (!trySetLanguageAndTerritory(language, territory, errors)) { | |
| trySetLanguageAndTerritory(language, undefined, errors); | |
| } | |
| ts_setUILocale(locale); | |
| function trySetLanguageAndTerritory(language, territory, errors) { | |
| var compilerFilePath = ts_normalizePath(sys.getExecutingFilePath()); | |
| var containingDirectoryPath = ts_getDirectoryPath(compilerFilePath); | |
| var filePath = ts_combinePaths(containingDirectoryPath, language); | |
| if (territory) { | |
| filePath = filePath + "-" + territory; | |
| } | |
| filePath = sys.resolvePath(ts_combinePaths(filePath, "diagnosticMessages.generated.json")); | |
| if (!sys.fileExists(filePath)) { | |
| return false; | |
| } | |
| var fileContents = ""; | |
| try { | |
| fileContents = sys.readFile(filePath); | |
| } | |
| catch (e) { | |
| if (errors) { | |
| errors.push(ts_createCompilerDiagnostic(ts_Diagnostics.Unable_to_open_file_0, filePath)); | |
| } | |
| return false; | |
| } | |
| try { | |
| ts_setLocalizedDiagnosticMessages(JSON.parse(fileContents)); | |
| } | |
| catch (_a) { | |
| if (errors) { | |
| errors.push(ts_createCompilerDiagnostic(ts_Diagnostics.Corrupted_locale_file_0, filePath)); | |
| } | |
| return false; | |
| } | |
| return true; | |
| } | |
| } | |
| ts_validateLocaleAndSetLanguage = validateLocaleAndSetLanguage; | |
| function getOriginalNode(node, nodeTest) { | |
| if (node) { | |
| while (node.original !== undefined) { | |
| node = node.original; | |
| } | |
| } | |
| return !nodeTest || nodeTest(node) ? node : undefined; | |
| } | |
| ts_getOriginalNode = getOriginalNode; | |
| function isParseTreeNode(node) { | |
| return (node.flags & 8) === 0; | |
| } | |
| ts_isParseTreeNode = isParseTreeNode; | |
| function getParseTreeNode(node, nodeTest) { | |
| if (node === undefined || isParseTreeNode(node)) { | |
| return node; | |
| } | |
| node = getOriginalNode(node); | |
| if (isParseTreeNode(node) && (!nodeTest || nodeTest(node))) { | |
| return node; | |
| } | |
| return undefined; | |
| } | |
| ts_getParseTreeNode = getParseTreeNode; | |
| function escapeLeadingUnderscores(identifier) { | |
| return (identifier.length >= 2 && identifier.charCodeAt(0) === 95 && identifier.charCodeAt(1) === 95 ? "_" + identifier : identifier); | |
| } | |
| ts_escapeLeadingUnderscores = escapeLeadingUnderscores; | |
| function unescapeLeadingUnderscores(identifier) { | |
| var id = identifier; | |
| return id.length >= 3 && id.charCodeAt(0) === 95 && id.charCodeAt(1) === 95 && id.charCodeAt(2) === 95 ? id.substr(1) : id; | |
| } | |
| ts_unescapeLeadingUnderscores = unescapeLeadingUnderscores; | |
| function idText(identifierOrPrivateName) { | |
| return unescapeLeadingUnderscores(identifierOrPrivateName.escapedText); | |
| } | |
| ts_idText = idText; | |
| function symbolName(symbol) { | |
| if (symbol.valueDeclaration && isPrivateIdentifierPropertyDeclaration(symbol.valueDeclaration)) { | |
| return idText(symbol.valueDeclaration.name); | |
| } | |
| return unescapeLeadingUnderscores(symbol.escapedName); | |
| } | |
| ts_symbolName = symbolName; | |
| function nameForNamelessJSDocTypedef(declaration) { | |
| var hostNode = declaration.parent.parent; | |
| if (!hostNode) { | |
| return undefined; | |
| } | |
| if (isDeclaration(hostNode)) { | |
| return getDeclarationIdentifier(hostNode); | |
| } | |
| switch (hostNode.kind) { | |
| case 225: | |
| if (hostNode.declarationList && hostNode.declarationList.declarations[0]) { | |
| return getDeclarationIdentifier(hostNode.declarationList.declarations[0]); | |
| } | |
| break; | |
| case 226: | |
| var expr = hostNode.expression; | |
| if (expr.kind === 209 && expr.operatorToken.kind === 62) { | |
| expr = expr.left; | |
| } | |
| switch (expr.kind) { | |
| case 194: | |
| return expr.name; | |
| case 195: | |
| var arg = expr.argumentExpression; | |
| if (isIdentifier(arg)) { | |
| return arg; | |
| } | |
| } | |
| break; | |
| case 200: { | |
| return getDeclarationIdentifier(hostNode.expression); | |
| } | |
| case 238: { | |
| if (isDeclaration(hostNode.statement) || isExpression(hostNode.statement)) { | |
| return getDeclarationIdentifier(hostNode.statement); | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| function getDeclarationIdentifier(node) { | |
| var name = getNameOfDeclaration(node); | |
| return name && isIdentifier(name) ? name : undefined; | |
| } | |
| function nodeHasName(statement, name) { | |
| if (isNamedDeclaration(statement) && isIdentifier(statement.name) && idText(statement.name) === idText(name)) { | |
| return true; | |
| } | |
| if (isVariableStatement(statement) && ts_some(statement.declarationList.declarations, function (d) { return nodeHasName(d, name); })) { | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_nodeHasName = nodeHasName; | |
| function getNameOfJSDocTypedef(declaration) { | |
| return declaration.name || nameForNamelessJSDocTypedef(declaration); | |
| } | |
| ts_getNameOfJSDocTypedef = getNameOfJSDocTypedef; | |
| function isNamedDeclaration(node) { | |
| return !!node.name; | |
| } | |
| ts_isNamedDeclaration = isNamedDeclaration; | |
| function getNonAssignedNameOfDeclaration(declaration) { | |
| switch (declaration.kind) { | |
| case 75: | |
| return declaration; | |
| case 322: | |
| case 316: { | |
| var name = declaration.name; | |
| if (name.kind === 153) { | |
| return name.right; | |
| } | |
| break; | |
| } | |
| case 196: | |
| case 209: { | |
| var expr_1 = declaration; | |
| switch (ts_getAssignmentDeclarationKind(expr_1)) { | |
| case 1: | |
| case 4: | |
| case 5: | |
| case 3: | |
| return ts_getElementOrPropertyAccessArgumentExpressionOrName(expr_1.left); | |
| case 7: | |
| case 8: | |
| case 9: | |
| return expr_1.arguments[1]; | |
| default: | |
| return undefined; | |
| } | |
| } | |
| case 321: | |
| return getNameOfJSDocTypedef(declaration); | |
| case 315: | |
| return nameForNamelessJSDocTypedef(declaration); | |
| case 259: { | |
| var expression = declaration.expression; | |
| return isIdentifier(expression) ? expression : undefined; | |
| } | |
| case 195: | |
| var expr = declaration; | |
| if (ts_isBindableStaticElementAccessExpression(expr)) { | |
| return expr.argumentExpression; | |
| } | |
| } | |
| return declaration.name; | |
| } | |
| ts_getNonAssignedNameOfDeclaration = getNonAssignedNameOfDeclaration; | |
| function getNameOfDeclaration(declaration) { | |
| if (declaration === undefined) | |
| return undefined; | |
| return getNonAssignedNameOfDeclaration(declaration) || | |
| (isFunctionExpression(declaration) || isClassExpression(declaration) ? getAssignedName(declaration) : undefined); | |
| } | |
| ts_getNameOfDeclaration = getNameOfDeclaration; | |
| function getAssignedName(node) { | |
| if (!node.parent) { | |
| return undefined; | |
| } | |
| else if (isPropertyAssignment(node.parent) || isBindingElement(node.parent)) { | |
| return node.parent.name; | |
| } | |
| else if (isBinaryExpression(node.parent) && node === node.parent.right) { | |
| if (isIdentifier(node.parent.left)) { | |
| return node.parent.left; | |
| } | |
| else if (ts_isAccessExpression(node.parent.left)) { | |
| return ts_getElementOrPropertyAccessArgumentExpressionOrName(node.parent.left); | |
| } | |
| } | |
| else if (isVariableDeclaration(node.parent) && isIdentifier(node.parent.name)) { | |
| return node.parent.name; | |
| } | |
| } | |
| function getJSDocParameterTags(param) { | |
| if (param.name) { | |
| if (isIdentifier(param.name)) { | |
| var name_1 = param.name.escapedText; | |
| return getJSDocTags(param.parent).filter(function (tag) { return isJSDocParameterTag(tag) && isIdentifier(tag.name) && tag.name.escapedText === name_1; }); | |
| } | |
| else { | |
| var i = param.parent.parameters.indexOf(param); | |
| ts_Debug.assert(i > -1, "Parameters should always be in their parents' parameter list"); | |
| var paramTags = getJSDocTags(param.parent).filter(isJSDocParameterTag); | |
| if (i < paramTags.length) { | |
| return [paramTags[i]]; | |
| } | |
| } | |
| } | |
| return ts_emptyArray; | |
| } | |
| ts_getJSDocParameterTags = getJSDocParameterTags; | |
| function getJSDocTypeParameterTags(param) { | |
| var name = param.name.escapedText; | |
| return getJSDocTags(param.parent).filter(function (tag) { | |
| return isJSDocTemplateTag(tag) && tag.typeParameters.some(function (tp) { return tp.name.escapedText === name; }); | |
| }); | |
| } | |
| ts_getJSDocTypeParameterTags = getJSDocTypeParameterTags; | |
| function hasJSDocParameterTags(node) { | |
| return !!getFirstJSDocTag(node, isJSDocParameterTag); | |
| } | |
| ts_hasJSDocParameterTags = hasJSDocParameterTags; | |
| function getJSDocAugmentsTag(node) { | |
| return getFirstJSDocTag(node, isJSDocAugmentsTag); | |
| } | |
| ts_getJSDocAugmentsTag = getJSDocAugmentsTag; | |
| function getJSDocClassTag(node) { | |
| return getFirstJSDocTag(node, isJSDocClassTag); | |
| } | |
| ts_getJSDocClassTag = getJSDocClassTag; | |
| function getJSDocPublicTag(node) { | |
| return getFirstJSDocTag(node, isJSDocPublicTag); | |
| } | |
| ts_getJSDocPublicTag = getJSDocPublicTag; | |
| function getJSDocPrivateTag(node) { | |
| return getFirstJSDocTag(node, isJSDocPrivateTag); | |
| } | |
| ts_getJSDocPrivateTag = getJSDocPrivateTag; | |
| function getJSDocProtectedTag(node) { | |
| return getFirstJSDocTag(node, isJSDocProtectedTag); | |
| } | |
| ts_getJSDocProtectedTag = getJSDocProtectedTag; | |
| function getJSDocReadonlyTag(node) { | |
| return getFirstJSDocTag(node, isJSDocReadonlyTag); | |
| } | |
| ts_getJSDocReadonlyTag = getJSDocReadonlyTag; | |
| function getJSDocEnumTag(node) { | |
| return getFirstJSDocTag(node, isJSDocEnumTag); | |
| } | |
| ts_getJSDocEnumTag = getJSDocEnumTag; | |
| function getJSDocThisTag(node) { | |
| return getFirstJSDocTag(node, isJSDocThisTag); | |
| } | |
| ts_getJSDocThisTag = getJSDocThisTag; | |
| function getJSDocReturnTag(node) { | |
| return getFirstJSDocTag(node, isJSDocReturnTag); | |
| } | |
| ts_getJSDocReturnTag = getJSDocReturnTag; | |
| function getJSDocTemplateTag(node) { | |
| return getFirstJSDocTag(node, isJSDocTemplateTag); | |
| } | |
| ts_getJSDocTemplateTag = getJSDocTemplateTag; | |
| function getJSDocTypeTag(node) { | |
| var tag = getFirstJSDocTag(node, isJSDocTypeTag); | |
| if (tag && tag.typeExpression && tag.typeExpression.type) { | |
| return tag; | |
| } | |
| return undefined; | |
| } | |
| ts_getJSDocTypeTag = getJSDocTypeTag; | |
| function getJSDocType(node) { | |
| var tag = getFirstJSDocTag(node, isJSDocTypeTag); | |
| if (!tag && isParameter(node)) { | |
| tag = ts_find(getJSDocParameterTags(node), function (tag) { return !!tag.typeExpression; }); | |
| } | |
| return tag && tag.typeExpression && tag.typeExpression.type; | |
| } | |
| ts_getJSDocType = getJSDocType; | |
| function getJSDocReturnType(node) { | |
| var returnTag = getJSDocReturnTag(node); | |
| if (returnTag && returnTag.typeExpression) { | |
| return returnTag.typeExpression.type; | |
| } | |
| var typeTag = getJSDocTypeTag(node); | |
| if (typeTag && typeTag.typeExpression) { | |
| var type = typeTag.typeExpression.type; | |
| if (isTypeLiteralNode(type)) { | |
| var sig = ts_find(type.members, isCallSignatureDeclaration); | |
| return sig && sig.type; | |
| } | |
| if (isFunctionTypeNode(type)) { | |
| return type.type; | |
| } | |
| } | |
| } | |
| ts_getJSDocReturnType = getJSDocReturnType; | |
| function getJSDocTags(node) { | |
| var tags = node.jsDocCache; | |
| if (tags === undefined) { | |
| var comments = ts_getJSDocCommentsAndTags(node); | |
| ts_Debug.assert(comments.length < 2 || comments[0] !== comments[1]); | |
| node.jsDocCache = tags = ts_flatMap(comments, function (j) { return isJSDoc(j) ? j.tags : j; }); | |
| } | |
| return tags; | |
| } | |
| ts_getJSDocTags = getJSDocTags; | |
| function getFirstJSDocTag(node, predicate) { | |
| return ts_find(getJSDocTags(node), predicate); | |
| } | |
| function getAllJSDocTagsOfKind(node, kind) { | |
| return getJSDocTags(node).filter(function (doc) { return doc.kind === kind; }); | |
| } | |
| ts_getAllJSDocTagsOfKind = getAllJSDocTagsOfKind; | |
| function getEffectiveTypeParameterDeclarations(node) { | |
| if (isJSDocSignature(node)) { | |
| return ts_emptyArray; | |
| } | |
| if (ts_isJSDocTypeAlias(node)) { | |
| ts_Debug.assert(node.parent.kind === 303); | |
| return ts_flatMap(node.parent.tags, function (tag) { return isJSDocTemplateTag(tag) ? tag.typeParameters : undefined; }); | |
| } | |
| if (node.typeParameters) { | |
| return node.typeParameters; | |
| } | |
| if (ts_isInJSFile(node)) { | |
| var decls = ts_getJSDocTypeParameterDeclarations(node); | |
| if (decls.length) { | |
| return decls; | |
| } | |
| var typeTag = getJSDocType(node); | |
| if (typeTag && isFunctionTypeNode(typeTag) && typeTag.typeParameters) { | |
| return typeTag.typeParameters; | |
| } | |
| } | |
| return ts_emptyArray; | |
| } | |
| ts_getEffectiveTypeParameterDeclarations = getEffectiveTypeParameterDeclarations; | |
| function getEffectiveConstraintOfTypeParameter(node) { | |
| return node.constraint ? node.constraint : | |
| isJSDocTemplateTag(node.parent) && node === node.parent.typeParameters[0] ? node.parent.constraint : | |
| undefined; | |
| } | |
| ts_getEffectiveConstraintOfTypeParameter = getEffectiveConstraintOfTypeParameter; | |
| function isNumericLiteral(node) { | |
| return node.kind === 8; | |
| } | |
| ts_isNumericLiteral = isNumericLiteral; | |
| function isBigIntLiteral(node) { | |
| return node.kind === 9; | |
| } | |
| ts_isBigIntLiteral = isBigIntLiteral; | |
| function isStringLiteral(node) { | |
| return node.kind === 10; | |
| } | |
| ts_isStringLiteral = isStringLiteral; | |
| function isJsxText(node) { | |
| return node.kind === 11; | |
| } | |
| ts_isJsxText = isJsxText; | |
| function isRegularExpressionLiteral(node) { | |
| return node.kind === 13; | |
| } | |
| ts_isRegularExpressionLiteral = isRegularExpressionLiteral; | |
| function isNoSubstitutionTemplateLiteral(node) { | |
| return node.kind === 14; | |
| } | |
| ts_isNoSubstitutionTemplateLiteral = isNoSubstitutionTemplateLiteral; | |
| function isTemplateHead(node) { | |
| return node.kind === 15; | |
| } | |
| ts_isTemplateHead = isTemplateHead; | |
| function isTemplateMiddle(node) { | |
| return node.kind === 16; | |
| } | |
| ts_isTemplateMiddle = isTemplateMiddle; | |
| function isTemplateTail(node) { | |
| return node.kind === 17; | |
| } | |
| ts_isTemplateTail = isTemplateTail; | |
| function isIdentifier(node) { | |
| return node.kind === 75; | |
| } | |
| ts_isIdentifier = isIdentifier; | |
| function isQualifiedName(node) { | |
| return node.kind === 153; | |
| } | |
| ts_isQualifiedName = isQualifiedName; | |
| function isComputedPropertyName(node) { | |
| return node.kind === 154; | |
| } | |
| ts_isComputedPropertyName = isComputedPropertyName; | |
| function isPrivateIdentifier(node) { | |
| return node.kind === 76; | |
| } | |
| ts_isPrivateIdentifier = isPrivateIdentifier; | |
| function isIdentifierOrPrivateIdentifier(node) { | |
| return node.kind === 75 || node.kind === 76; | |
| } | |
| ts_isIdentifierOrPrivateIdentifier = isIdentifierOrPrivateIdentifier; | |
| function isTypeParameterDeclaration(node) { | |
| return node.kind === 155; | |
| } | |
| ts_isTypeParameterDeclaration = isTypeParameterDeclaration; | |
| function isParameter(node) { | |
| return node.kind === 156; | |
| } | |
| ts_isParameter = isParameter; | |
| function isDecorator(node) { | |
| return node.kind === 157; | |
| } | |
| ts_isDecorator = isDecorator; | |
| function isPropertySignature(node) { | |
| return node.kind === 158; | |
| } | |
| ts_isPropertySignature = isPropertySignature; | |
| function isPropertyDeclaration(node) { | |
| return node.kind === 159; | |
| } | |
| ts_isPropertyDeclaration = isPropertyDeclaration; | |
| function isMethodSignature(node) { | |
| return node.kind === 160; | |
| } | |
| ts_isMethodSignature = isMethodSignature; | |
| function isMethodDeclaration(node) { | |
| return node.kind === 161; | |
| } | |
| ts_isMethodDeclaration = isMethodDeclaration; | |
| function isConstructorDeclaration(node) { | |
| return node.kind === 162; | |
| } | |
| ts_isConstructorDeclaration = isConstructorDeclaration; | |
| function isGetAccessorDeclaration(node) { | |
| return node.kind === 163; | |
| } | |
| ts_isGetAccessorDeclaration = isGetAccessorDeclaration; | |
| function isSetAccessorDeclaration(node) { | |
| return node.kind === 164; | |
| } | |
| ts_isSetAccessorDeclaration = isSetAccessorDeclaration; | |
| function isCallSignatureDeclaration(node) { | |
| return node.kind === 165; | |
| } | |
| ts_isCallSignatureDeclaration = isCallSignatureDeclaration; | |
| function isConstructSignatureDeclaration(node) { | |
| return node.kind === 166; | |
| } | |
| ts_isConstructSignatureDeclaration = isConstructSignatureDeclaration; | |
| function isIndexSignatureDeclaration(node) { | |
| return node.kind === 167; | |
| } | |
| ts_isIndexSignatureDeclaration = isIndexSignatureDeclaration; | |
| function isGetOrSetAccessorDeclaration(node) { | |
| return node.kind === 164 || node.kind === 163; | |
| } | |
| ts_isGetOrSetAccessorDeclaration = isGetOrSetAccessorDeclaration; | |
| function isTypePredicateNode(node) { | |
| return node.kind === 168; | |
| } | |
| ts_isTypePredicateNode = isTypePredicateNode; | |
| function isTypeReferenceNode(node) { | |
| return node.kind === 169; | |
| } | |
| ts_isTypeReferenceNode = isTypeReferenceNode; | |
| function isFunctionTypeNode(node) { | |
| return node.kind === 170; | |
| } | |
| ts_isFunctionTypeNode = isFunctionTypeNode; | |
| function isConstructorTypeNode(node) { | |
| return node.kind === 171; | |
| } | |
| ts_isConstructorTypeNode = isConstructorTypeNode; | |
| function isTypeQueryNode(node) { | |
| return node.kind === 172; | |
| } | |
| ts_isTypeQueryNode = isTypeQueryNode; | |
| function isTypeLiteralNode(node) { | |
| return node.kind === 173; | |
| } | |
| ts_isTypeLiteralNode = isTypeLiteralNode; | |
| function isArrayTypeNode(node) { | |
| return node.kind === 174; | |
| } | |
| ts_isArrayTypeNode = isArrayTypeNode; | |
| function isTupleTypeNode(node) { | |
| return node.kind === 175; | |
| } | |
| ts_isTupleTypeNode = isTupleTypeNode; | |
| function isUnionTypeNode(node) { | |
| return node.kind === 178; | |
| } | |
| ts_isUnionTypeNode = isUnionTypeNode; | |
| function isIntersectionTypeNode(node) { | |
| return node.kind === 179; | |
| } | |
| ts_isIntersectionTypeNode = isIntersectionTypeNode; | |
| function isConditionalTypeNode(node) { | |
| return node.kind === 180; | |
| } | |
| ts_isConditionalTypeNode = isConditionalTypeNode; | |
| function isInferTypeNode(node) { | |
| return node.kind === 181; | |
| } | |
| ts_isInferTypeNode = isInferTypeNode; | |
| function isParenthesizedTypeNode(node) { | |
| return node.kind === 182; | |
| } | |
| ts_isParenthesizedTypeNode = isParenthesizedTypeNode; | |
| function isThisTypeNode(node) { | |
| return node.kind === 183; | |
| } | |
| ts_isThisTypeNode = isThisTypeNode; | |
| function isTypeOperatorNode(node) { | |
| return node.kind === 184; | |
| } | |
| ts_isTypeOperatorNode = isTypeOperatorNode; | |
| function isIndexedAccessTypeNode(node) { | |
| return node.kind === 185; | |
| } | |
| ts_isIndexedAccessTypeNode = isIndexedAccessTypeNode; | |
| function isMappedTypeNode(node) { | |
| return node.kind === 186; | |
| } | |
| ts_isMappedTypeNode = isMappedTypeNode; | |
| function isLiteralTypeNode(node) { | |
| return node.kind === 187; | |
| } | |
| ts_isLiteralTypeNode = isLiteralTypeNode; | |
| function isImportTypeNode(node) { | |
| return node.kind === 188; | |
| } | |
| ts_isImportTypeNode = isImportTypeNode; | |
| function isObjectBindingPattern(node) { | |
| return node.kind === 189; | |
| } | |
| ts_isObjectBindingPattern = isObjectBindingPattern; | |
| function isArrayBindingPattern(node) { | |
| return node.kind === 190; | |
| } | |
| ts_isArrayBindingPattern = isArrayBindingPattern; | |
| function isBindingElement(node) { | |
| return node.kind === 191; | |
| } | |
| ts_isBindingElement = isBindingElement; | |
| function isArrayLiteralExpression(node) { | |
| return node.kind === 192; | |
| } | |
| ts_isArrayLiteralExpression = isArrayLiteralExpression; | |
| function isObjectLiteralExpression(node) { | |
| return node.kind === 193; | |
| } | |
| ts_isObjectLiteralExpression = isObjectLiteralExpression; | |
| function isPropertyAccessExpression(node) { | |
| return node.kind === 194; | |
| } | |
| ts_isPropertyAccessExpression = isPropertyAccessExpression; | |
| function isPropertyAccessChain(node) { | |
| return isPropertyAccessExpression(node) && !!(node.flags & 32); | |
| } | |
| ts_isPropertyAccessChain = isPropertyAccessChain; | |
| function isElementAccessExpression(node) { | |
| return node.kind === 195; | |
| } | |
| ts_isElementAccessExpression = isElementAccessExpression; | |
| function isElementAccessChain(node) { | |
| return isElementAccessExpression(node) && !!(node.flags & 32); | |
| } | |
| ts_isElementAccessChain = isElementAccessChain; | |
| function isCallExpression(node) { | |
| return node.kind === 196; | |
| } | |
| ts_isCallExpression = isCallExpression; | |
| function isCallChain(node) { | |
| return isCallExpression(node) && !!(node.flags & 32); | |
| } | |
| ts_isCallChain = isCallChain; | |
| function isOptionalChain(node) { | |
| var kind = node.kind; | |
| return !!(node.flags & 32) && | |
| (kind === 194 | |
| || kind === 195 | |
| || kind === 196); | |
| } | |
| ts_isOptionalChain = isOptionalChain; | |
| function isOptionalChainRoot(node) { | |
| return isOptionalChain(node) && !!node.questionDotToken; | |
| } | |
| ts_isOptionalChainRoot = isOptionalChainRoot; | |
| function isExpressionOfOptionalChainRoot(node) { | |
| return isOptionalChainRoot(node.parent) && node.parent.expression === node; | |
| } | |
| ts_isExpressionOfOptionalChainRoot = isExpressionOfOptionalChainRoot; | |
| function isOutermostOptionalChain(node) { | |
| return !isOptionalChain(node.parent) | |
| || isOptionalChainRoot(node.parent) | |
| || node !== node.parent.expression; | |
| } | |
| ts_isOutermostOptionalChain = isOutermostOptionalChain; | |
| function isNullishCoalesce(node) { | |
| return node.kind === 209 && node.operatorToken.kind === 60; | |
| } | |
| ts_isNullishCoalesce = isNullishCoalesce; | |
| function isNewExpression(node) { | |
| return node.kind === 197; | |
| } | |
| ts_isNewExpression = isNewExpression; | |
| function isTaggedTemplateExpression(node) { | |
| return node.kind === 198; | |
| } | |
| ts_isTaggedTemplateExpression = isTaggedTemplateExpression; | |
| function isTypeAssertion(node) { | |
| return node.kind === 199; | |
| } | |
| ts_isTypeAssertion = isTypeAssertion; | |
| function isConstTypeReference(node) { | |
| return isTypeReferenceNode(node) && isIdentifier(node.typeName) && | |
| node.typeName.escapedText === "const" && !node.typeArguments; | |
| } | |
| ts_isConstTypeReference = isConstTypeReference; | |
| function isParenthesizedExpression(node) { | |
| return node.kind === 200; | |
| } | |
| ts_isParenthesizedExpression = isParenthesizedExpression; | |
| function skipPartiallyEmittedExpressions(node) { | |
| while (node.kind === 325) { | |
| node = node.expression; | |
| } | |
| return node; | |
| } | |
| ts_skipPartiallyEmittedExpressions = skipPartiallyEmittedExpressions; | |
| function isFunctionExpression(node) { | |
| return node.kind === 201; | |
| } | |
| ts_isFunctionExpression = isFunctionExpression; | |
| function isArrowFunction(node) { | |
| return node.kind === 202; | |
| } | |
| ts_isArrowFunction = isArrowFunction; | |
| function isDeleteExpression(node) { | |
| return node.kind === 203; | |
| } | |
| ts_isDeleteExpression = isDeleteExpression; | |
| function isTypeOfExpression(node) { | |
| return node.kind === 204; | |
| } | |
| ts_isTypeOfExpression = isTypeOfExpression; | |
| function isVoidExpression(node) { | |
| return node.kind === 205; | |
| } | |
| ts_isVoidExpression = isVoidExpression; | |
| function isAwaitExpression(node) { | |
| return node.kind === 206; | |
| } | |
| ts_isAwaitExpression = isAwaitExpression; | |
| function isPrefixUnaryExpression(node) { | |
| return node.kind === 207; | |
| } | |
| ts_isPrefixUnaryExpression = isPrefixUnaryExpression; | |
| function isPostfixUnaryExpression(node) { | |
| return node.kind === 208; | |
| } | |
| ts_isPostfixUnaryExpression = isPostfixUnaryExpression; | |
| function isBinaryExpression(node) { | |
| return node.kind === 209; | |
| } | |
| ts_isBinaryExpression = isBinaryExpression; | |
| function isConditionalExpression(node) { | |
| return node.kind === 210; | |
| } | |
| ts_isConditionalExpression = isConditionalExpression; | |
| function isTemplateExpression(node) { | |
| return node.kind === 211; | |
| } | |
| ts_isTemplateExpression = isTemplateExpression; | |
| function isYieldExpression(node) { | |
| return node.kind === 212; | |
| } | |
| ts_isYieldExpression = isYieldExpression; | |
| function isSpreadElement(node) { | |
| return node.kind === 213; | |
| } | |
| ts_isSpreadElement = isSpreadElement; | |
| function isClassExpression(node) { | |
| return node.kind === 214; | |
| } | |
| ts_isClassExpression = isClassExpression; | |
| function isOmittedExpression(node) { | |
| return node.kind === 215; | |
| } | |
| ts_isOmittedExpression = isOmittedExpression; | |
| function isExpressionWithTypeArguments(node) { | |
| return node.kind === 216; | |
| } | |
| ts_isExpressionWithTypeArguments = isExpressionWithTypeArguments; | |
| function isAsExpression(node) { | |
| return node.kind === 217; | |
| } | |
| ts_isAsExpression = isAsExpression; | |
| function isNonNullExpression(node) { | |
| return node.kind === 218; | |
| } | |
| ts_isNonNullExpression = isNonNullExpression; | |
| function isMetaProperty(node) { | |
| return node.kind === 219; | |
| } | |
| ts_isMetaProperty = isMetaProperty; | |
| function isTemplateSpan(node) { | |
| return node.kind === 221; | |
| } | |
| ts_isTemplateSpan = isTemplateSpan; | |
| function isSemicolonClassElement(node) { | |
| return node.kind === 222; | |
| } | |
| ts_isSemicolonClassElement = isSemicolonClassElement; | |
| function isBlock(node) { | |
| return node.kind === 223; | |
| } | |
| ts_isBlock = isBlock; | |
| function isVariableStatement(node) { | |
| return node.kind === 225; | |
| } | |
| ts_isVariableStatement = isVariableStatement; | |
| function isEmptyStatement(node) { | |
| return node.kind === 224; | |
| } | |
| ts_isEmptyStatement = isEmptyStatement; | |
| function isExpressionStatement(node) { | |
| return node.kind === 226; | |
| } | |
| ts_isExpressionStatement = isExpressionStatement; | |
| function isIfStatement(node) { | |
| return node.kind === 227; | |
| } | |
| ts_isIfStatement = isIfStatement; | |
| function isDoStatement(node) { | |
| return node.kind === 228; | |
| } | |
| ts_isDoStatement = isDoStatement; | |
| function isWhileStatement(node) { | |
| return node.kind === 229; | |
| } | |
| ts_isWhileStatement = isWhileStatement; | |
| function isForStatement(node) { | |
| return node.kind === 230; | |
| } | |
| ts_isForStatement = isForStatement; | |
| function isForInStatement(node) { | |
| return node.kind === 231; | |
| } | |
| ts_isForInStatement = isForInStatement; | |
| function isForOfStatement(node) { | |
| return node.kind === 232; | |
| } | |
| ts_isForOfStatement = isForOfStatement; | |
| function isContinueStatement(node) { | |
| return node.kind === 233; | |
| } | |
| ts_isContinueStatement = isContinueStatement; | |
| function isBreakStatement(node) { | |
| return node.kind === 234; | |
| } | |
| ts_isBreakStatement = isBreakStatement; | |
| function isBreakOrContinueStatement(node) { | |
| return node.kind === 234 || node.kind === 233; | |
| } | |
| ts_isBreakOrContinueStatement = isBreakOrContinueStatement; | |
| function isReturnStatement(node) { | |
| return node.kind === 235; | |
| } | |
| ts_isReturnStatement = isReturnStatement; | |
| function isWithStatement(node) { | |
| return node.kind === 236; | |
| } | |
| ts_isWithStatement = isWithStatement; | |
| function isSwitchStatement(node) { | |
| return node.kind === 237; | |
| } | |
| ts_isSwitchStatement = isSwitchStatement; | |
| function isLabeledStatement(node) { | |
| return node.kind === 238; | |
| } | |
| ts_isLabeledStatement = isLabeledStatement; | |
| function isThrowStatement(node) { | |
| return node.kind === 239; | |
| } | |
| ts_isThrowStatement = isThrowStatement; | |
| function isTryStatement(node) { | |
| return node.kind === 240; | |
| } | |
| ts_isTryStatement = isTryStatement; | |
| function isDebuggerStatement(node) { | |
| return node.kind === 241; | |
| } | |
| ts_isDebuggerStatement = isDebuggerStatement; | |
| function isVariableDeclaration(node) { | |
| return node.kind === 242; | |
| } | |
| ts_isVariableDeclaration = isVariableDeclaration; | |
| function isVariableDeclarationList(node) { | |
| return node.kind === 243; | |
| } | |
| ts_isVariableDeclarationList = isVariableDeclarationList; | |
| function isFunctionDeclaration(node) { | |
| return node.kind === 244; | |
| } | |
| ts_isFunctionDeclaration = isFunctionDeclaration; | |
| function isClassDeclaration(node) { | |
| return node.kind === 245; | |
| } | |
| ts_isClassDeclaration = isClassDeclaration; | |
| function isInterfaceDeclaration(node) { | |
| return node.kind === 246; | |
| } | |
| ts_isInterfaceDeclaration = isInterfaceDeclaration; | |
| function isTypeAliasDeclaration(node) { | |
| return node.kind === 247; | |
| } | |
| ts_isTypeAliasDeclaration = isTypeAliasDeclaration; | |
| function isEnumDeclaration(node) { | |
| return node.kind === 248; | |
| } | |
| ts_isEnumDeclaration = isEnumDeclaration; | |
| function isModuleDeclaration(node) { | |
| return node.kind === 249; | |
| } | |
| ts_isModuleDeclaration = isModuleDeclaration; | |
| function isModuleBlock(node) { | |
| return node.kind === 250; | |
| } | |
| ts_isModuleBlock = isModuleBlock; | |
| function isCaseBlock(node) { | |
| return node.kind === 251; | |
| } | |
| ts_isCaseBlock = isCaseBlock; | |
| function isNamespaceExportDeclaration(node) { | |
| return node.kind === 252; | |
| } | |
| ts_isNamespaceExportDeclaration = isNamespaceExportDeclaration; | |
| function isImportEqualsDeclaration(node) { | |
| return node.kind === 253; | |
| } | |
| ts_isImportEqualsDeclaration = isImportEqualsDeclaration; | |
| function isImportDeclaration(node) { | |
| return node.kind === 254; | |
| } | |
| ts_isImportDeclaration = isImportDeclaration; | |
| function isImportClause(node) { | |
| return node.kind === 255; | |
| } | |
| ts_isImportClause = isImportClause; | |
| function isNamespaceImport(node) { | |
| return node.kind === 256; | |
| } | |
| ts_isNamespaceImport = isNamespaceImport; | |
| function isNamespaceExport(node) { | |
| return node.kind === 262; | |
| } | |
| ts_isNamespaceExport = isNamespaceExport; | |
| function isNamedExportBindings(node) { | |
| return node.kind === 262 || node.kind === 261; | |
| } | |
| ts_isNamedExportBindings = isNamedExportBindings; | |
| function isNamedImports(node) { | |
| return node.kind === 257; | |
| } | |
| ts_isNamedImports = isNamedImports; | |
| function isImportSpecifier(node) { | |
| return node.kind === 258; | |
| } | |
| ts_isImportSpecifier = isImportSpecifier; | |
| function isExportAssignment(node) { | |
| return node.kind === 259; | |
| } | |
| ts_isExportAssignment = isExportAssignment; | |
| function isExportDeclaration(node) { | |
| return node.kind === 260; | |
| } | |
| ts_isExportDeclaration = isExportDeclaration; | |
| function isNamedExports(node) { | |
| return node.kind === 261; | |
| } | |
| ts_isNamedExports = isNamedExports; | |
| function isExportSpecifier(node) { | |
| return node.kind === 263; | |
| } | |
| ts_isExportSpecifier = isExportSpecifier; | |
| function isMissingDeclaration(node) { | |
| return node.kind === 264; | |
| } | |
| ts_isMissingDeclaration = isMissingDeclaration; | |
| function isExternalModuleReference(node) { | |
| return node.kind === 265; | |
| } | |
| ts_isExternalModuleReference = isExternalModuleReference; | |
| function isJsxElement(node) { | |
| return node.kind === 266; | |
| } | |
| ts_isJsxElement = isJsxElement; | |
| function isJsxSelfClosingElement(node) { | |
| return node.kind === 267; | |
| } | |
| ts_isJsxSelfClosingElement = isJsxSelfClosingElement; | |
| function isJsxOpeningElement(node) { | |
| return node.kind === 268; | |
| } | |
| ts_isJsxOpeningElement = isJsxOpeningElement; | |
| function isJsxClosingElement(node) { | |
| return node.kind === 269; | |
| } | |
| ts_isJsxClosingElement = isJsxClosingElement; | |
| function isJsxFragment(node) { | |
| return node.kind === 270; | |
| } | |
| ts_isJsxFragment = isJsxFragment; | |
| function isJsxOpeningFragment(node) { | |
| return node.kind === 271; | |
| } | |
| ts_isJsxOpeningFragment = isJsxOpeningFragment; | |
| function isJsxClosingFragment(node) { | |
| return node.kind === 272; | |
| } | |
| ts_isJsxClosingFragment = isJsxClosingFragment; | |
| function isJsxAttribute(node) { | |
| return node.kind === 273; | |
| } | |
| ts_isJsxAttribute = isJsxAttribute; | |
| function isJsxAttributes(node) { | |
| return node.kind === 274; | |
| } | |
| ts_isJsxAttributes = isJsxAttributes; | |
| function isJsxSpreadAttribute(node) { | |
| return node.kind === 275; | |
| } | |
| ts_isJsxSpreadAttribute = isJsxSpreadAttribute; | |
| function isJsxExpression(node) { | |
| return node.kind === 276; | |
| } | |
| ts_isJsxExpression = isJsxExpression; | |
| function isCaseClause(node) { | |
| return node.kind === 277; | |
| } | |
| ts_isCaseClause = isCaseClause; | |
| function isDefaultClause(node) { | |
| return node.kind === 278; | |
| } | |
| ts_isDefaultClause = isDefaultClause; | |
| function isHeritageClause(node) { | |
| return node.kind === 279; | |
| } | |
| ts_isHeritageClause = isHeritageClause; | |
| function isCatchClause(node) { | |
| return node.kind === 280; | |
| } | |
| ts_isCatchClause = isCatchClause; | |
| function isPropertyAssignment(node) { | |
| return node.kind === 281; | |
| } | |
| ts_isPropertyAssignment = isPropertyAssignment; | |
| function isShorthandPropertyAssignment(node) { | |
| return node.kind === 282; | |
| } | |
| ts_isShorthandPropertyAssignment = isShorthandPropertyAssignment; | |
| function isSpreadAssignment(node) { | |
| return node.kind === 283; | |
| } | |
| ts_isSpreadAssignment = isSpreadAssignment; | |
| function isEnumMember(node) { | |
| return node.kind === 284; | |
| } | |
| ts_isEnumMember = isEnumMember; | |
| function isSourceFile(node) { | |
| return node.kind === 290; | |
| } | |
| ts_isSourceFile = isSourceFile; | |
| function isBundle(node) { | |
| return node.kind === 291; | |
| } | |
| ts_isBundle = isBundle; | |
| function isUnparsedSource(node) { | |
| return node.kind === 292; | |
| } | |
| ts_isUnparsedSource = isUnparsedSource; | |
| function isUnparsedPrepend(node) { | |
| return node.kind === 286; | |
| } | |
| ts_isUnparsedPrepend = isUnparsedPrepend; | |
| function isUnparsedTextLike(node) { | |
| switch (node.kind) { | |
| case 287: | |
| case 288: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_isUnparsedTextLike = isUnparsedTextLike; | |
| function isUnparsedNode(node) { | |
| return isUnparsedTextLike(node) || | |
| node.kind === 285 || | |
| node.kind === 289; | |
| } | |
| ts_isUnparsedNode = isUnparsedNode; | |
| function isJSDocTypeExpression(node) { | |
| return node.kind === 294; | |
| } | |
| ts_isJSDocTypeExpression = isJSDocTypeExpression; | |
| function isJSDocAllType(node) { | |
| return node.kind === 295; | |
| } | |
| ts_isJSDocAllType = isJSDocAllType; | |
| function isJSDocUnknownType(node) { | |
| return node.kind === 296; | |
| } | |
| ts_isJSDocUnknownType = isJSDocUnknownType; | |
| function isJSDocNullableType(node) { | |
| return node.kind === 297; | |
| } | |
| ts_isJSDocNullableType = isJSDocNullableType; | |
| function isJSDocNonNullableType(node) { | |
| return node.kind === 298; | |
| } | |
| ts_isJSDocNonNullableType = isJSDocNonNullableType; | |
| function isJSDocOptionalType(node) { | |
| return node.kind === 299; | |
| } | |
| ts_isJSDocOptionalType = isJSDocOptionalType; | |
| function isJSDocFunctionType(node) { | |
| return node.kind === 300; | |
| } | |
| ts_isJSDocFunctionType = isJSDocFunctionType; | |
| function isJSDocVariadicType(node) { | |
| return node.kind === 301; | |
| } | |
| ts_isJSDocVariadicType = isJSDocVariadicType; | |
| function isJSDoc(node) { | |
| return node.kind === 303; | |
| } | |
| ts_isJSDoc = isJSDoc; | |
| function isJSDocAuthorTag(node) { | |
| return node.kind === 308; | |
| } | |
| ts_isJSDocAuthorTag = isJSDocAuthorTag; | |
| function isJSDocAugmentsTag(node) { | |
| return node.kind === 307; | |
| } | |
| ts_isJSDocAugmentsTag = isJSDocAugmentsTag; | |
| function isJSDocClassTag(node) { | |
| return node.kind === 309; | |
| } | |
| ts_isJSDocClassTag = isJSDocClassTag; | |
| function isJSDocPublicTag(node) { | |
| return node.kind === 310; | |
| } | |
| ts_isJSDocPublicTag = isJSDocPublicTag; | |
| function isJSDocPrivateTag(node) { | |
| return node.kind === 311; | |
| } | |
| ts_isJSDocPrivateTag = isJSDocPrivateTag; | |
| function isJSDocProtectedTag(node) { | |
| return node.kind === 312; | |
| } | |
| ts_isJSDocProtectedTag = isJSDocProtectedTag; | |
| function isJSDocReadonlyTag(node) { | |
| return node.kind === 313; | |
| } | |
| ts_isJSDocReadonlyTag = isJSDocReadonlyTag; | |
| function isJSDocEnumTag(node) { | |
| return node.kind === 315; | |
| } | |
| ts_isJSDocEnumTag = isJSDocEnumTag; | |
| function isJSDocThisTag(node) { | |
| return node.kind === 318; | |
| } | |
| ts_isJSDocThisTag = isJSDocThisTag; | |
| function isJSDocParameterTag(node) { | |
| return node.kind === 316; | |
| } | |
| ts_isJSDocParameterTag = isJSDocParameterTag; | |
| function isJSDocReturnTag(node) { | |
| return node.kind === 317; | |
| } | |
| ts_isJSDocReturnTag = isJSDocReturnTag; | |
| function isJSDocTypeTag(node) { | |
| return node.kind === 319; | |
| } | |
| ts_isJSDocTypeTag = isJSDocTypeTag; | |
| function isJSDocTemplateTag(node) { | |
| return node.kind === 320; | |
| } | |
| ts_isJSDocTemplateTag = isJSDocTemplateTag; | |
| function isJSDocTypedefTag(node) { | |
| return node.kind === 321; | |
| } | |
| ts_isJSDocTypedefTag = isJSDocTypedefTag; | |
| function isJSDocPropertyTag(node) { | |
| return node.kind === 322; | |
| } | |
| ts_isJSDocPropertyTag = isJSDocPropertyTag; | |
| function isJSDocPropertyLikeTag(node) { | |
| return node.kind === 322 || node.kind === 316; | |
| } | |
| ts_isJSDocPropertyLikeTag = isJSDocPropertyLikeTag; | |
| function isJSDocTypeLiteral(node) { | |
| return node.kind === 304; | |
| } | |
| ts_isJSDocTypeLiteral = isJSDocTypeLiteral; | |
| function isJSDocCallbackTag(node) { | |
| return node.kind === 314; | |
| } | |
| ts_isJSDocCallbackTag = isJSDocCallbackTag; | |
| function isJSDocSignature(node) { | |
| return node.kind === 305; | |
| } | |
| ts_isJSDocSignature = isJSDocSignature; | |
| function isSyntaxList(n) { | |
| return n.kind === 323; | |
| } | |
| ts_isSyntaxList = isSyntaxList; | |
| function isNode(node) { | |
| return isNodeKind(node.kind); | |
| } | |
| ts_isNode = isNode; | |
| function isNodeKind(kind) { | |
| return kind >= 153; | |
| } | |
| ts_isNodeKind = isNodeKind; | |
| function isToken(n) { | |
| return n.kind >= 0 && n.kind <= 152; | |
| } | |
| ts_isToken = isToken; | |
| function isNodeArray(array) { | |
| return array.hasOwnProperty("pos") && array.hasOwnProperty("end"); | |
| } | |
| ts_isNodeArray = isNodeArray; | |
| function isLiteralKind(kind) { | |
| return 8 <= kind && kind <= 14; | |
| } | |
| ts_isLiteralKind = isLiteralKind; | |
| function isLiteralExpression(node) { | |
| return isLiteralKind(node.kind); | |
| } | |
| ts_isLiteralExpression = isLiteralExpression; | |
| function isTemplateLiteralKind(kind) { | |
| return 14 <= kind && kind <= 17; | |
| } | |
| ts_isTemplateLiteralKind = isTemplateLiteralKind; | |
| function isTemplateLiteralToken(node) { | |
| return isTemplateLiteralKind(node.kind); | |
| } | |
| ts_isTemplateLiteralToken = isTemplateLiteralToken; | |
| function isTemplateMiddleOrTemplateTail(node) { | |
| var kind = node.kind; | |
| return kind === 16 | |
| || kind === 17; | |
| } | |
| ts_isTemplateMiddleOrTemplateTail = isTemplateMiddleOrTemplateTail; | |
| function isImportOrExportSpecifier(node) { | |
| return isImportSpecifier(node) || isExportSpecifier(node); | |
| } | |
| ts_isImportOrExportSpecifier = isImportOrExportSpecifier; | |
| function isTypeOnlyImportOrExportDeclaration(node) { | |
| switch (node.kind) { | |
| case 258: | |
| case 263: | |
| return node.parent.parent.isTypeOnly; | |
| case 256: | |
| return node.parent.isTypeOnly; | |
| case 255: | |
| return node.isTypeOnly; | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_isTypeOnlyImportOrExportDeclaration = isTypeOnlyImportOrExportDeclaration; | |
| function isStringTextContainingNode(node) { | |
| return node.kind === 10 || isTemplateLiteralKind(node.kind); | |
| } | |
| ts_isStringTextContainingNode = isStringTextContainingNode; | |
| function isGeneratedIdentifier(node) { | |
| return isIdentifier(node) && (node.autoGenerateFlags & 7) > 0; | |
| } | |
| ts_isGeneratedIdentifier = isGeneratedIdentifier; | |
| function isPrivateIdentifierPropertyDeclaration(node) { | |
| return isPropertyDeclaration(node) && isPrivateIdentifier(node.name); | |
| } | |
| ts_isPrivateIdentifierPropertyDeclaration = isPrivateIdentifierPropertyDeclaration; | |
| function isPrivateIdentifierPropertyAccessExpression(node) { | |
| return isPropertyAccessExpression(node) && isPrivateIdentifier(node.name); | |
| } | |
| ts_isPrivateIdentifierPropertyAccessExpression = isPrivateIdentifierPropertyAccessExpression; | |
| function isModifierKind(token) { | |
| switch (token) { | |
| case 122: | |
| case 126: | |
| case 81: | |
| case 130: | |
| case 84: | |
| case 89: | |
| case 119: | |
| case 117: | |
| case 118: | |
| case 138: | |
| case 120: | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_isModifierKind = isModifierKind; | |
| function isParameterPropertyModifier(kind) { | |
| return !!(ts_modifierToFlag(kind) & 92); | |
| } | |
| ts_isParameterPropertyModifier = isParameterPropertyModifier; | |
| function isClassMemberModifier(idToken) { | |
| return isParameterPropertyModifier(idToken) || idToken === 120; | |
| } | |
| ts_isClassMemberModifier = isClassMemberModifier; | |
| function isModifier(node) { | |
| return isModifierKind(node.kind); | |
| } | |
| ts_isModifier = isModifier; | |
| function isEntityName(node) { | |
| var kind = node.kind; | |
| return kind === 153 | |
| || kind === 75; | |
| } | |
| ts_isEntityName = isEntityName; | |
| function isPropertyName(node) { | |
| var kind = node.kind; | |
| return kind === 75 | |
| || kind === 10 | |
| || kind === 8 | |
| || kind === 154; | |
| } | |
| ts_isPropertyName = isPropertyName; | |
| function isBindingName(node) { | |
| var kind = node.kind; | |
| return kind === 75 | |
| || kind === 189 | |
| || kind === 190; | |
| } | |
| ts_isBindingName = isBindingName; | |
| function isFunctionLike(node) { | |
| return node && isFunctionLikeKind(node.kind); | |
| } | |
| ts_isFunctionLike = isFunctionLike; | |
| function isFunctionLikeDeclaration(node) { | |
| return node && isFunctionLikeDeclarationKind(node.kind); | |
| } | |
| ts_isFunctionLikeDeclaration = isFunctionLikeDeclaration; | |
| function isFunctionLikeDeclarationKind(kind) { | |
| switch (kind) { | |
| case 244: | |
| case 161: | |
| case 162: | |
| case 163: | |
| case 164: | |
| case 201: | |
| case 202: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| function isFunctionLikeKind(kind) { | |
| switch (kind) { | |
| case 160: | |
| case 165: | |
| case 305: | |
| case 166: | |
| case 167: | |
| case 170: | |
| case 300: | |
| case 171: | |
| return true; | |
| default: | |
| return isFunctionLikeDeclarationKind(kind); | |
| } | |
| } | |
| ts_isFunctionLikeKind = isFunctionLikeKind; | |
| function isFunctionOrModuleBlock(node) { | |
| return isSourceFile(node) || isModuleBlock(node) || isBlock(node) && isFunctionLike(node.parent); | |
| } | |
| ts_isFunctionOrModuleBlock = isFunctionOrModuleBlock; | |
| function isClassElement(node) { | |
| var kind = node.kind; | |
| return kind === 162 | |
| || kind === 159 | |
| || kind === 161 | |
| || kind === 163 | |
| || kind === 164 | |
| || kind === 167 | |
| || kind === 222; | |
| } | |
| ts_isClassElement = isClassElement; | |
| function isClassLike(node) { | |
| return node && (node.kind === 245 || node.kind === 214); | |
| } | |
| ts_isClassLike = isClassLike; | |
| function isAccessor(node) { | |
| return node && (node.kind === 163 || node.kind === 164); | |
| } | |
| ts_isAccessor = isAccessor; | |
| function isMethodOrAccessor(node) { | |
| switch (node.kind) { | |
| case 161: | |
| case 163: | |
| case 164: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_isMethodOrAccessor = isMethodOrAccessor; | |
| function isTypeElement(node) { | |
| var kind = node.kind; | |
| return kind === 166 | |
| || kind === 165 | |
| || kind === 158 | |
| || kind === 160 | |
| || kind === 167; | |
| } | |
| ts_isTypeElement = isTypeElement; | |
| function isClassOrTypeElement(node) { | |
| return isTypeElement(node) || isClassElement(node); | |
| } | |
| ts_isClassOrTypeElement = isClassOrTypeElement; | |
| function isObjectLiteralElementLike(node) { | |
| var kind = node.kind; | |
| return kind === 281 | |
| || kind === 282 | |
| || kind === 283 | |
| || kind === 161 | |
| || kind === 163 | |
| || kind === 164; | |
| } | |
| ts_isObjectLiteralElementLike = isObjectLiteralElementLike; | |
| function isTypeNode(node) { | |
| return ts_isTypeNodeKind(node.kind); | |
| } | |
| ts_isTypeNode = isTypeNode; | |
| function isFunctionOrConstructorTypeNode(node) { | |
| switch (node.kind) { | |
| case 170: | |
| case 171: | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_isFunctionOrConstructorTypeNode = isFunctionOrConstructorTypeNode; | |
| function isBindingPattern(node) { | |
| if (node) { | |
| var kind = node.kind; | |
| return kind === 190 | |
| || kind === 189; | |
| } | |
| return false; | |
| } | |
| ts_isBindingPattern = isBindingPattern; | |
| function isAssignmentPattern(node) { | |
| var kind = node.kind; | |
| return kind === 192 | |
| || kind === 193; | |
| } | |
| ts_isAssignmentPattern = isAssignmentPattern; | |
| function isArrayBindingElement(node) { | |
| var kind = node.kind; | |
| return kind === 191 | |
| || kind === 215; | |
| } | |
| ts_isArrayBindingElement = isArrayBindingElement; | |
| function isDeclarationBindingElement(bindingElement) { | |
| switch (bindingElement.kind) { | |
| case 242: | |
| case 156: | |
| case 191: | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_isDeclarationBindingElement = isDeclarationBindingElement; | |
| function isBindingOrAssignmentPattern(node) { | |
| return isObjectBindingOrAssignmentPattern(node) | |
| || isArrayBindingOrAssignmentPattern(node); | |
| } | |
| ts_isBindingOrAssignmentPattern = isBindingOrAssignmentPattern; | |
| function isObjectBindingOrAssignmentPattern(node) { | |
| switch (node.kind) { | |
| case 189: | |
| case 193: | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_isObjectBindingOrAssignmentPattern = isObjectBindingOrAssignmentPattern; | |
| function isArrayBindingOrAssignmentPattern(node) { | |
| switch (node.kind) { | |
| case 190: | |
| case 192: | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_isArrayBindingOrAssignmentPattern = isArrayBindingOrAssignmentPattern; | |
| function isPropertyAccessOrQualifiedNameOrImportTypeNode(node) { | |
| var kind = node.kind; | |
| return kind === 194 | |
| || kind === 153 | |
| || kind === 188; | |
| } | |
| ts_isPropertyAccessOrQualifiedNameOrImportTypeNode = isPropertyAccessOrQualifiedNameOrImportTypeNode; | |
| function isPropertyAccessOrQualifiedName(node) { | |
| var kind = node.kind; | |
| return kind === 194 | |
| || kind === 153; | |
| } | |
| ts_isPropertyAccessOrQualifiedName = isPropertyAccessOrQualifiedName; | |
| function isCallLikeExpression(node) { | |
| switch (node.kind) { | |
| case 268: | |
| case 267: | |
| case 196: | |
| case 197: | |
| case 198: | |
| case 157: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_isCallLikeExpression = isCallLikeExpression; | |
| function isCallOrNewExpression(node) { | |
| return node.kind === 196 || node.kind === 197; | |
| } | |
| ts_isCallOrNewExpression = isCallOrNewExpression; | |
| function isTemplateLiteral(node) { | |
| var kind = node.kind; | |
| return kind === 211 | |
| || kind === 14; | |
| } | |
| ts_isTemplateLiteral = isTemplateLiteral; | |
| function isLeftHandSideExpression(node) { | |
| return isLeftHandSideExpressionKind(skipPartiallyEmittedExpressions(node).kind); | |
| } | |
| ts_isLeftHandSideExpression = isLeftHandSideExpression; | |
| function isLeftHandSideExpressionKind(kind) { | |
| switch (kind) { | |
| case 194: | |
| case 195: | |
| case 197: | |
| case 196: | |
| case 266: | |
| case 267: | |
| case 270: | |
| case 198: | |
| case 192: | |
| case 200: | |
| case 193: | |
| case 214: | |
| case 201: | |
| case 75: | |
| case 13: | |
| case 8: | |
| case 9: | |
| case 10: | |
| case 14: | |
| case 211: | |
| case 91: | |
| case 100: | |
| case 104: | |
| case 106: | |
| case 102: | |
| case 218: | |
| case 219: | |
| case 96: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| function isUnaryExpression(node) { | |
| return isUnaryExpressionKind(skipPartiallyEmittedExpressions(node).kind); | |
| } | |
| ts_isUnaryExpression = isUnaryExpression; | |
| function isUnaryExpressionKind(kind) { | |
| switch (kind) { | |
| case 207: | |
| case 208: | |
| case 203: | |
| case 204: | |
| case 205: | |
| case 206: | |
| case 199: | |
| return true; | |
| default: | |
| return isLeftHandSideExpressionKind(kind); | |
| } | |
| } | |
| function isUnaryExpressionWithWrite(expr) { | |
| switch (expr.kind) { | |
| case 208: | |
| return true; | |
| case 207: | |
| return expr.operator === 45 || | |
| expr.operator === 46; | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_isUnaryExpressionWithWrite = isUnaryExpressionWithWrite; | |
| function isExpression(node) { | |
| return isExpressionKind(skipPartiallyEmittedExpressions(node).kind); | |
| } | |
| ts_isExpression = isExpression; | |
| function isExpressionKind(kind) { | |
| switch (kind) { | |
| case 210: | |
| case 212: | |
| case 202: | |
| case 209: | |
| case 213: | |
| case 217: | |
| case 215: | |
| case 326: | |
| case 325: | |
| return true; | |
| default: | |
| return isUnaryExpressionKind(kind); | |
| } | |
| } | |
| function isAssertionExpression(node) { | |
| var kind = node.kind; | |
| return kind === 199 | |
| || kind === 217; | |
| } | |
| ts_isAssertionExpression = isAssertionExpression; | |
| function isPartiallyEmittedExpression(node) { | |
| return node.kind === 325; | |
| } | |
| ts_isPartiallyEmittedExpression = isPartiallyEmittedExpression; | |
| function isNotEmittedStatement(node) { | |
| return node.kind === 324; | |
| } | |
| ts_isNotEmittedStatement = isNotEmittedStatement; | |
| function isSyntheticReference(node) { | |
| return node.kind === 329; | |
| } | |
| ts_isSyntheticReference = isSyntheticReference; | |
| function isNotEmittedOrPartiallyEmittedNode(node) { | |
| return isNotEmittedStatement(node) | |
| || isPartiallyEmittedExpression(node); | |
| } | |
| ts_isNotEmittedOrPartiallyEmittedNode = isNotEmittedOrPartiallyEmittedNode; | |
| function isIterationStatement(node, lookInLabeledStatements) { | |
| switch (node.kind) { | |
| case 230: | |
| case 231: | |
| case 232: | |
| case 228: | |
| case 229: | |
| return true; | |
| case 238: | |
| return lookInLabeledStatements && isIterationStatement(node.statement, lookInLabeledStatements); | |
| } | |
| return false; | |
| } | |
| ts_isIterationStatement = isIterationStatement; | |
| function isScopeMarker(node) { | |
| return isExportAssignment(node) || isExportDeclaration(node); | |
| } | |
| ts_isScopeMarker = isScopeMarker; | |
| function hasScopeMarker(statements) { | |
| return ts_some(statements, isScopeMarker); | |
| } | |
| ts_hasScopeMarker = hasScopeMarker; | |
| function needsScopeMarker(result) { | |
| return !ts_isAnyImportOrReExport(result) && !isExportAssignment(result) && !ts_hasModifier(result, 1) && !ts_isAmbientModule(result); | |
| } | |
| ts_needsScopeMarker = needsScopeMarker; | |
| function isExternalModuleIndicator(result) { | |
| return ts_isAnyImportOrReExport(result) || isExportAssignment(result) || ts_hasModifier(result, 1); | |
| } | |
| ts_isExternalModuleIndicator = isExternalModuleIndicator; | |
| function isForInOrOfStatement(node) { | |
| return node.kind === 231 || node.kind === 232; | |
| } | |
| ts_isForInOrOfStatement = isForInOrOfStatement; | |
| function isConciseBody(node) { | |
| return isBlock(node) | |
| || isExpression(node); | |
| } | |
| ts_isConciseBody = isConciseBody; | |
| function isFunctionBody(node) { | |
| return isBlock(node); | |
| } | |
| ts_isFunctionBody = isFunctionBody; | |
| function isForInitializer(node) { | |
| return isVariableDeclarationList(node) | |
| || isExpression(node); | |
| } | |
| ts_isForInitializer = isForInitializer; | |
| function isModuleBody(node) { | |
| var kind = node.kind; | |
| return kind === 250 | |
| || kind === 249 | |
| || kind === 75; | |
| } | |
| ts_isModuleBody = isModuleBody; | |
| function isNamespaceBody(node) { | |
| var kind = node.kind; | |
| return kind === 250 | |
| || kind === 249; | |
| } | |
| ts_isNamespaceBody = isNamespaceBody; | |
| function isJSDocNamespaceBody(node) { | |
| var kind = node.kind; | |
| return kind === 75 | |
| || kind === 249; | |
| } | |
| ts_isJSDocNamespaceBody = isJSDocNamespaceBody; | |
| function isNamedImportBindings(node) { | |
| var kind = node.kind; | |
| return kind === 257 | |
| || kind === 256; | |
| } | |
| ts_isNamedImportBindings = isNamedImportBindings; | |
| function isModuleOrEnumDeclaration(node) { | |
| return node.kind === 249 || node.kind === 248; | |
| } | |
| ts_isModuleOrEnumDeclaration = isModuleOrEnumDeclaration; | |
| function isDeclarationKind(kind) { | |
| return kind === 202 | |
| || kind === 191 | |
| || kind === 245 | |
| || kind === 214 | |
| || kind === 162 | |
| || kind === 248 | |
| || kind === 284 | |
| || kind === 263 | |
| || kind === 244 | |
| || kind === 201 | |
| || kind === 163 | |
| || kind === 255 | |
| || kind === 253 | |
| || kind === 258 | |
| || kind === 246 | |
| || kind === 273 | |
| || kind === 161 | |
| || kind === 160 | |
| || kind === 249 | |
| || kind === 252 | |
| || kind === 256 | |
| || kind === 262 | |
| || kind === 156 | |
| || kind === 281 | |
| || kind === 159 | |
| || kind === 158 | |
| || kind === 164 | |
| || kind === 282 | |
| || kind === 247 | |
| || kind === 155 | |
| || kind === 242 | |
| || kind === 321 | |
| || kind === 314 | |
| || kind === 322; | |
| } | |
| function isDeclarationStatementKind(kind) { | |
| return kind === 244 | |
| || kind === 264 | |
| || kind === 245 | |
| || kind === 246 | |
| || kind === 247 | |
| || kind === 248 | |
| || kind === 249 | |
| || kind === 254 | |
| || kind === 253 | |
| || kind === 260 | |
| || kind === 259 | |
| || kind === 252; | |
| } | |
| function isStatementKindButNotDeclarationKind(kind) { | |
| return kind === 234 | |
| || kind === 233 | |
| || kind === 241 | |
| || kind === 228 | |
| || kind === 226 | |
| || kind === 224 | |
| || kind === 231 | |
| || kind === 232 | |
| || kind === 230 | |
| || kind === 227 | |
| || kind === 238 | |
| || kind === 235 | |
| || kind === 237 | |
| || kind === 239 | |
| || kind === 240 | |
| || kind === 225 | |
| || kind === 229 | |
| || kind === 236 | |
| || kind === 324 | |
| || kind === 328 | |
| || kind === 327; | |
| } | |
| function isDeclaration(node) { | |
| if (node.kind === 155) { | |
| return (node.parent && node.parent.kind !== 320) || ts_isInJSFile(node); | |
| } | |
| return isDeclarationKind(node.kind); | |
| } | |
| ts_isDeclaration = isDeclaration; | |
| function isDeclarationStatement(node) { | |
| return isDeclarationStatementKind(node.kind); | |
| } | |
| ts_isDeclarationStatement = isDeclarationStatement; | |
| function isStatementButNotDeclaration(node) { | |
| return isStatementKindButNotDeclarationKind(node.kind); | |
| } | |
| ts_isStatementButNotDeclaration = isStatementButNotDeclaration; | |
| function isStatement(node) { | |
| var kind = node.kind; | |
| return isStatementKindButNotDeclarationKind(kind) | |
| || isDeclarationStatementKind(kind) | |
| || isBlockStatement(node); | |
| } | |
| ts_isStatement = isStatement; | |
| function isBlockStatement(node) { | |
| if (node.kind !== 223) | |
| return false; | |
| if (node.parent !== undefined) { | |
| if (node.parent.kind === 240 || node.parent.kind === 280) { | |
| return false; | |
| } | |
| } | |
| return !ts_isFunctionBlock(node); | |
| } | |
| function isModuleReference(node) { | |
| var kind = node.kind; | |
| return kind === 265 | |
| || kind === 153 | |
| || kind === 75; | |
| } | |
| ts_isModuleReference = isModuleReference; | |
| function isJsxTagNameExpression(node) { | |
| var kind = node.kind; | |
| return kind === 104 | |
| || kind === 75 | |
| || kind === 194; | |
| } | |
| ts_isJsxTagNameExpression = isJsxTagNameExpression; | |
| function isJsxChild(node) { | |
| var kind = node.kind; | |
| return kind === 266 | |
| || kind === 276 | |
| || kind === 267 | |
| || kind === 11 | |
| || kind === 270; | |
| } | |
| ts_isJsxChild = isJsxChild; | |
| function isJsxAttributeLike(node) { | |
| var kind = node.kind; | |
| return kind === 273 | |
| || kind === 275; | |
| } | |
| ts_isJsxAttributeLike = isJsxAttributeLike; | |
| function isStringLiteralOrJsxExpression(node) { | |
| var kind = node.kind; | |
| return kind === 10 | |
| || kind === 276; | |
| } | |
| ts_isStringLiteralOrJsxExpression = isStringLiteralOrJsxExpression; | |
| function isJsxOpeningLikeElement(node) { | |
| var kind = node.kind; | |
| return kind === 268 | |
| || kind === 267; | |
| } | |
| ts_isJsxOpeningLikeElement = isJsxOpeningLikeElement; | |
| function isCaseOrDefaultClause(node) { | |
| var kind = node.kind; | |
| return kind === 277 | |
| || kind === 278; | |
| } | |
| ts_isCaseOrDefaultClause = isCaseOrDefaultClause; | |
| function isJSDocNode(node) { | |
| return node.kind >= 294 && node.kind <= 322; | |
| } | |
| ts_isJSDocNode = isJSDocNode; | |
| function isJSDocCommentContainingNode(node) { | |
| return node.kind === 303 || isJSDocTag(node) || isJSDocTypeLiteral(node) || isJSDocSignature(node); | |
| } | |
| ts_isJSDocCommentContainingNode = isJSDocCommentContainingNode; | |
| function isJSDocTag(node) { | |
| return node.kind >= 306 && node.kind <= 322; | |
| } | |
| ts_isJSDocTag = isJSDocTag; | |
| function isSetAccessor(node) { | |
| return node.kind === 164; | |
| } | |
| ts_isSetAccessor = isSetAccessor; | |
| function isGetAccessor(node) { | |
| return node.kind === 163; | |
| } | |
| ts_isGetAccessor = isGetAccessor; | |
| function hasJSDocNodes(node) { | |
| var jsDoc = node.jsDoc; | |
| return !!jsDoc && jsDoc.length > 0; | |
| } | |
| ts_hasJSDocNodes = hasJSDocNodes; | |
| function hasType(node) { | |
| return !!node.type; | |
| } | |
| ts_hasType = hasType; | |
| function hasInitializer(node) { | |
| return !!node.initializer; | |
| } | |
| ts_hasInitializer = hasInitializer; | |
| function hasOnlyExpressionInitializer(node) { | |
| return hasInitializer(node) && !isForStatement(node) && !isForInStatement(node) && !isForOfStatement(node) && !isJsxAttribute(node); | |
| } | |
| ts_hasOnlyExpressionInitializer = hasOnlyExpressionInitializer; | |
| function isObjectLiteralElement(node) { | |
| return node.kind === 273 || node.kind === 275 || isObjectLiteralElementLike(node); | |
| } | |
| ts_isObjectLiteralElement = isObjectLiteralElement; | |
| function isTypeReferenceType(node) { | |
| return node.kind === 169 || node.kind === 216; | |
| } | |
| ts_isTypeReferenceType = isTypeReferenceType; | |
| var MAX_SMI_X86 = 1073741823; | |
| function guessIndentation(lines) { | |
| var indentation = MAX_SMI_X86; | |
| for (var _i = 0, lines_1 = lines; _i < lines_1.length; _i++) { | |
| var line = lines_1[_i]; | |
| if (!line.length) { | |
| continue; | |
| } | |
| var i = 0; | |
| for (; i < line.length && i < indentation; i++) { | |
| if (!ts_isWhiteSpaceLike(line.charCodeAt(i))) { | |
| break; | |
| } | |
| } | |
| if (i < indentation) { | |
| indentation = i; | |
| } | |
| if (indentation === 0) { | |
| return 0; | |
| } | |
| } | |
| return indentation === MAX_SMI_X86 ? undefined : indentation; | |
| } | |
| ts_guessIndentation = guessIndentation; | |
| function isStringLiteralLike(node) { | |
| return node.kind === 10 || node.kind === 14; | |
| } | |
| ts_isStringLiteralLike = isStringLiteralLike; | |
| })(ts || (ts = {})); | |
| var ts; | |
| (function (ts) { | |
| ts_resolvingEmptyArray = []; | |
| ts_emptyMap = ts_createMap(); | |
| ts_emptyUnderscoreEscapedMap = ts_emptyMap; | |
| ts_externalHelpersModuleNameText = "tslib"; | |
| ts_defaultMaximumTruncationLength = 160; | |
| function getDeclarationOfKind(symbol, kind) { | |
| var declarations = symbol.declarations; | |
| if (declarations) { | |
| for (var _i = 0, declarations_1 = declarations; _i < declarations_1.length; _i++) { | |
| var declaration = declarations_1[_i]; | |
| if (declaration.kind === kind) { | |
| return declaration; | |
| } | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_getDeclarationOfKind = getDeclarationOfKind; | |
| function createUnderscoreEscapedMap() { | |
| return new ts_Map(); | |
| } | |
| ts_createUnderscoreEscapedMap = createUnderscoreEscapedMap; | |
| function hasEntries(map) { | |
| return !!map && !!map.size; | |
| } | |
| ts_hasEntries = hasEntries; | |
| function createSymbolTable(symbols) { | |
| var result = ts_createMap(); | |
| if (symbols) { | |
| for (var _i = 0, symbols_1 = symbols; _i < symbols_1.length; _i++) { | |
| var symbol = symbols_1[_i]; | |
| result.set(symbol.escapedName, symbol); | |
| } | |
| } | |
| return result; | |
| } | |
| ts_createSymbolTable = createSymbolTable; | |
| function isTransientSymbol(symbol) { | |
| return (symbol.flags & 33554432) !== 0; | |
| } | |
| ts_isTransientSymbol = isTransientSymbol; | |
| var stringWriter = createSingleLineStringWriter(); | |
| function createSingleLineStringWriter() { | |
| var str = ""; | |
| var writeText = function (text) { return str += text; }; | |
| return { | |
| getText: function () { return str; }, | |
| write: writeText, | |
| rawWrite: writeText, | |
| writeKeyword: writeText, | |
| writeOperator: writeText, | |
| writePunctuation: writeText, | |
| writeSpace: writeText, | |
| writeStringLiteral: writeText, | |
| writeLiteral: writeText, | |
| writeParameter: writeText, | |
| writeProperty: writeText, | |
| writeSymbol: function (s, _) { return writeText(s); }, | |
| writeTrailingSemicolon: writeText, | |
| writeComment: writeText, | |
| getTextPos: function () { return str.length; }, | |
| getLine: function () { return 0; }, | |
| getColumn: function () { return 0; }, | |
| getIndent: function () { return 0; }, | |
| isAtStartOfLine: function () { return false; }, | |
| hasTrailingComment: function () { return false; }, | |
| hasTrailingWhitespace: function () { return !!str.length && ts_isWhiteSpaceLike(str.charCodeAt(str.length - 1)); }, | |
| writeLine: function () { return str += " "; }, | |
| increaseIndent: ts_noop, | |
| decreaseIndent: ts_noop, | |
| clear: function () { return str = ""; }, | |
| trackSymbol: ts_noop, | |
| reportInaccessibleThisError: ts_noop, | |
| reportInaccessibleUniqueSymbolError: ts_noop, | |
| reportPrivateInBaseOfClassExpression: ts_noop, | |
| }; | |
| } | |
| function changesAffectModuleResolution(oldOptions, newOptions) { | |
| return oldOptions.configFilePath !== newOptions.configFilePath || | |
| optionsHaveModuleResolutionChanges(oldOptions, newOptions); | |
| } | |
| ts_changesAffectModuleResolution = changesAffectModuleResolution; | |
| function optionsHaveModuleResolutionChanges(oldOptions, newOptions) { | |
| return ts_moduleResolutionOptionDeclarations.some(function (o) { | |
| return !isJsonEqual(getCompilerOptionValue(oldOptions, o), getCompilerOptionValue(newOptions, o)); | |
| }); | |
| } | |
| ts_optionsHaveModuleResolutionChanges = optionsHaveModuleResolutionChanges; | |
| function findAncestor(node, callback) { | |
| while (node) { | |
| var result = callback(node); | |
| if (result === "quit") { | |
| return undefined; | |
| } | |
| else if (result) { | |
| return node; | |
| } | |
| node = node.parent; | |
| } | |
| return undefined; | |
| } | |
| ts_findAncestor = findAncestor; | |
| function forEachAncestor(node, callback) { | |
| while (true) { | |
| var res = callback(node); | |
| if (res === "quit") | |
| return undefined; | |
| if (res !== undefined) | |
| return res; | |
| if (ts_isSourceFile(node)) | |
| return undefined; | |
| node = node.parent; | |
| } | |
| } | |
| ts_forEachAncestor = forEachAncestor; | |
| function forEachEntry(map, callback) { | |
| var iterator = map.entries(); | |
| for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { | |
| var _a = iterResult.value, key = _a[0], value = _a[1]; | |
| var result = callback(value, key); | |
| if (result) { | |
| return result; | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_forEachEntry = forEachEntry; | |
| function forEachKey(map, callback) { | |
| var iterator = map.keys(); | |
| for (var iterResult = iterator.next(); !iterResult.done; iterResult = iterator.next()) { | |
| var result = callback(iterResult.value); | |
| if (result) { | |
| return result; | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_forEachKey = forEachKey; | |
| function copyEntries(source, target) { | |
| source.forEach(function (value, key) { | |
| target.set(key, value); | |
| }); | |
| } | |
| ts_copyEntries = copyEntries; | |
| function arrayToSet(array, makeKey) { | |
| return ts_arrayToMap(array, makeKey || (function (s) { return s; }), ts_returnTrue); | |
| } | |
| ts_arrayToSet = arrayToSet; | |
| function cloneMap(map) { | |
| var clone = ts_createMap(); | |
| copyEntries(map, clone); | |
| return clone; | |
| } | |
| ts_cloneMap = cloneMap; | |
| function usingSingleLineStringWriter(action) { | |
| var oldString = stringWriter.getText(); | |
| try { | |
| action(stringWriter); | |
| return stringWriter.getText(); | |
| } | |
| finally { | |
| stringWriter.clear(); | |
| stringWriter.writeKeyword(oldString); | |
| } | |
| } | |
| ts_usingSingleLineStringWriter = usingSingleLineStringWriter; | |
| function getFullWidth(node) { | |
| return node.end - node.pos; | |
| } | |
| ts_getFullWidth = getFullWidth; | |
| function getResolvedModule(sourceFile, moduleNameText) { | |
| return sourceFile && sourceFile.resolvedModules && sourceFile.resolvedModules.get(moduleNameText); | |
| } | |
| ts_getResolvedModule = getResolvedModule; | |
| function setResolvedModule(sourceFile, moduleNameText, resolvedModule) { | |
| if (!sourceFile.resolvedModules) { | |
| sourceFile.resolvedModules = ts_createMap(); | |
| } | |
| sourceFile.resolvedModules.set(moduleNameText, resolvedModule); | |
| } | |
| ts_setResolvedModule = setResolvedModule; | |
| function setResolvedTypeReferenceDirective(sourceFile, typeReferenceDirectiveName, resolvedTypeReferenceDirective) { | |
| if (!sourceFile.resolvedTypeReferenceDirectiveNames) { | |
| sourceFile.resolvedTypeReferenceDirectiveNames = ts_createMap(); | |
| } | |
| sourceFile.resolvedTypeReferenceDirectiveNames.set(typeReferenceDirectiveName, resolvedTypeReferenceDirective); | |
| } | |
| ts_setResolvedTypeReferenceDirective = setResolvedTypeReferenceDirective; | |
| function projectReferenceIsEqualTo(oldRef, newRef) { | |
| return oldRef.path === newRef.path && | |
| !oldRef.prepend === !newRef.prepend && | |
| !oldRef.circular === !newRef.circular; | |
| } | |
| ts_projectReferenceIsEqualTo = projectReferenceIsEqualTo; | |
| function moduleResolutionIsEqualTo(oldResolution, newResolution) { | |
| return oldResolution.isExternalLibraryImport === newResolution.isExternalLibraryImport && | |
| oldResolution.extension === newResolution.extension && | |
| oldResolution.resolvedFileName === newResolution.resolvedFileName && | |
| oldResolution.originalPath === newResolution.originalPath && | |
| packageIdIsEqual(oldResolution.packageId, newResolution.packageId); | |
| } | |
| ts_moduleResolutionIsEqualTo = moduleResolutionIsEqualTo; | |
| function packageIdIsEqual(a, b) { | |
| return a === b || !!a && !!b && a.name === b.name && a.subModuleName === b.subModuleName && a.version === b.version; | |
| } | |
| function packageIdToString(_a) { | |
| var name = _a.name, subModuleName = _a.subModuleName, version = _a.version; | |
| var fullName = subModuleName ? name + "/" + subModuleName : name; | |
| return fullName + "@" + version; | |
| } | |
| ts_packageIdToString = packageIdToString; | |
| function typeDirectiveIsEqualTo(oldResolution, newResolution) { | |
| return oldResolution.resolvedFileName === newResolution.resolvedFileName && oldResolution.primary === newResolution.primary; | |
| } | |
| ts_typeDirectiveIsEqualTo = typeDirectiveIsEqualTo; | |
| function hasChangesInResolutions(names, newResolutions, oldResolutions, comparer) { | |
| ts_Debug.assert(names.length === newResolutions.length); | |
| for (var i = 0; i < names.length; i++) { | |
| var newResolution = newResolutions[i]; | |
| var oldResolution = oldResolutions && oldResolutions.get(names[i]); | |
| var changed = oldResolution | |
| ? !newResolution || !comparer(oldResolution, newResolution) | |
| : newResolution; | |
| if (changed) { | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| ts_hasChangesInResolutions = hasChangesInResolutions; | |
| function containsParseError(node) { | |
| aggregateChildData(node); | |
| return (node.flags & 262144) !== 0; | |
| } | |
| ts_containsParseError = containsParseError; | |
| function aggregateChildData(node) { | |
| if (!(node.flags & 524288)) { | |
| var thisNodeOrAnySubNodesHasError = ((node.flags & 65536) !== 0) || | |
| ts_forEachChild(node, containsParseError); | |
| if (thisNodeOrAnySubNodesHasError) { | |
| node.flags |= 262144; | |
| } | |
| node.flags |= 524288; | |
| } | |
| } | |
| function getSourceFileOfNode(node) { | |
| while (node && node.kind !== 290) { | |
| node = node.parent; | |
| } | |
| return node; | |
| } | |
| ts_getSourceFileOfNode = getSourceFileOfNode; | |
| function isStatementWithLocals(node) { | |
| switch (node.kind) { | |
| case 223: | |
| case 251: | |
| case 230: | |
| case 231: | |
| case 232: | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_isStatementWithLocals = isStatementWithLocals; | |
| function getStartPositionOfLine(line, sourceFile) { | |
| ts_Debug.assert(line >= 0); | |
| return ts_getLineStarts(sourceFile)[line]; | |
| } | |
| ts_getStartPositionOfLine = getStartPositionOfLine; | |
| function nodePosToString(node) { | |
| var file = getSourceFileOfNode(node); | |
| var loc = ts_getLineAndCharacterOfPosition(file, node.pos); | |
| return file.fileName + "(" + (loc.line + 1) + "," + (loc.character + 1) + ")"; | |
| } | |
| ts_nodePosToString = nodePosToString; | |
| function getEndLinePosition(line, sourceFile) { | |
| ts_Debug.assert(line >= 0); | |
| var lineStarts = ts_getLineStarts(sourceFile); | |
| var lineIndex = line; | |
| var sourceText = sourceFile.text; | |
| if (lineIndex + 1 === lineStarts.length) { | |
| return sourceText.length - 1; | |
| } | |
| else { | |
| var start = lineStarts[lineIndex]; | |
| var pos = lineStarts[lineIndex + 1] - 1; | |
| ts_Debug.assert(ts_isLineBreak(sourceText.charCodeAt(pos))); | |
| while (start <= pos && ts_isLineBreak(sourceText.charCodeAt(pos))) { | |
| pos--; | |
| } | |
| return pos; | |
| } | |
| } | |
| ts_getEndLinePosition = getEndLinePosition; | |
| function isFileLevelUniqueName(sourceFile, name, hasGlobalName) { | |
| return !(hasGlobalName && hasGlobalName(name)) && !sourceFile.identifiers.has(name); | |
| } | |
| ts_isFileLevelUniqueName = isFileLevelUniqueName; | |
| function nodeIsMissing(node) { | |
| if (node === undefined) { | |
| return true; | |
| } | |
| return node.pos === node.end && node.pos >= 0 && node.kind !== 1; | |
| } | |
| ts_nodeIsMissing = nodeIsMissing; | |
| function nodeIsPresent(node) { | |
| return !nodeIsMissing(node); | |
| } | |
| ts_nodeIsPresent = nodeIsPresent; | |
| function insertStatementsAfterPrologue(to, from, isPrologueDirective) { | |
| if (from === undefined || from.length === 0) | |
| return to; | |
| var statementIndex = 0; | |
| for (; statementIndex < to.length; ++statementIndex) { | |
| if (!isPrologueDirective(to[statementIndex])) { | |
| break; | |
| } | |
| } | |
| to.splice.apply(to, __spreadArrays([statementIndex, 0], from)); | |
| return to; | |
| } | |
| function insertStatementAfterPrologue(to, statement, isPrologueDirective) { | |
| if (statement === undefined) | |
| return to; | |
| var statementIndex = 0; | |
| for (; statementIndex < to.length; ++statementIndex) { | |
| if (!isPrologueDirective(to[statementIndex])) { | |
| break; | |
| } | |
| } | |
| to.splice(statementIndex, 0, statement); | |
| return to; | |
| } | |
| function isAnyPrologueDirective(node) { | |
| return isPrologueDirective(node) || !!(getEmitFlags(node) & 1048576); | |
| } | |
| function insertStatementsAfterStandardPrologue(to, from) { | |
| return insertStatementsAfterPrologue(to, from, isPrologueDirective); | |
| } | |
| ts_insertStatementsAfterStandardPrologue = insertStatementsAfterStandardPrologue; | |
| function insertStatementsAfterCustomPrologue(to, from) { | |
| return insertStatementsAfterPrologue(to, from, isAnyPrologueDirective); | |
| } | |
| ts_insertStatementsAfterCustomPrologue = insertStatementsAfterCustomPrologue; | |
| function insertStatementAfterStandardPrologue(to, statement) { | |
| return insertStatementAfterPrologue(to, statement, isPrologueDirective); | |
| } | |
| ts_insertStatementAfterStandardPrologue = insertStatementAfterStandardPrologue; | |
| function insertStatementAfterCustomPrologue(to, statement) { | |
| return insertStatementAfterPrologue(to, statement, isAnyPrologueDirective); | |
| } | |
| ts_insertStatementAfterCustomPrologue = insertStatementAfterCustomPrologue; | |
| function isRecognizedTripleSlashComment(text, commentPos, commentEnd) { | |
| if (text.charCodeAt(commentPos + 1) === 47 && | |
| commentPos + 2 < commentEnd && | |
| text.charCodeAt(commentPos + 2) === 47) { | |
| var textSubStr = text.substring(commentPos, commentEnd); | |
| return textSubStr.match(ts_fullTripleSlashReferencePathRegEx) || | |
| textSubStr.match(ts_fullTripleSlashAMDReferencePathRegEx) || | |
| textSubStr.match(fullTripleSlashReferenceTypeReferenceDirectiveRegEx) || | |
| textSubStr.match(defaultLibReferenceRegEx) ? | |
| true : false; | |
| } | |
| return false; | |
| } | |
| ts_isRecognizedTripleSlashComment = isRecognizedTripleSlashComment; | |
| function isPinnedComment(text, start) { | |
| return text.charCodeAt(start + 1) === 42 && | |
| text.charCodeAt(start + 2) === 33; | |
| } | |
| ts_isPinnedComment = isPinnedComment; | |
| function getTokenPosOfNode(node, sourceFile, includeJsDoc) { | |
| if (nodeIsMissing(node)) { | |
| return node.pos; | |
| } | |
| if (ts_isJSDocNode(node)) { | |
| return ts_skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos, false, true); | |
| } | |
| if (includeJsDoc && ts_hasJSDocNodes(node)) { | |
| return getTokenPosOfNode(node.jsDoc[0]); | |
| } | |
| if (node.kind === 323 && node._children.length > 0) { | |
| return getTokenPosOfNode(node._children[0], sourceFile, includeJsDoc); | |
| } | |
| return ts_skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos); | |
| } | |
| ts_getTokenPosOfNode = getTokenPosOfNode; | |
| function getNonDecoratorTokenPosOfNode(node, sourceFile) { | |
| if (nodeIsMissing(node) || !node.decorators) { | |
| return getTokenPosOfNode(node, sourceFile); | |
| } | |
| return ts_skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.decorators.end); | |
| } | |
| ts_getNonDecoratorTokenPosOfNode = getNonDecoratorTokenPosOfNode; | |
| function getSourceTextOfNodeFromSourceFile(sourceFile, node, includeTrivia) { | |
| if (includeTrivia === void 0) { includeTrivia = false; } | |
| return getTextOfNodeFromSourceText(sourceFile.text, node, includeTrivia); | |
| } | |
| ts_getSourceTextOfNodeFromSourceFile = getSourceTextOfNodeFromSourceFile; | |
| function isJSDocTypeExpressionOrChild(node) { | |
| return !!findAncestor(node, ts_isJSDocTypeExpression); | |
| } | |
| function getTextOfNodeFromSourceText(sourceText, node, includeTrivia) { | |
| if (includeTrivia === void 0) { includeTrivia = false; } | |
| if (nodeIsMissing(node)) { | |
| return ""; | |
| } | |
| var text = sourceText.substring(includeTrivia ? node.pos : ts_skipTrivia(sourceText, node.pos), node.end); | |
| if (isJSDocTypeExpressionOrChild(node)) { | |
| text = text.replace(/(^|\r?\n|\r)\s*\*\s*/g, "$1"); | |
| } | |
| return text; | |
| } | |
| ts_getTextOfNodeFromSourceText = getTextOfNodeFromSourceText; | |
| function getTextOfNode(node, includeTrivia) { | |
| if (includeTrivia === void 0) { includeTrivia = false; } | |
| return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia); | |
| } | |
| ts_getTextOfNode = getTextOfNode; | |
| function getPos(range) { | |
| return range.pos; | |
| } | |
| function indexOfNode(nodeArray, node) { | |
| return ts_binarySearch(nodeArray, node, getPos, ts_compareValues); | |
| } | |
| ts_indexOfNode = indexOfNode; | |
| function getEmitFlags(node) { | |
| var emitNode = node.emitNode; | |
| return emitNode && emitNode.flags || 0; | |
| } | |
| ts_getEmitFlags = getEmitFlags; | |
| function getLiteralText(node, sourceFile, neverAsciiEscape, jsxAttributeEscape) { | |
| if (!nodeIsSynthesized(node) && node.parent && !((ts_isNumericLiteral(node) && node.numericLiteralFlags & 512) || | |
| ts_isBigIntLiteral(node))) { | |
| return getSourceTextOfNodeFromSourceFile(sourceFile, node); | |
| } | |
| switch (node.kind) { | |
| case 10: { | |
| var escapeText = jsxAttributeEscape ? escapeJsxAttributeString : | |
| neverAsciiEscape || (getEmitFlags(node) & 16777216) ? escapeString : | |
| escapeNonAsciiString; | |
| if (node.singleQuote) { | |
| return "'" + escapeText(node.text, 39) + "'"; | |
| } | |
| else { | |
| return '"' + escapeText(node.text, 34) + '"'; | |
| } | |
| } | |
| case 14: | |
| case 15: | |
| case 16: | |
| case 17: { | |
| var escapeText = neverAsciiEscape || (getEmitFlags(node) & 16777216) ? escapeString : | |
| escapeNonAsciiString; | |
| var rawText = node.rawText || escapeTemplateSubstitution(escapeText(node.text, 96)); | |
| switch (node.kind) { | |
| case 14: | |
| return "`" + rawText + "`"; | |
| case 15: | |
| return "`" + rawText + "${"; | |
| case 16: | |
| return "}" + rawText + "${"; | |
| case 17: | |
| return "}" + rawText + "`"; | |
| } | |
| break; | |
| } | |
| case 8: | |
| case 9: | |
| case 13: | |
| return node.text; | |
| } | |
| return ts_Debug.fail("Literal kind '" + node.kind + "' not accounted for."); | |
| } | |
| ts_getLiteralText = getLiteralText; | |
| function getTextOfConstantValue(value) { | |
| return ts_isString(value) ? '"' + escapeNonAsciiString(value) + '"' : "" + value; | |
| } | |
| ts_getTextOfConstantValue = getTextOfConstantValue; | |
| function makeIdentifierFromModuleName(moduleName) { | |
| return ts_getBaseFileName(moduleName).replace(/^(\d)/, "_$1").replace(/\W/g, "_"); | |
| } | |
| ts_makeIdentifierFromModuleName = makeIdentifierFromModuleName; | |
| function isBlockOrCatchScoped(declaration) { | |
| return (ts_getCombinedNodeFlags(declaration) & 3) !== 0 || | |
| isCatchClauseVariableDeclarationOrBindingElement(declaration); | |
| } | |
| ts_isBlockOrCatchScoped = isBlockOrCatchScoped; | |
| function isCatchClauseVariableDeclarationOrBindingElement(declaration) { | |
| var node = getRootDeclaration(declaration); | |
| return node.kind === 242 && node.parent.kind === 280; | |
| } | |
| ts_isCatchClauseVariableDeclarationOrBindingElement = isCatchClauseVariableDeclarationOrBindingElement; | |
| function isAmbientModule(node) { | |
| return ts_isModuleDeclaration(node) && (node.name.kind === 10 || isGlobalScopeAugmentation(node)); | |
| } | |
| ts_isAmbientModule = isAmbientModule; | |
| function isModuleWithStringLiteralName(node) { | |
| return ts_isModuleDeclaration(node) && node.name.kind === 10; | |
| } | |
| ts_isModuleWithStringLiteralName = isModuleWithStringLiteralName; | |
| function isNonGlobalAmbientModule(node) { | |
| return ts_isModuleDeclaration(node) && ts_isStringLiteral(node.name); | |
| } | |
| ts_isNonGlobalAmbientModule = isNonGlobalAmbientModule; | |
| function isEffectiveModuleDeclaration(node) { | |
| return ts_isModuleDeclaration(node) || ts_isIdentifier(node); | |
| } | |
| ts_isEffectiveModuleDeclaration = isEffectiveModuleDeclaration; | |
| function isShorthandAmbientModuleSymbol(moduleSymbol) { | |
| return isShorthandAmbientModule(moduleSymbol.valueDeclaration); | |
| } | |
| ts_isShorthandAmbientModuleSymbol = isShorthandAmbientModuleSymbol; | |
| function isShorthandAmbientModule(node) { | |
| return node && node.kind === 249 && (!node.body); | |
| } | |
| function isBlockScopedContainerTopLevel(node) { | |
| return node.kind === 290 || | |
| node.kind === 249 || | |
| ts_isFunctionLike(node); | |
| } | |
| ts_isBlockScopedContainerTopLevel = isBlockScopedContainerTopLevel; | |
| function isGlobalScopeAugmentation(module) { | |
| return !!(module.flags & 1024); | |
| } | |
| ts_isGlobalScopeAugmentation = isGlobalScopeAugmentation; | |
| function isExternalModuleAugmentation(node) { | |
| return isAmbientModule(node) && isModuleAugmentationExternal(node); | |
| } | |
| ts_isExternalModuleAugmentation = isExternalModuleAugmentation; | |
| function isModuleAugmentationExternal(node) { | |
| switch (node.parent.kind) { | |
| case 290: | |
| return ts_isExternalModule(node.parent); | |
| case 250: | |
| return isAmbientModule(node.parent.parent) && ts_isSourceFile(node.parent.parent.parent) && !ts_isExternalModule(node.parent.parent.parent); | |
| } | |
| return false; | |
| } | |
| ts_isModuleAugmentationExternal = isModuleAugmentationExternal; | |
| function getNonAugmentationDeclaration(symbol) { | |
| return ts_find(symbol.declarations, function (d) { return !isExternalModuleAugmentation(d) && !(ts_isModuleDeclaration(d) && isGlobalScopeAugmentation(d)); }); | |
| } | |
| ts_getNonAugmentationDeclaration = getNonAugmentationDeclaration; | |
| function isEffectiveExternalModule(node, compilerOptions) { | |
| return ts_isExternalModule(node) || compilerOptions.isolatedModules || ((getEmitModuleKind(compilerOptions) === ts_ModuleKind.CommonJS) && !!node.commonJsModuleIndicator); | |
| } | |
| ts_isEffectiveExternalModule = isEffectiveExternalModule; | |
| function isEffectiveStrictModeSourceFile(node, compilerOptions) { | |
| switch (node.scriptKind) { | |
| case 1: | |
| case 3: | |
| case 2: | |
| case 4: | |
| break; | |
| default: | |
| return false; | |
| } | |
| if (node.isDeclarationFile) { | |
| return false; | |
| } | |
| if (getStrictOptionValue(compilerOptions, "alwaysStrict")) { | |
| return true; | |
| } | |
| if (ts_startsWithUseStrict(node.statements)) { | |
| return true; | |
| } | |
| if (ts_isExternalModule(node) || compilerOptions.isolatedModules) { | |
| if (getEmitModuleKind(compilerOptions) >= ts_ModuleKind.ES2015) { | |
| return true; | |
| } | |
| return !compilerOptions.noImplicitUseStrict; | |
| } | |
| return false; | |
| } | |
| ts_isEffectiveStrictModeSourceFile = isEffectiveStrictModeSourceFile; | |
| function isBlockScope(node, parentNode) { | |
| switch (node.kind) { | |
| case 290: | |
| case 251: | |
| case 280: | |
| case 249: | |
| case 230: | |
| case 231: | |
| case 232: | |
| case 162: | |
| case 161: | |
| case 163: | |
| case 164: | |
| case 244: | |
| case 201: | |
| case 202: | |
| return true; | |
| case 223: | |
| return !ts_isFunctionLike(parentNode); | |
| } | |
| return false; | |
| } | |
| ts_isBlockScope = isBlockScope; | |
| function isDeclarationWithTypeParameters(node) { | |
| switch (node.kind) { | |
| case 314: | |
| case 321: | |
| case 305: | |
| return true; | |
| default: | |
| ts_assertType(node); | |
| return isDeclarationWithTypeParameterChildren(node); | |
| } | |
| } | |
| ts_isDeclarationWithTypeParameters = isDeclarationWithTypeParameters; | |
| function isDeclarationWithTypeParameterChildren(node) { | |
| switch (node.kind) { | |
| case 165: | |
| case 166: | |
| case 160: | |
| case 167: | |
| case 170: | |
| case 171: | |
| case 300: | |
| case 245: | |
| case 214: | |
| case 246: | |
| case 247: | |
| case 320: | |
| case 244: | |
| case 161: | |
| case 162: | |
| case 163: | |
| case 164: | |
| case 201: | |
| case 202: | |
| return true; | |
| default: | |
| ts_assertType(node); | |
| return false; | |
| } | |
| } | |
| ts_isDeclarationWithTypeParameterChildren = isDeclarationWithTypeParameterChildren; | |
| function isAnyImportSyntax(node) { | |
| switch (node.kind) { | |
| case 254: | |
| case 253: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_isAnyImportSyntax = isAnyImportSyntax; | |
| function isLateVisibilityPaintedStatement(node) { | |
| switch (node.kind) { | |
| case 254: | |
| case 253: | |
| case 225: | |
| case 245: | |
| case 244: | |
| case 249: | |
| case 247: | |
| case 246: | |
| case 248: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_isLateVisibilityPaintedStatement = isLateVisibilityPaintedStatement; | |
| function isAnyImportOrReExport(node) { | |
| return isAnyImportSyntax(node) || ts_isExportDeclaration(node); | |
| } | |
| ts_isAnyImportOrReExport = isAnyImportOrReExport; | |
| function getEnclosingBlockScopeContainer(node) { | |
| return findAncestor(node.parent, function (current) { return isBlockScope(current, current.parent); }); | |
| } | |
| ts_getEnclosingBlockScopeContainer = getEnclosingBlockScopeContainer; | |
| function declarationNameToString(name) { | |
| return !name || getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name); | |
| } | |
| ts_declarationNameToString = declarationNameToString; | |
| function getNameFromIndexInfo(info) { | |
| return info.declaration ? declarationNameToString(info.declaration.parameters[0].name) : undefined; | |
| } | |
| ts_getNameFromIndexInfo = getNameFromIndexInfo; | |
| function getTextOfPropertyName(name) { | |
| switch (name.kind) { | |
| case 75: | |
| case 76: | |
| return name.escapedText; | |
| case 10: | |
| case 8: | |
| case 14: | |
| return ts_escapeLeadingUnderscores(name.text); | |
| case 154: | |
| if (isStringOrNumericLiteralLike(name.expression)) | |
| return ts_escapeLeadingUnderscores(name.expression.text); | |
| return ts_Debug.fail("Text of property name cannot be read from non-literal-valued ComputedPropertyNames"); | |
| default: | |
| return ts_Debug.assertNever(name); | |
| } | |
| } | |
| ts_getTextOfPropertyName = getTextOfPropertyName; | |
| function entityNameToString(name) { | |
| switch (name.kind) { | |
| case 75: | |
| return getFullWidth(name) === 0 ? ts_idText(name) : getTextOfNode(name); | |
| case 153: | |
| return entityNameToString(name.left) + "." + entityNameToString(name.right); | |
| case 194: | |
| if (ts_isIdentifier(name.name)) { | |
| return entityNameToString(name.expression) + "." + entityNameToString(name.name); | |
| } | |
| else { | |
| return ts_Debug.assertNever(name.name); | |
| } | |
| default: | |
| return ts_Debug.assertNever(name); | |
| } | |
| } | |
| ts_entityNameToString = entityNameToString; | |
| function createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3) { | |
| var sourceFile = getSourceFileOfNode(node); | |
| return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3); | |
| } | |
| ts_createDiagnosticForNode = createDiagnosticForNode; | |
| function createDiagnosticForNodeArray(sourceFile, nodes, message, arg0, arg1, arg2, arg3) { | |
| var start = ts_skipTrivia(sourceFile.text, nodes.pos); | |
| return createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2, arg3); | |
| } | |
| ts_createDiagnosticForNodeArray = createDiagnosticForNodeArray; | |
| function createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3) { | |
| var span = getErrorSpanForNode(sourceFile, node); | |
| return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2, arg3); | |
| } | |
| ts_createDiagnosticForNodeInSourceFile = createDiagnosticForNodeInSourceFile; | |
| function createDiagnosticForNodeFromMessageChain(node, messageChain, relatedInformation) { | |
| var sourceFile = getSourceFileOfNode(node); | |
| var span = getErrorSpanForNode(sourceFile, node); | |
| return { | |
| file: sourceFile, | |
| start: span.start, | |
| length: span.length, | |
| code: messageChain.code, | |
| category: messageChain.category, | |
| messageText: messageChain.next ? messageChain : messageChain.messageText, | |
| relatedInformation: relatedInformation | |
| }; | |
| } | |
| ts_createDiagnosticForNodeFromMessageChain = createDiagnosticForNodeFromMessageChain; | |
| function getSpanOfTokenAtPosition(sourceFile, pos) { | |
| var scanner = ts_createScanner(sourceFile.languageVersion, true, sourceFile.languageVariant, sourceFile.text, undefined, pos); | |
| scanner.scan(); | |
| var start = scanner.getTokenPos(); | |
| return ts_createTextSpanFromBounds(start, scanner.getTextPos()); | |
| } | |
| ts_getSpanOfTokenAtPosition = getSpanOfTokenAtPosition; | |
| function getErrorSpanForArrowFunction(sourceFile, node) { | |
| var pos = ts_skipTrivia(sourceFile.text, node.pos); | |
| if (node.body && node.body.kind === 223) { | |
| var startLine = ts_getLineAndCharacterOfPosition(sourceFile, node.body.pos).line; | |
| var endLine = ts_getLineAndCharacterOfPosition(sourceFile, node.body.end).line; | |
| if (startLine < endLine) { | |
| return ts_createTextSpan(pos, getEndLinePosition(startLine, sourceFile) - pos + 1); | |
| } | |
| } | |
| return ts_createTextSpanFromBounds(pos, node.end); | |
| } | |
| function getErrorSpanForNode(sourceFile, node) { | |
| var errorNode = node; | |
| switch (node.kind) { | |
| case 290: | |
| var pos_1 = ts_skipTrivia(sourceFile.text, 0, false); | |
| if (pos_1 === sourceFile.text.length) { | |
| return ts_createTextSpan(0, 0); | |
| } | |
| return getSpanOfTokenAtPosition(sourceFile, pos_1); | |
| case 242: | |
| case 191: | |
| case 245: | |
| case 214: | |
| case 246: | |
| case 249: | |
| case 248: | |
| case 284: | |
| case 244: | |
| case 201: | |
| case 161: | |
| case 163: | |
| case 164: | |
| case 247: | |
| case 159: | |
| case 158: | |
| errorNode = node.name; | |
| break; | |
| case 202: | |
| return getErrorSpanForArrowFunction(sourceFile, node); | |
| case 277: | |
| case 278: | |
| var start = ts_skipTrivia(sourceFile.text, node.pos); | |
| var end = node.statements.length > 0 ? node.statements[0].pos : node.end; | |
| return ts_createTextSpanFromBounds(start, end); | |
| } | |
| if (errorNode === undefined) { | |
| return getSpanOfTokenAtPosition(sourceFile, node.pos); | |
| } | |
| ts_Debug.assert(!ts_isJSDoc(errorNode)); | |
| var isMissing = nodeIsMissing(errorNode); | |
| var pos = isMissing || ts_isJsxText(node) | |
| ? errorNode.pos | |
| : ts_skipTrivia(sourceFile.text, errorNode.pos); | |
| if (isMissing) { | |
| ts_Debug.assert(pos === errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); | |
| ts_Debug.assert(pos === errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); | |
| } | |
| else { | |
| ts_Debug.assert(pos >= errorNode.pos, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); | |
| ts_Debug.assert(pos <= errorNode.end, "This failure could trigger https://github.com/Microsoft/TypeScript/issues/20809"); | |
| } | |
| return ts_createTextSpanFromBounds(pos, errorNode.end); | |
| } | |
| ts_getErrorSpanForNode = getErrorSpanForNode; | |
| function isExternalOrCommonJsModule(file) { | |
| return (file.externalModuleIndicator || file.commonJsModuleIndicator) !== undefined; | |
| } | |
| ts_isExternalOrCommonJsModule = isExternalOrCommonJsModule; | |
| function isJsonSourceFile(file) { | |
| return file.scriptKind === 6; | |
| } | |
| ts_isJsonSourceFile = isJsonSourceFile; | |
| function isEnumConst(node) { | |
| return !!(ts_getCombinedModifierFlags(node) & 2048); | |
| } | |
| ts_isEnumConst = isEnumConst; | |
| function isDeclarationReadonly(declaration) { | |
| return !!(ts_getCombinedModifierFlags(declaration) & 64 && !ts_isParameterPropertyDeclaration(declaration, declaration.parent)); | |
| } | |
| ts_isDeclarationReadonly = isDeclarationReadonly; | |
| function isVarConst(node) { | |
| return !!(ts_getCombinedNodeFlags(node) & 2); | |
| } | |
| ts_isVarConst = isVarConst; | |
| function isLet(node) { | |
| return !!(ts_getCombinedNodeFlags(node) & 1); | |
| } | |
| ts_isLet = isLet; | |
| function isSuperCall(n) { | |
| return n.kind === 196 && n.expression.kind === 102; | |
| } | |
| ts_isSuperCall = isSuperCall; | |
| function isImportCall(n) { | |
| return n.kind === 196 && n.expression.kind === 96; | |
| } | |
| ts_isImportCall = isImportCall; | |
| function isImportMeta(n) { | |
| return ts_isMetaProperty(n) | |
| && n.keywordToken === 96 | |
| && n.name.escapedText === "meta"; | |
| } | |
| ts_isImportMeta = isImportMeta; | |
| function isLiteralImportTypeNode(n) { | |
| return ts_isImportTypeNode(n) && ts_isLiteralTypeNode(n.argument) && ts_isStringLiteral(n.argument.literal); | |
| } | |
| ts_isLiteralImportTypeNode = isLiteralImportTypeNode; | |
| function isPrologueDirective(node) { | |
| return node.kind === 226 | |
| && node.expression.kind === 10; | |
| } | |
| ts_isPrologueDirective = isPrologueDirective; | |
| function getLeadingCommentRangesOfNode(node, sourceFileOfNode) { | |
| return node.kind !== 11 ? ts_getLeadingCommentRanges(sourceFileOfNode.text, node.pos) : undefined; | |
| } | |
| ts_getLeadingCommentRangesOfNode = getLeadingCommentRangesOfNode; | |
| function getJSDocCommentRanges(node, text) { | |
| var commentRanges = (node.kind === 156 || | |
| node.kind === 155 || | |
| node.kind === 201 || | |
| node.kind === 202 || | |
| node.kind === 200) ? | |
| ts_concatenate(ts_getTrailingCommentRanges(text, node.pos), ts_getLeadingCommentRanges(text, node.pos)) : | |
| ts_getLeadingCommentRanges(text, node.pos); | |
| return ts_filter(commentRanges, function (comment) { | |
| return text.charCodeAt(comment.pos + 1) === 42 && | |
| text.charCodeAt(comment.pos + 2) === 42 && | |
| text.charCodeAt(comment.pos + 3) !== 47; | |
| }); | |
| } | |
| ts_getJSDocCommentRanges = getJSDocCommentRanges; | |
| ts_fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)('|")(.+?)\2.*?\/>/; | |
| var fullTripleSlashReferenceTypeReferenceDirectiveRegEx = /^(\/\/\/\s*<reference\s+types\s*=\s*)('|")(.+?)\2.*?\/>/; | |
| ts_fullTripleSlashAMDReferencePathRegEx = /^(\/\/\/\s*<amd-dependency\s+path\s*=\s*)('|")(.+?)\2.*?\/>/; | |
| var defaultLibReferenceRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)('|")(.+?)\2\s*\/>/; | |
| function isPartOfTypeNode(node) { | |
| if (168 <= node.kind && node.kind <= 188) { | |
| return true; | |
| } | |
| switch (node.kind) { | |
| case 125: | |
| case 148: | |
| case 140: | |
| case 151: | |
| case 143: | |
| case 128: | |
| case 144: | |
| case 141: | |
| case 146: | |
| case 137: | |
| return true; | |
| case 110: | |
| return node.parent.kind !== 205; | |
| case 216: | |
| return !isExpressionWithTypeArgumentsInClassExtendsClause(node); | |
| case 155: | |
| return node.parent.kind === 186 || node.parent.kind === 181; | |
| case 75: | |
| if (node.parent.kind === 153 && node.parent.right === node) { | |
| node = node.parent; | |
| } | |
| else if (node.parent.kind === 194 && node.parent.name === node) { | |
| node = node.parent; | |
| } | |
| ts_Debug.assert(node.kind === 75 || node.kind === 153 || node.kind === 194, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'."); | |
| case 153: | |
| case 194: | |
| case 104: { | |
| var parent = node.parent; | |
| if (parent.kind === 172) { | |
| return false; | |
| } | |
| if (parent.kind === 188) { | |
| return !parent.isTypeOf; | |
| } | |
| if (168 <= parent.kind && parent.kind <= 188) { | |
| return true; | |
| } | |
| switch (parent.kind) { | |
| case 216: | |
| return !isExpressionWithTypeArgumentsInClassExtendsClause(parent); | |
| case 155: | |
| return node === parent.constraint; | |
| case 320: | |
| return node === parent.constraint; | |
| case 159: | |
| case 158: | |
| case 156: | |
| case 242: | |
| return node === parent.type; | |
| case 244: | |
| case 201: | |
| case 202: | |
| case 162: | |
| case 161: | |
| case 160: | |
| case 163: | |
| case 164: | |
| return node === parent.type; | |
| case 165: | |
| case 166: | |
| case 167: | |
| return node === parent.type; | |
| case 199: | |
| return node === parent.type; | |
| case 196: | |
| case 197: | |
| return ts_contains(parent.typeArguments, node); | |
| case 198: | |
| return false; | |
| } | |
| } | |
| } | |
| return false; | |
| } | |
| ts_isPartOfTypeNode = isPartOfTypeNode; | |
| function isChildOfNodeWithKind(node, kind) { | |
| while (node) { | |
| if (node.kind === kind) { | |
| return true; | |
| } | |
| node = node.parent; | |
| } | |
| return false; | |
| } | |
| ts_isChildOfNodeWithKind = isChildOfNodeWithKind; | |
| function forEachReturnStatement(body, visitor) { | |
| return traverse(body); | |
| function traverse(node) { | |
| switch (node.kind) { | |
| case 235: | |
| return visitor(node); | |
| case 251: | |
| case 223: | |
| case 227: | |
| case 228: | |
| case 229: | |
| case 230: | |
| case 231: | |
| case 232: | |
| case 236: | |
| case 237: | |
| case 277: | |
| case 278: | |
| case 238: | |
| case 240: | |
| case 280: | |
| return ts_forEachChild(node, traverse); | |
| } | |
| } | |
| } | |
| ts_forEachReturnStatement = forEachReturnStatement; | |
| function forEachYieldExpression(body, visitor) { | |
| return traverse(body); | |
| function traverse(node) { | |
| switch (node.kind) { | |
| case 212: | |
| visitor(node); | |
| var operand = node.expression; | |
| if (operand) { | |
| traverse(operand); | |
| } | |
| return; | |
| case 248: | |
| case 246: | |
| case 249: | |
| case 247: | |
| return; | |
| default: | |
| if (ts_isFunctionLike(node)) { | |
| if (node.name && node.name.kind === 154) { | |
| traverse(node.name.expression); | |
| return; | |
| } | |
| } | |
| else if (!isPartOfTypeNode(node)) { | |
| ts_forEachChild(node, traverse); | |
| } | |
| } | |
| } | |
| } | |
| ts_forEachYieldExpression = forEachYieldExpression; | |
| function getRestParameterElementType(node) { | |
| if (node && node.kind === 174) { | |
| return node.elementType; | |
| } | |
| else if (node && node.kind === 169) { | |
| return ts_singleOrUndefined(node.typeArguments); | |
| } | |
| else { | |
| return undefined; | |
| } | |
| } | |
| ts_getRestParameterElementType = getRestParameterElementType; | |
| function getMembersOfDeclaration(node) { | |
| switch (node.kind) { | |
| case 246: | |
| case 245: | |
| case 214: | |
| case 173: | |
| return node.members; | |
| case 193: | |
| return node.properties; | |
| } | |
| } | |
| ts_getMembersOfDeclaration = getMembersOfDeclaration; | |
| function isVariableLike(node) { | |
| if (node) { | |
| switch (node.kind) { | |
| case 191: | |
| case 284: | |
| case 156: | |
| case 281: | |
| case 159: | |
| case 158: | |
| case 282: | |
| case 242: | |
| return true; | |
| } | |
| } | |
| return false; | |
| } | |
| ts_isVariableLike = isVariableLike; | |
| function isVariableLikeOrAccessor(node) { | |
| return isVariableLike(node) || ts_isAccessor(node); | |
| } | |
| ts_isVariableLikeOrAccessor = isVariableLikeOrAccessor; | |
| function isVariableDeclarationInVariableStatement(node) { | |
| return node.parent.kind === 243 | |
| && node.parent.parent.kind === 225; | |
| } | |
| ts_isVariableDeclarationInVariableStatement = isVariableDeclarationInVariableStatement; | |
| function isValidESSymbolDeclaration(node) { | |
| return ts_isVariableDeclaration(node) ? isVarConst(node) && ts_isIdentifier(node.name) && isVariableDeclarationInVariableStatement(node) : | |
| ts_isPropertyDeclaration(node) ? hasReadonlyModifier(node) && hasStaticModifier(node) : | |
| ts_isPropertySignature(node) && hasReadonlyModifier(node); | |
| } | |
| ts_isValidESSymbolDeclaration = isValidESSymbolDeclaration; | |
| function introducesArgumentsExoticObject(node) { | |
| switch (node.kind) { | |
| case 161: | |
| case 160: | |
| case 162: | |
| case 163: | |
| case 164: | |
| case 244: | |
| case 201: | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_introducesArgumentsExoticObject = introducesArgumentsExoticObject; | |
| function unwrapInnermostStatementOfLabel(node, beforeUnwrapLabelCallback) { | |
| while (true) { | |
| if (beforeUnwrapLabelCallback) { | |
| beforeUnwrapLabelCallback(node); | |
| } | |
| if (node.statement.kind !== 238) { | |
| return node.statement; | |
| } | |
| node = node.statement; | |
| } | |
| } | |
| ts_unwrapInnermostStatementOfLabel = unwrapInnermostStatementOfLabel; | |
| function isFunctionBlock(node) { | |
| return node && node.kind === 223 && ts_isFunctionLike(node.parent); | |
| } | |
| ts_isFunctionBlock = isFunctionBlock; | |
| function isObjectLiteralMethod(node) { | |
| return node && node.kind === 161 && node.parent.kind === 193; | |
| } | |
| ts_isObjectLiteralMethod = isObjectLiteralMethod; | |
| function isObjectLiteralOrClassExpressionMethod(node) { | |
| return node.kind === 161 && | |
| (node.parent.kind === 193 || | |
| node.parent.kind === 214); | |
| } | |
| ts_isObjectLiteralOrClassExpressionMethod = isObjectLiteralOrClassExpressionMethod; | |
| function isIdentifierTypePredicate(predicate) { | |
| return predicate && predicate.kind === 1; | |
| } | |
| ts_isIdentifierTypePredicate = isIdentifierTypePredicate; | |
| function isThisTypePredicate(predicate) { | |
| return predicate && predicate.kind === 0; | |
| } | |
| ts_isThisTypePredicate = isThisTypePredicate; | |
| function getPropertyAssignment(objectLiteral, key, key2) { | |
| return objectLiteral.properties.filter(function (property) { | |
| if (property.kind === 281) { | |
| var propName = getTextOfPropertyName(property.name); | |
| return key === propName || (!!key2 && key2 === propName); | |
| } | |
| return false; | |
| }); | |
| } | |
| ts_getPropertyAssignment = getPropertyAssignment; | |
| function getTsConfigObjectLiteralExpression(tsConfigSourceFile) { | |
| if (tsConfigSourceFile && tsConfigSourceFile.statements.length) { | |
| var expression = tsConfigSourceFile.statements[0].expression; | |
| return ts_tryCast(expression, ts_isObjectLiteralExpression); | |
| } | |
| } | |
| ts_getTsConfigObjectLiteralExpression = getTsConfigObjectLiteralExpression; | |
| function getTsConfigPropArrayElementValue(tsConfigSourceFile, propKey, elementValue) { | |
| return ts_firstDefined(getTsConfigPropArray(tsConfigSourceFile, propKey), function (property) { | |
| return ts_isArrayLiteralExpression(property.initializer) ? | |
| ts_find(property.initializer.elements, function (element) { return ts_isStringLiteral(element) && element.text === elementValue; }) : | |
| undefined; | |
| }); | |
| } | |
| ts_getTsConfigPropArrayElementValue = getTsConfigPropArrayElementValue; | |
| function getTsConfigPropArray(tsConfigSourceFile, propKey) { | |
| var jsonObjectLiteral = getTsConfigObjectLiteralExpression(tsConfigSourceFile); | |
| return jsonObjectLiteral ? getPropertyAssignment(jsonObjectLiteral, propKey) : ts_emptyArray; | |
| } | |
| ts_getTsConfigPropArray = getTsConfigPropArray; | |
| function getContainingFunction(node) { | |
| return findAncestor(node.parent, ts_isFunctionLike); | |
| } | |
| ts_getContainingFunction = getContainingFunction; | |
| function getContainingFunctionDeclaration(node) { | |
| return findAncestor(node.parent, ts_isFunctionLikeDeclaration); | |
| } | |
| ts_getContainingFunctionDeclaration = getContainingFunctionDeclaration; | |
| function getContainingClass(node) { | |
| return findAncestor(node.parent, ts_isClassLike); | |
| } | |
| ts_getContainingClass = getContainingClass; | |
| function getThisContainer(node, includeArrowFunctions) { | |
| ts_Debug.assert(node.kind !== 290); | |
| while (true) { | |
| node = node.parent; | |
| if (!node) { | |
| return ts_Debug.fail(); | |
| } | |
| switch (node.kind) { | |
| case 154: | |
| if (ts_isClassLike(node.parent.parent)) { | |
| return node; | |
| } | |
| node = node.parent; | |
| break; | |
| case 157: | |
| if (node.parent.kind === 156 && ts_isClassElement(node.parent.parent)) { | |
| node = node.parent.parent; | |
| } | |
| else if (ts_isClassElement(node.parent)) { | |
| node = node.parent; | |
| } | |
| break; | |
| case 202: | |
| if (!includeArrowFunctions) { | |
| continue; | |
| } | |
| case 244: | |
| case 201: | |
| case 249: | |
| case 159: | |
| case 158: | |
| case 161: | |
| case 160: | |
| case 162: | |
| case 163: | |
| case 164: | |
| case 165: | |
| case 166: | |
| case 167: | |
| case 248: | |
| case 290: | |
| return node; | |
| } | |
| } | |
| } | |
| ts_getThisContainer = getThisContainer; | |
| function getNewTargetContainer(node) { | |
| var container = getThisContainer(node, false); | |
| if (container) { | |
| switch (container.kind) { | |
| case 162: | |
| case 244: | |
| case 201: | |
| return container; | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_getNewTargetContainer = getNewTargetContainer; | |
| function getSuperContainer(node, stopOnFunctions) { | |
| while (true) { | |
| node = node.parent; | |
| if (!node) { | |
| return node; | |
| } | |
| switch (node.kind) { | |
| case 154: | |
| node = node.parent; | |
| break; | |
| case 244: | |
| case 201: | |
| case 202: | |
| if (!stopOnFunctions) { | |
| continue; | |
| } | |
| case 159: | |
| case 158: | |
| case 161: | |
| case 160: | |
| case 162: | |
| case 163: | |
| case 164: | |
| return node; | |
| case 157: | |
| if (node.parent.kind === 156 && ts_isClassElement(node.parent.parent)) { | |
| node = node.parent.parent; | |
| } | |
| else if (ts_isClassElement(node.parent)) { | |
| node = node.parent; | |
| } | |
| break; | |
| } | |
| } | |
| } | |
| ts_getSuperContainer = getSuperContainer; | |
| function getImmediatelyInvokedFunctionExpression(func) { | |
| if (func.kind === 201 || func.kind === 202) { | |
| var prev = func; | |
| var parent = func.parent; | |
| while (parent.kind === 200) { | |
| prev = parent; | |
| parent = parent.parent; | |
| } | |
| if (parent.kind === 196 && parent.expression === prev) { | |
| return parent; | |
| } | |
| } | |
| } | |
| ts_getImmediatelyInvokedFunctionExpression = getImmediatelyInvokedFunctionExpression; | |
| function isSuperOrSuperProperty(node) { | |
| return node.kind === 102 | |
| || isSuperProperty(node); | |
| } | |
| ts_isSuperOrSuperProperty = isSuperOrSuperProperty; | |
| function isSuperProperty(node) { | |
| var kind = node.kind; | |
| return (kind === 194 || kind === 195) | |
| && node.expression.kind === 102; | |
| } | |
| ts_isSuperProperty = isSuperProperty; | |
| function isThisProperty(node) { | |
| var kind = node.kind; | |
| return (kind === 194 || kind === 195) | |
| && node.expression.kind === 104; | |
| } | |
| ts_isThisProperty = isThisProperty; | |
| function getEntityNameFromTypeNode(node) { | |
| switch (node.kind) { | |
| case 169: | |
| return node.typeName; | |
| case 216: | |
| return isEntityNameExpression(node.expression) | |
| ? node.expression | |
| : undefined; | |
| case 75: | |
| case 153: | |
| return node; | |
| } | |
| return undefined; | |
| } | |
| ts_getEntityNameFromTypeNode = getEntityNameFromTypeNode; | |
| function getInvokedExpression(node) { | |
| switch (node.kind) { | |
| case 198: | |
| return node.tag; | |
| case 268: | |
| case 267: | |
| return node.tagName; | |
| default: | |
| return node.expression; | |
| } | |
| } | |
| ts_getInvokedExpression = getInvokedExpression; | |
| function nodeCanBeDecorated(node, parent, grandparent) { | |
| if (ts_isNamedDeclaration(node) && ts_isPrivateIdentifier(node.name)) { | |
| return false; | |
| } | |
| switch (node.kind) { | |
| case 245: | |
| return true; | |
| case 159: | |
| return parent.kind === 245; | |
| case 163: | |
| case 164: | |
| case 161: | |
| return node.body !== undefined | |
| && parent.kind === 245; | |
| case 156: | |
| return parent.body !== undefined | |
| && (parent.kind === 162 | |
| || parent.kind === 161 | |
| || parent.kind === 164) | |
| && grandparent.kind === 245; | |
| } | |
| return false; | |
| } | |
| ts_nodeCanBeDecorated = nodeCanBeDecorated; | |
| function nodeIsDecorated(node, parent, grandparent) { | |
| return node.decorators !== undefined | |
| && nodeCanBeDecorated(node, parent, grandparent); | |
| } | |
| ts_nodeIsDecorated = nodeIsDecorated; | |
| function nodeOrChildIsDecorated(node, parent, grandparent) { | |
| return nodeIsDecorated(node, parent, grandparent) || childIsDecorated(node, parent); | |
| } | |
| ts_nodeOrChildIsDecorated = nodeOrChildIsDecorated; | |
| function childIsDecorated(node, parent) { | |
| switch (node.kind) { | |
| case 245: | |
| return ts_some(node.members, function (m) { return nodeOrChildIsDecorated(m, node, parent); }); | |
| case 161: | |
| case 164: | |
| return ts_some(node.parameters, function (p) { return nodeIsDecorated(p, node, parent); }); | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_childIsDecorated = childIsDecorated; | |
| function isJSXTagName(node) { | |
| var parent = node.parent; | |
| if (parent.kind === 268 || | |
| parent.kind === 267 || | |
| parent.kind === 269) { | |
| return parent.tagName === node; | |
| } | |
| return false; | |
| } | |
| ts_isJSXTagName = isJSXTagName; | |
| function isExpressionNode(node) { | |
| switch (node.kind) { | |
| case 102: | |
| case 100: | |
| case 106: | |
| case 91: | |
| case 13: | |
| case 192: | |
| case 193: | |
| case 194: | |
| case 195: | |
| case 196: | |
| case 197: | |
| case 198: | |
| case 217: | |
| case 199: | |
| case 218: | |
| case 200: | |
| case 201: | |
| case 214: | |
| case 202: | |
| case 205: | |
| case 203: | |
| case 204: | |
| case 207: | |
| case 208: | |
| case 209: | |
| case 210: | |
| case 213: | |
| case 211: | |
| case 215: | |
| case 266: | |
| case 267: | |
| case 270: | |
| case 212: | |
| case 206: | |
| case 219: | |
| return true; | |
| case 153: | |
| while (node.parent.kind === 153) { | |
| node = node.parent; | |
| } | |
| return node.parent.kind === 172 || isJSXTagName(node); | |
| case 75: | |
| if (node.parent.kind === 172 || isJSXTagName(node)) { | |
| return true; | |
| } | |
| case 8: | |
| case 9: | |
| case 10: | |
| case 14: | |
| case 104: | |
| return isInExpressionContext(node); | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_isExpressionNode = isExpressionNode; | |
| function isInExpressionContext(node) { | |
| var parent = node.parent; | |
| switch (parent.kind) { | |
| case 242: | |
| case 156: | |
| case 159: | |
| case 158: | |
| case 284: | |
| case 281: | |
| case 191: | |
| return parent.initializer === node; | |
| case 226: | |
| case 227: | |
| case 228: | |
| case 229: | |
| case 235: | |
| case 236: | |
| case 237: | |
| case 277: | |
| case 239: | |
| return parent.expression === node; | |
| case 230: | |
| var forStatement = parent; | |
| return (forStatement.initializer === node && forStatement.initializer.kind !== 243) || | |
| forStatement.condition === node || | |
| forStatement.incrementor === node; | |
| case 231: | |
| case 232: | |
| var forInStatement = parent; | |
| return (forInStatement.initializer === node && forInStatement.initializer.kind !== 243) || | |
| forInStatement.expression === node; | |
| case 199: | |
| case 217: | |
| return node === parent.expression; | |
| case 221: | |
| return node === parent.expression; | |
| case 154: | |
| return node === parent.expression; | |
| case 157: | |
| case 276: | |
| case 275: | |
| case 283: | |
| return true; | |
| case 216: | |
| return parent.expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent); | |
| case 282: | |
| return parent.objectAssignmentInitializer === node; | |
| default: | |
| return isExpressionNode(parent); | |
| } | |
| } | |
| ts_isInExpressionContext = isInExpressionContext; | |
| function isPartOfTypeQuery(node) { | |
| while (node.kind === 153 || node.kind === 75) { | |
| node = node.parent; | |
| } | |
| return node.kind === 172; | |
| } | |
| ts_isPartOfTypeQuery = isPartOfTypeQuery; | |
| function isExternalModuleImportEqualsDeclaration(node) { | |
| return node.kind === 253 && node.moduleReference.kind === 265; | |
| } | |
| ts_isExternalModuleImportEqualsDeclaration = isExternalModuleImportEqualsDeclaration; | |
| function getExternalModuleImportEqualsDeclarationExpression(node) { | |
| ts_Debug.assert(isExternalModuleImportEqualsDeclaration(node)); | |
| return node.moduleReference.expression; | |
| } | |
| ts_getExternalModuleImportEqualsDeclarationExpression = getExternalModuleImportEqualsDeclarationExpression; | |
| function isInternalModuleImportEqualsDeclaration(node) { | |
| return node.kind === 253 && node.moduleReference.kind !== 265; | |
| } | |
| ts_isInternalModuleImportEqualsDeclaration = isInternalModuleImportEqualsDeclaration; | |
| function isSourceFileJS(file) { | |
| return isInJSFile(file); | |
| } | |
| ts_isSourceFileJS = isSourceFileJS; | |
| function isSourceFileNotJS(file) { | |
| return !isInJSFile(file); | |
| } | |
| ts_isSourceFileNotJS = isSourceFileNotJS; | |
| function isInJSFile(node) { | |
| return !!node && !!(node.flags & 131072); | |
| } | |
| ts_isInJSFile = isInJSFile; | |
| function isInJsonFile(node) { | |
| return !!node && !!(node.flags & 33554432); | |
| } | |
| ts_isInJsonFile = isInJsonFile; | |
| function isSourceFileNotJson(file) { | |
| return !isJsonSourceFile(file); | |
| } | |
| ts_isSourceFileNotJson = isSourceFileNotJson; | |
| function isInJSDoc(node) { | |
| return !!node && !!(node.flags & 4194304); | |
| } | |
| ts_isInJSDoc = isInJSDoc; | |
| function isJSDocIndexSignature(node) { | |
| return ts_isTypeReferenceNode(node) && | |
| ts_isIdentifier(node.typeName) && | |
| node.typeName.escapedText === "Object" && | |
| node.typeArguments && node.typeArguments.length === 2 && | |
| (node.typeArguments[0].kind === 143 || node.typeArguments[0].kind === 140); | |
| } | |
| ts_isJSDocIndexSignature = isJSDocIndexSignature; | |
| function isRequireCall(callExpression, requireStringLiteralLikeArgument) { | |
| if (callExpression.kind !== 196) { | |
| return false; | |
| } | |
| var _a = callExpression, expression = _a.expression, args = _a.arguments; | |
| if (expression.kind !== 75 || expression.escapedText !== "require") { | |
| return false; | |
| } | |
| if (args.length !== 1) { | |
| return false; | |
| } | |
| var arg = args[0]; | |
| return !requireStringLiteralLikeArgument || ts_isStringLiteralLike(arg); | |
| } | |
| ts_isRequireCall = isRequireCall; | |
| function isSingleOrDoubleQuote(charCode) { | |
| return charCode === 39 || charCode === 34; | |
| } | |
| ts_isSingleOrDoubleQuote = isSingleOrDoubleQuote; | |
| function isStringDoubleQuoted(str, sourceFile) { | |
| return getSourceTextOfNodeFromSourceFile(sourceFile, str).charCodeAt(0) === 34; | |
| } | |
| ts_isStringDoubleQuoted = isStringDoubleQuoted; | |
| function getDeclarationOfExpando(node) { | |
| if (!node.parent) { | |
| return undefined; | |
| } | |
| var name; | |
| var decl; | |
| if (ts_isVariableDeclaration(node.parent) && node.parent.initializer === node) { | |
| if (!isInJSFile(node) && !isVarConst(node.parent)) { | |
| return undefined; | |
| } | |
| name = node.parent.name; | |
| decl = node.parent; | |
| } | |
| else if (ts_isBinaryExpression(node.parent)) { | |
| var parentNode = node.parent; | |
| var parentNodeOperator = node.parent.operatorToken.kind; | |
| if (parentNodeOperator === 62 && parentNode.right === node) { | |
| name = parentNode.left; | |
| decl = name; | |
| } | |
| else if (parentNodeOperator === 56 || parentNodeOperator === 60) { | |
| if (ts_isVariableDeclaration(parentNode.parent) && parentNode.parent.initializer === parentNode) { | |
| name = parentNode.parent.name; | |
| decl = parentNode.parent; | |
| } | |
| else if (ts_isBinaryExpression(parentNode.parent) && parentNode.parent.operatorToken.kind === 62 && parentNode.parent.right === parentNode) { | |
| name = parentNode.parent.left; | |
| decl = name; | |
| } | |
| if (!name || !isBindableStaticNameExpression(name) || !isSameEntityName(name, parentNode.left)) { | |
| return undefined; | |
| } | |
| } | |
| } | |
| if (!name || !getExpandoInitializer(node, isPrototypeAccess(name))) { | |
| return undefined; | |
| } | |
| return decl; | |
| } | |
| ts_getDeclarationOfExpando = getDeclarationOfExpando; | |
| function isAssignmentDeclaration(decl) { | |
| return ts_isBinaryExpression(decl) || isAccessExpression(decl) || ts_isIdentifier(decl) || ts_isCallExpression(decl); | |
| } | |
| ts_isAssignmentDeclaration = isAssignmentDeclaration; | |
| function getEffectiveInitializer(node) { | |
| if (isInJSFile(node) && node.initializer && | |
| ts_isBinaryExpression(node.initializer) && | |
| (node.initializer.operatorToken.kind === 56 || node.initializer.operatorToken.kind === 60) && | |
| node.name && isEntityNameExpression(node.name) && isSameEntityName(node.name, node.initializer.left)) { | |
| return node.initializer.right; | |
| } | |
| return node.initializer; | |
| } | |
| ts_getEffectiveInitializer = getEffectiveInitializer; | |
| function getDeclaredExpandoInitializer(node) { | |
| var init = getEffectiveInitializer(node); | |
| return init && getExpandoInitializer(init, isPrototypeAccess(node.name)); | |
| } | |
| ts_getDeclaredExpandoInitializer = getDeclaredExpandoInitializer; | |
| function hasExpandoValueProperty(node, isPrototypeAssignment) { | |
| return ts_forEach(node.properties, function (p) { | |
| return ts_isPropertyAssignment(p) && | |
| ts_isIdentifier(p.name) && | |
| p.name.escapedText === "value" && | |
| p.initializer && | |
| getExpandoInitializer(p.initializer, isPrototypeAssignment); | |
| }); | |
| } | |
| function getAssignedExpandoInitializer(node) { | |
| if (node && node.parent && ts_isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 62) { | |
| var isPrototypeAssignment = isPrototypeAccess(node.parent.left); | |
| return getExpandoInitializer(node.parent.right, isPrototypeAssignment) || | |
| getDefaultedExpandoInitializer(node.parent.left, node.parent.right, isPrototypeAssignment); | |
| } | |
| if (node && ts_isCallExpression(node) && isBindableObjectDefinePropertyCall(node)) { | |
| var result = hasExpandoValueProperty(node.arguments[2], node.arguments[1].text === "prototype"); | |
| if (result) { | |
| return result; | |
| } | |
| } | |
| } | |
| ts_getAssignedExpandoInitializer = getAssignedExpandoInitializer; | |
| function getExpandoInitializer(initializer, isPrototypeAssignment) { | |
| if (ts_isCallExpression(initializer)) { | |
| var e = skipParentheses(initializer.expression); | |
| return e.kind === 201 || e.kind === 202 ? initializer : undefined; | |
| } | |
| if (initializer.kind === 201 || | |
| initializer.kind === 214 || | |
| initializer.kind === 202) { | |
| return initializer; | |
| } | |
| if (ts_isObjectLiteralExpression(initializer) && (initializer.properties.length === 0 || isPrototypeAssignment)) { | |
| return initializer; | |
| } | |
| } | |
| ts_getExpandoInitializer = getExpandoInitializer; | |
| function getDefaultedExpandoInitializer(name, initializer, isPrototypeAssignment) { | |
| var e = ts_isBinaryExpression(initializer) | |
| && (initializer.operatorToken.kind === 56 || initializer.operatorToken.kind === 60) | |
| && getExpandoInitializer(initializer.right, isPrototypeAssignment); | |
| if (e && isSameEntityName(name, initializer.left)) { | |
| return e; | |
| } | |
| } | |
| function isDefaultedExpandoInitializer(node) { | |
| var name = ts_isVariableDeclaration(node.parent) ? node.parent.name : | |
| ts_isBinaryExpression(node.parent) && node.parent.operatorToken.kind === 62 ? node.parent.left : | |
| undefined; | |
| return name && getExpandoInitializer(node.right, isPrototypeAccess(name)) && isEntityNameExpression(name) && isSameEntityName(name, node.left); | |
| } | |
| ts_isDefaultedExpandoInitializer = isDefaultedExpandoInitializer; | |
| function getNameOfExpando(node) { | |
| if (ts_isBinaryExpression(node.parent)) { | |
| var parent = ((node.parent.operatorToken.kind === 56 || node.parent.operatorToken.kind === 60) && ts_isBinaryExpression(node.parent.parent)) ? node.parent.parent : node.parent; | |
| if (parent.operatorToken.kind === 62 && ts_isIdentifier(parent.left)) { | |
| return parent.left; | |
| } | |
| } | |
| else if (ts_isVariableDeclaration(node.parent)) { | |
| return node.parent.name; | |
| } | |
| } | |
| ts_getNameOfExpando = getNameOfExpando; | |
| function isSameEntityName(name, initializer) { | |
| if (isPropertyNameLiteral(name) && isPropertyNameLiteral(initializer)) { | |
| return getTextOfIdentifierOrLiteral(name) === getTextOfIdentifierOrLiteral(name); | |
| } | |
| if (ts_isIdentifier(name) && isLiteralLikeAccess(initializer) && | |
| (initializer.expression.kind === 104 || | |
| ts_isIdentifier(initializer.expression) && | |
| (initializer.expression.escapedText === "window" || | |
| initializer.expression.escapedText === "self" || | |
| initializer.expression.escapedText === "global"))) { | |
| var nameOrArgument = getNameOrArgument(initializer); | |
| if (ts_isPrivateIdentifier(nameOrArgument)) { | |
| ts_Debug.fail("Unexpected PrivateIdentifier in name expression with literal-like access."); | |
| } | |
| return isSameEntityName(name, nameOrArgument); | |
| } | |
| if (isLiteralLikeAccess(name) && isLiteralLikeAccess(initializer)) { | |
| return getElementOrPropertyAccessName(name) === getElementOrPropertyAccessName(initializer) | |
| && isSameEntityName(name.expression, initializer.expression); | |
| } | |
| return false; | |
| } | |
| function getRightMostAssignedExpression(node) { | |
| while (isAssignmentExpression(node, true)) { | |
| node = node.right; | |
| } | |
| return node; | |
| } | |
| ts_getRightMostAssignedExpression = getRightMostAssignedExpression; | |
| function isExportsIdentifier(node) { | |
| return ts_isIdentifier(node) && node.escapedText === "exports"; | |
| } | |
| ts_isExportsIdentifier = isExportsIdentifier; | |
| function isModuleExportsAccessExpression(node) { | |
| return (ts_isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node)) | |
| && ts_isIdentifier(node.expression) | |
| && node.expression.escapedText === "module" | |
| && getElementOrPropertyAccessName(node) === "exports"; | |
| } | |
| ts_isModuleExportsAccessExpression = isModuleExportsAccessExpression; | |
| function getAssignmentDeclarationKind(expr) { | |
| var special = getAssignmentDeclarationKindWorker(expr); | |
| return special === 5 || isInJSFile(expr) ? special : 0; | |
| } | |
| ts_getAssignmentDeclarationKind = getAssignmentDeclarationKind; | |
| function isBindableObjectDefinePropertyCall(expr) { | |
| return ts_length(expr.arguments) === 3 && | |
| ts_isPropertyAccessExpression(expr.expression) && | |
| ts_isIdentifier(expr.expression.expression) && | |
| ts_idText(expr.expression.expression) === "Object" && | |
| ts_idText(expr.expression.name) === "defineProperty" && | |
| isStringOrNumericLiteralLike(expr.arguments[1]) && | |
| isBindableStaticNameExpression(expr.arguments[0], true); | |
| } | |
| ts_isBindableObjectDefinePropertyCall = isBindableObjectDefinePropertyCall; | |
| function isLiteralLikeAccess(node) { | |
| return ts_isPropertyAccessExpression(node) || isLiteralLikeElementAccess(node); | |
| } | |
| ts_isLiteralLikeAccess = isLiteralLikeAccess; | |
| function isLiteralLikeElementAccess(node) { | |
| return ts_isElementAccessExpression(node) && (isStringOrNumericLiteralLike(node.argumentExpression) || | |
| isWellKnownSymbolSyntactically(node.argumentExpression)); | |
| } | |
| ts_isLiteralLikeElementAccess = isLiteralLikeElementAccess; | |
| function isBindableStaticAccessExpression(node, excludeThisKeyword) { | |
| return ts_isPropertyAccessExpression(node) && (!excludeThisKeyword && node.expression.kind === 104 || isBindableStaticNameExpression(node.expression, true)) | |
| || isBindableStaticElementAccessExpression(node, excludeThisKeyword); | |
| } | |
| ts_isBindableStaticAccessExpression = isBindableStaticAccessExpression; | |
| function isBindableStaticElementAccessExpression(node, excludeThisKeyword) { | |
| return isLiteralLikeElementAccess(node) | |
| && ((!excludeThisKeyword && node.expression.kind === 104) || | |
| isEntityNameExpression(node.expression) || | |
| isBindableStaticAccessExpression(node.expression, true)); | |
| } | |
| ts_isBindableStaticElementAccessExpression = isBindableStaticElementAccessExpression; | |
| function isBindableStaticNameExpression(node, excludeThisKeyword) { | |
| return isEntityNameExpression(node) || isBindableStaticAccessExpression(node, excludeThisKeyword); | |
| } | |
| ts_isBindableStaticNameExpression = isBindableStaticNameExpression; | |
| function getNameOrArgument(expr) { | |
| if (ts_isPropertyAccessExpression(expr)) { | |
| return expr.name; | |
| } | |
| return expr.argumentExpression; | |
| } | |
| ts_getNameOrArgument = getNameOrArgument; | |
| function getAssignmentDeclarationKindWorker(expr) { | |
| if (ts_isCallExpression(expr)) { | |
| if (!isBindableObjectDefinePropertyCall(expr)) { | |
| return 0; | |
| } | |
| var entityName = expr.arguments[0]; | |
| if (isExportsIdentifier(entityName) || isModuleExportsAccessExpression(entityName)) { | |
| return 8; | |
| } | |
| if (isBindableStaticAccessExpression(entityName) && getElementOrPropertyAccessName(entityName) === "prototype") { | |
| return 9; | |
| } | |
| return 7; | |
| } | |
| if (expr.operatorToken.kind !== 62 || !isAccessExpression(expr.left)) { | |
| return 0; | |
| } | |
| if (isBindableStaticNameExpression(expr.left.expression, true) && getElementOrPropertyAccessName(expr.left) === "prototype" && ts_isObjectLiteralExpression(getInitializerOfBinaryExpression(expr))) { | |
| return 6; | |
| } | |
| return getAssignmentDeclarationPropertyAccessKind(expr.left); | |
| } | |
| function getElementOrPropertyAccessArgumentExpressionOrName(node) { | |
| if (ts_isPropertyAccessExpression(node)) { | |
| return node.name; | |
| } | |
| var arg = skipParentheses(node.argumentExpression); | |
| if (ts_isNumericLiteral(arg) || ts_isStringLiteralLike(arg)) { | |
| return arg; | |
| } | |
| return node; | |
| } | |
| ts_getElementOrPropertyAccessArgumentExpressionOrName = getElementOrPropertyAccessArgumentExpressionOrName; | |
| function getElementOrPropertyAccessName(node) { | |
| var name = getElementOrPropertyAccessArgumentExpressionOrName(node); | |
| if (name) { | |
| if (ts_isIdentifier(name)) { | |
| return name.escapedText; | |
| } | |
| if (ts_isStringLiteralLike(name) || ts_isNumericLiteral(name)) { | |
| return ts_escapeLeadingUnderscores(name.text); | |
| } | |
| } | |
| if (ts_isElementAccessExpression(node) && isWellKnownSymbolSyntactically(node.argumentExpression)) { | |
| return getPropertyNameForKnownSymbolName(ts_idText(node.argumentExpression.name)); | |
| } | |
| return undefined; | |
| } | |
| ts_getElementOrPropertyAccessName = getElementOrPropertyAccessName; | |
| function getAssignmentDeclarationPropertyAccessKind(lhs) { | |
| if (lhs.expression.kind === 104) { | |
| return 4; | |
| } | |
| else if (isModuleExportsAccessExpression(lhs)) { | |
| return 2; | |
| } | |
| else if (isBindableStaticNameExpression(lhs.expression, true)) { | |
| if (isPrototypeAccess(lhs.expression)) { | |
| return 3; | |
| } | |
| var nextToLast = lhs; | |
| while (!ts_isIdentifier(nextToLast.expression)) { | |
| nextToLast = nextToLast.expression; | |
| } | |
| var id = nextToLast.expression; | |
| if ((id.escapedText === "exports" || | |
| id.escapedText === "module" && getElementOrPropertyAccessName(nextToLast) === "exports") && | |
| isBindableStaticAccessExpression(lhs)) { | |
| return 1; | |
| } | |
| if (isBindableStaticNameExpression(lhs, true) || (ts_isElementAccessExpression(lhs) && isDynamicName(lhs) && lhs.expression.kind !== 104)) { | |
| return 5; | |
| } | |
| } | |
| return 0; | |
| } | |
| ts_getAssignmentDeclarationPropertyAccessKind = getAssignmentDeclarationPropertyAccessKind; | |
| function getInitializerOfBinaryExpression(expr) { | |
| while (ts_isBinaryExpression(expr.right)) { | |
| expr = expr.right; | |
| } | |
| return expr.right; | |
| } | |
| ts_getInitializerOfBinaryExpression = getInitializerOfBinaryExpression; | |
| function isPrototypePropertyAssignment(node) { | |
| return ts_isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 3; | |
| } | |
| ts_isPrototypePropertyAssignment = isPrototypePropertyAssignment; | |
| function isSpecialPropertyDeclaration(expr) { | |
| return isInJSFile(expr) && | |
| expr.parent && expr.parent.kind === 226 && | |
| (!ts_isElementAccessExpression(expr) || isLiteralLikeElementAccess(expr)) && | |
| !!ts_getJSDocTypeTag(expr.parent); | |
| } | |
| ts_isSpecialPropertyDeclaration = isSpecialPropertyDeclaration; | |
| function isFunctionSymbol(symbol) { | |
| if (!symbol || !symbol.valueDeclaration) { | |
| return false; | |
| } | |
| var decl = symbol.valueDeclaration; | |
| return decl.kind === 244 || ts_isVariableDeclaration(decl) && decl.initializer && ts_isFunctionLike(decl.initializer); | |
| } | |
| ts_isFunctionSymbol = isFunctionSymbol; | |
| function importFromModuleSpecifier(node) { | |
| return tryGetImportFromModuleSpecifier(node) || ts_Debug.failBadSyntaxKind(node.parent); | |
| } | |
| ts_importFromModuleSpecifier = importFromModuleSpecifier; | |
| function tryGetImportFromModuleSpecifier(node) { | |
| switch (node.parent.kind) { | |
| case 254: | |
| case 260: | |
| return node.parent; | |
| case 265: | |
| return node.parent.parent; | |
| case 196: | |
| return isImportCall(node.parent) || isRequireCall(node.parent, false) ? node.parent : undefined; | |
| case 187: | |
| ts_Debug.assert(ts_isStringLiteral(node)); | |
| return ts_tryCast(node.parent.parent, ts_isImportTypeNode); | |
| default: | |
| return undefined; | |
| } | |
| } | |
| ts_tryGetImportFromModuleSpecifier = tryGetImportFromModuleSpecifier; | |
| function getExternalModuleName(node) { | |
| switch (node.kind) { | |
| case 254: | |
| case 260: | |
| return node.moduleSpecifier; | |
| case 253: | |
| return node.moduleReference.kind === 265 ? node.moduleReference.expression : undefined; | |
| case 188: | |
| return isLiteralImportTypeNode(node) ? node.argument.literal : undefined; | |
| default: | |
| return ts_Debug.assertNever(node); | |
| } | |
| } | |
| ts_getExternalModuleName = getExternalModuleName; | |
| function getNamespaceDeclarationNode(node) { | |
| switch (node.kind) { | |
| case 254: | |
| return node.importClause && ts_tryCast(node.importClause.namedBindings, ts_isNamespaceImport); | |
| case 253: | |
| return node; | |
| case 260: | |
| return node.exportClause && ts_tryCast(node.exportClause, ts_isNamespaceExport); | |
| default: | |
| return ts_Debug.assertNever(node); | |
| } | |
| } | |
| ts_getNamespaceDeclarationNode = getNamespaceDeclarationNode; | |
| function isDefaultImport(node) { | |
| return node.kind === 254 && !!node.importClause && !!node.importClause.name; | |
| } | |
| ts_isDefaultImport = isDefaultImport; | |
| function forEachImportClauseDeclaration(node, action) { | |
| if (node.name) { | |
| var result = action(node); | |
| if (result) | |
| return result; | |
| } | |
| if (node.namedBindings) { | |
| var result = ts_isNamespaceImport(node.namedBindings) | |
| ? action(node.namedBindings) | |
| : ts_forEach(node.namedBindings.elements, action); | |
| if (result) | |
| return result; | |
| } | |
| } | |
| ts_forEachImportClauseDeclaration = forEachImportClauseDeclaration; | |
| function hasQuestionToken(node) { | |
| if (node) { | |
| switch (node.kind) { | |
| case 156: | |
| case 161: | |
| case 160: | |
| case 282: | |
| case 281: | |
| case 159: | |
| case 158: | |
| return node.questionToken !== undefined; | |
| } | |
| } | |
| return false; | |
| } | |
| ts_hasQuestionToken = hasQuestionToken; | |
| function isJSDocConstructSignature(node) { | |
| var param = ts_isJSDocFunctionType(node) ? ts_firstOrUndefined(node.parameters) : undefined; | |
| var name = ts_tryCast(param && param.name, ts_isIdentifier); | |
| return !!name && name.escapedText === "new"; | |
| } | |
| ts_isJSDocConstructSignature = isJSDocConstructSignature; | |
| function isJSDocTypeAlias(node) { | |
| return node.kind === 321 || node.kind === 314 || node.kind === 315; | |
| } | |
| ts_isJSDocTypeAlias = isJSDocTypeAlias; | |
| function isTypeAlias(node) { | |
| return isJSDocTypeAlias(node) || ts_isTypeAliasDeclaration(node); | |
| } | |
| ts_isTypeAlias = isTypeAlias; | |
| function getSourceOfAssignment(node) { | |
| return ts_isExpressionStatement(node) && | |
| ts_isBinaryExpression(node.expression) && | |
| node.expression.operatorToken.kind === 62 | |
| ? getRightMostAssignedExpression(node.expression) | |
| : undefined; | |
| } | |
| function getSourceOfDefaultedAssignment(node) { | |
| return ts_isExpressionStatement(node) && | |
| ts_isBinaryExpression(node.expression) && | |
| getAssignmentDeclarationKind(node.expression) !== 0 && | |
| ts_isBinaryExpression(node.expression.right) && | |
| (node.expression.right.operatorToken.kind === 56 || node.expression.right.operatorToken.kind === 60) | |
| ? node.expression.right.right | |
| : undefined; | |
| } | |
| function getSingleInitializerOfVariableStatementOrPropertyDeclaration(node) { | |
| switch (node.kind) { | |
| case 225: | |
| var v = getSingleVariableOfVariableStatement(node); | |
| return v && v.initializer; | |
| case 159: | |
| return node.initializer; | |
| case 281: | |
| return node.initializer; | |
| } | |
| } | |
| ts_getSingleInitializerOfVariableStatementOrPropertyDeclaration = getSingleInitializerOfVariableStatementOrPropertyDeclaration; | |
| function getSingleVariableOfVariableStatement(node) { | |
| return ts_isVariableStatement(node) ? ts_firstOrUndefined(node.declarationList.declarations) : undefined; | |
| } | |
| function getNestedModuleDeclaration(node) { | |
| return ts_isModuleDeclaration(node) && | |
| node.body && | |
| node.body.kind === 249 | |
| ? node.body | |
| : undefined; | |
| } | |
| function getJSDocCommentsAndTags(hostNode) { | |
| var result; | |
| if (isVariableLike(hostNode) && ts_hasInitializer(hostNode) && ts_hasJSDocNodes(hostNode.initializer)) { | |
| result = ts_append(result, ts_last(hostNode.initializer.jsDoc)); | |
| } | |
| var node = hostNode; | |
| while (node && node.parent) { | |
| if (ts_hasJSDocNodes(node)) { | |
| result = ts_append(result, ts_last(node.jsDoc)); | |
| } | |
| if (node.kind === 156) { | |
| result = ts_addRange(result, ts_getJSDocParameterTags(node)); | |
| break; | |
| } | |
| if (node.kind === 155) { | |
| result = ts_addRange(result, ts_getJSDocTypeParameterTags(node)); | |
| break; | |
| } | |
| node = getNextJSDocCommentLocation(node); | |
| } | |
| return result || ts_emptyArray; | |
| } | |
| ts_getJSDocCommentsAndTags = getJSDocCommentsAndTags; | |
| function getNextJSDocCommentLocation(node) { | |
| var parent = node.parent; | |
| if (parent.kind === 281 || | |
| parent.kind === 259 || | |
| parent.kind === 159 || | |
| parent.kind === 226 && node.kind === 194 || | |
| getNestedModuleDeclaration(parent) || | |
| ts_isBinaryExpression(node) && node.operatorToken.kind === 62) { | |
| return parent; | |
| } | |
| else if (parent.parent && | |
| (getSingleVariableOfVariableStatement(parent.parent) === node || | |
| ts_isBinaryExpression(parent) && parent.operatorToken.kind === 62)) { | |
| return parent.parent; | |
| } | |
| else if (parent.parent && parent.parent.parent && | |
| (getSingleVariableOfVariableStatement(parent.parent.parent) || | |
| getSingleInitializerOfVariableStatementOrPropertyDeclaration(parent.parent.parent) === node || | |
| getSourceOfDefaultedAssignment(parent.parent.parent))) { | |
| return parent.parent.parent; | |
| } | |
| } | |
| function getParameterSymbolFromJSDoc(node) { | |
| if (node.symbol) { | |
| return node.symbol; | |
| } | |
| if (!ts_isIdentifier(node.name)) { | |
| return undefined; | |
| } | |
| var name = node.name.escapedText; | |
| var decl = getHostSignatureFromJSDoc(node); | |
| if (!decl) { | |
| return undefined; | |
| } | |
| var parameter = ts_find(decl.parameters, function (p) { return p.name.kind === 75 && p.name.escapedText === name; }); | |
| return parameter && parameter.symbol; | |
| } | |
| ts_getParameterSymbolFromJSDoc = getParameterSymbolFromJSDoc; | |
| function getHostSignatureFromJSDoc(node) { | |
| return getHostSignatureFromJSDocHost(getJSDocHost(node)); | |
| } | |
| ts_getHostSignatureFromJSDoc = getHostSignatureFromJSDoc; | |
| function getHostSignatureFromJSDocHost(host) { | |
| var decl = getSourceOfDefaultedAssignment(host) || | |
| getSourceOfAssignment(host) || | |
| getSingleInitializerOfVariableStatementOrPropertyDeclaration(host) || | |
| getSingleVariableOfVariableStatement(host) || | |
| getNestedModuleDeclaration(host) || | |
| host; | |
| return decl && ts_isFunctionLike(decl) ? decl : undefined; | |
| } | |
| ts_getHostSignatureFromJSDocHost = getHostSignatureFromJSDocHost; | |
| function getJSDocHost(node) { | |
| return ts_Debug.assertDefined(findAncestor(node.parent, ts_isJSDoc)).parent; | |
| } | |
| ts_getJSDocHost = getJSDocHost; | |
| function getTypeParameterFromJsDoc(node) { | |
| var name = node.name.escapedText; | |
| var typeParameters = node.parent.parent.parent.typeParameters; | |
| return typeParameters && ts_find(typeParameters, function (p) { return p.name.escapedText === name; }); | |
| } | |
| ts_getTypeParameterFromJsDoc = getTypeParameterFromJsDoc; | |
| function hasRestParameter(s) { | |
| var last = ts_lastOrUndefined(s.parameters); | |
| return !!last && isRestParameter(last); | |
| } | |
| ts_hasRestParameter = hasRestParameter; | |
| function isRestParameter(node) { | |
| var type = ts_isJSDocParameterTag(node) ? (node.typeExpression && node.typeExpression.type) : node.type; | |
| return node.dotDotDotToken !== undefined || !!type && type.kind === 301; | |
| } | |
| ts_isRestParameter = isRestParameter; | |
| function hasTypeArguments(node) { | |
| return !!node.typeArguments; | |
| } | |
| ts_hasTypeArguments = hasTypeArguments; | |
| function getAssignmentTargetKind(node) { | |
| var parent = node.parent; | |
| while (true) { | |
| switch (parent.kind) { | |
| case 209: | |
| var binaryOperator = parent.operatorToken.kind; | |
| return isAssignmentOperator(binaryOperator) && parent.left === node ? | |
| binaryOperator === 62 ? 1 : 2 : | |
| 0; | |
| case 207: | |
| case 208: | |
| var unaryOperator = parent.operator; | |
| return unaryOperator === 45 || unaryOperator === 46 ? 2 : 0; | |
| case 231: | |
| case 232: | |
| return parent.initializer === node ? 1 : 0; | |
| case 200: | |
| case 192: | |
| case 213: | |
| case 218: | |
| node = parent; | |
| break; | |
| case 282: | |
| if (parent.name !== node) { | |
| return 0; | |
| } | |
| node = parent.parent; | |
| break; | |
| case 281: | |
| if (parent.name === node) { | |
| return 0; | |
| } | |
| node = parent.parent; | |
| break; | |
| default: | |
| return 0; | |
| } | |
| parent = node.parent; | |
| } | |
| } | |
| ts_getAssignmentTargetKind = getAssignmentTargetKind; | |
| function isAssignmentTarget(node) { | |
| return getAssignmentTargetKind(node) !== 0; | |
| } | |
| ts_isAssignmentTarget = isAssignmentTarget; | |
| function isNodeWithPossibleHoistedDeclaration(node) { | |
| switch (node.kind) { | |
| case 223: | |
| case 225: | |
| case 236: | |
| case 227: | |
| case 237: | |
| case 251: | |
| case 277: | |
| case 278: | |
| case 238: | |
| case 230: | |
| case 231: | |
| case 232: | |
| case 228: | |
| case 229: | |
| case 240: | |
| case 280: | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_isNodeWithPossibleHoistedDeclaration = isNodeWithPossibleHoistedDeclaration; | |
| function isValueSignatureDeclaration(node) { | |
| return ts_isFunctionExpression(node) || ts_isArrowFunction(node) || ts_isMethodOrAccessor(node) || ts_isFunctionDeclaration(node) || ts_isConstructorDeclaration(node); | |
| } | |
| ts_isValueSignatureDeclaration = isValueSignatureDeclaration; | |
| function walkUp(node, kind) { | |
| while (node && node.kind === kind) { | |
| node = node.parent; | |
| } | |
| return node; | |
| } | |
| function walkUpParenthesizedTypes(node) { | |
| return walkUp(node, 182); | |
| } | |
| ts_walkUpParenthesizedTypes = walkUpParenthesizedTypes; | |
| function walkUpParenthesizedExpressions(node) { | |
| return walkUp(node, 200); | |
| } | |
| ts_walkUpParenthesizedExpressions = walkUpParenthesizedExpressions; | |
| function skipParentheses(node) { | |
| while (node.kind === 200) { | |
| node = node.expression; | |
| } | |
| return node; | |
| } | |
| ts_skipParentheses = skipParentheses; | |
| function skipParenthesesUp(node) { | |
| while (node.kind === 200) { | |
| node = node.parent; | |
| } | |
| return node; | |
| } | |
| function isDeleteTarget(node) { | |
| if (node.kind !== 194 && node.kind !== 195) { | |
| return false; | |
| } | |
| node = walkUpParenthesizedExpressions(node.parent); | |
| return node && node.kind === 203; | |
| } | |
| ts_isDeleteTarget = isDeleteTarget; | |
| function isNodeDescendantOf(node, ancestor) { | |
| while (node) { | |
| if (node === ancestor) | |
| return true; | |
| node = node.parent; | |
| } | |
| return false; | |
| } | |
| ts_isNodeDescendantOf = isNodeDescendantOf; | |
| function isDeclarationName(name) { | |
| return !ts_isSourceFile(name) && !ts_isBindingPattern(name) && ts_isDeclaration(name.parent) && name.parent.name === name; | |
| } | |
| ts_isDeclarationName = isDeclarationName; | |
| function getDeclarationFromName(name) { | |
| var parent = name.parent; | |
| switch (name.kind) { | |
| case 10: | |
| case 14: | |
| case 8: | |
| if (ts_isComputedPropertyName(parent)) | |
| return parent.parent; | |
| case 75: | |
| if (ts_isDeclaration(parent)) { | |
| return parent.name === name ? parent : undefined; | |
| } | |
| else if (ts_isQualifiedName(parent)) { | |
| var tag = parent.parent; | |
| return ts_isJSDocParameterTag(tag) && tag.name === parent ? tag : undefined; | |
| } | |
| else { | |
| var binExp = parent.parent; | |
| return ts_isBinaryExpression(binExp) && | |
| getAssignmentDeclarationKind(binExp) !== 0 && | |
| (binExp.left.symbol || binExp.symbol) && | |
| ts_getNameOfDeclaration(binExp) === name | |
| ? binExp | |
| : undefined; | |
| } | |
| case 76: | |
| return ts_isDeclaration(parent) && parent.name === name ? parent : undefined; | |
| default: | |
| return undefined; | |
| } | |
| } | |
| ts_getDeclarationFromName = getDeclarationFromName; | |
| function isLiteralComputedPropertyDeclarationName(node) { | |
| return isStringOrNumericLiteralLike(node) && | |
| node.parent.kind === 154 && | |
| ts_isDeclaration(node.parent.parent); | |
| } | |
| ts_isLiteralComputedPropertyDeclarationName = isLiteralComputedPropertyDeclarationName; | |
| function isIdentifierName(node) { | |
| var parent = node.parent; | |
| switch (parent.kind) { | |
| case 159: | |
| case 158: | |
| case 161: | |
| case 160: | |
| case 163: | |
| case 164: | |
| case 284: | |
| case 281: | |
| case 194: | |
| return parent.name === node; | |
| case 153: | |
| if (parent.right === node) { | |
| while (parent.kind === 153) { | |
| parent = parent.parent; | |
| } | |
| return parent.kind === 172 || parent.kind === 169; | |
| } | |
| return false; | |
| case 191: | |
| case 258: | |
| return parent.propertyName === node; | |
| case 263: | |
| case 273: | |
| return true; | |
| } | |
| return false; | |
| } | |
| ts_isIdentifierName = isIdentifierName; | |
| function isAliasSymbolDeclaration(node) { | |
| return node.kind === 253 || | |
| node.kind === 252 || | |
| node.kind === 255 && !!node.name || | |
| node.kind === 256 || | |
| node.kind === 262 || | |
| node.kind === 258 || | |
| node.kind === 263 || | |
| node.kind === 259 && exportAssignmentIsAlias(node) || | |
| ts_isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 && exportAssignmentIsAlias(node) || | |
| ts_isPropertyAccessExpression(node) && ts_isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 62 && isAliasableExpression(node.parent.right) || | |
| node.kind === 282 || | |
| node.kind === 281 && isAliasableExpression(node.initializer); | |
| } | |
| ts_isAliasSymbolDeclaration = isAliasSymbolDeclaration; | |
| function getAliasDeclarationFromName(node) { | |
| switch (node.parent.kind) { | |
| case 255: | |
| case 258: | |
| case 256: | |
| case 263: | |
| case 259: | |
| case 253: | |
| return node.parent; | |
| case 153: | |
| do { | |
| node = node.parent; | |
| } while (node.parent.kind === 153); | |
| return getAliasDeclarationFromName(node); | |
| } | |
| } | |
| ts_getAliasDeclarationFromName = getAliasDeclarationFromName; | |
| function isAliasableExpression(e) { | |
| return isEntityNameExpression(e) || ts_isClassExpression(e); | |
| } | |
| ts_isAliasableExpression = isAliasableExpression; | |
| function exportAssignmentIsAlias(node) { | |
| var e = getExportAssignmentExpression(node); | |
| return isAliasableExpression(e); | |
| } | |
| ts_exportAssignmentIsAlias = exportAssignmentIsAlias; | |
| function getExportAssignmentExpression(node) { | |
| return ts_isExportAssignment(node) ? node.expression : node.right; | |
| } | |
| ts_getExportAssignmentExpression = getExportAssignmentExpression; | |
| function getPropertyAssignmentAliasLikeExpression(node) { | |
| return node.kind === 282 ? node.name : node.kind === 281 ? node.initializer : | |
| node.parent.right; | |
| } | |
| ts_getPropertyAssignmentAliasLikeExpression = getPropertyAssignmentAliasLikeExpression; | |
| function getEffectiveBaseTypeNode(node) { | |
| var baseType = getClassExtendsHeritageElement(node); | |
| if (baseType && isInJSFile(node)) { | |
| var tag = ts_getJSDocAugmentsTag(node); | |
| if (tag) { | |
| return tag.class; | |
| } | |
| } | |
| return baseType; | |
| } | |
| ts_getEffectiveBaseTypeNode = getEffectiveBaseTypeNode; | |
| function getClassExtendsHeritageElement(node) { | |
| var heritageClause = getHeritageClause(node.heritageClauses, 90); | |
| return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined; | |
| } | |
| ts_getClassExtendsHeritageElement = getClassExtendsHeritageElement; | |
| function getClassImplementsHeritageClauseElements(node) { | |
| var heritageClause = getHeritageClause(node.heritageClauses, 113); | |
| return heritageClause ? heritageClause.types : undefined; | |
| } | |
| ts_getClassImplementsHeritageClauseElements = getClassImplementsHeritageClauseElements; | |
| function getAllSuperTypeNodes(node) { | |
| return ts_isInterfaceDeclaration(node) ? getInterfaceBaseTypeNodes(node) || ts_emptyArray : | |
| ts_isClassLike(node) ? ts_concatenate(ts_singleElementArray(getEffectiveBaseTypeNode(node)), getClassImplementsHeritageClauseElements(node)) || ts_emptyArray : | |
| ts_emptyArray; | |
| } | |
| ts_getAllSuperTypeNodes = getAllSuperTypeNodes; | |
| function getInterfaceBaseTypeNodes(node) { | |
| var heritageClause = getHeritageClause(node.heritageClauses, 90); | |
| return heritageClause ? heritageClause.types : undefined; | |
| } | |
| ts_getInterfaceBaseTypeNodes = getInterfaceBaseTypeNodes; | |
| function getHeritageClause(clauses, kind) { | |
| if (clauses) { | |
| for (var _i = 0, clauses_1 = clauses; _i < clauses_1.length; _i++) { | |
| var clause = clauses_1[_i]; | |
| if (clause.token === kind) { | |
| return clause; | |
| } | |
| } | |
| } | |
| return undefined; | |
| } | |
| ts_getHeritageClause = getHeritageClause; | |
| function getAncestor(node, kind) { | |
| while (node) { | |
| if (node.kind === kind) { | |
| return node; | |
| } | |
| node = node.parent; | |
| } | |
| return undefined; | |
| } | |
| ts_getAncestor = getAncestor; | |
| function isKeyword(token) { | |
| return 77 <= token && token <= 152; | |
| } | |
| ts_isKeyword = isKeyword; | |
| function isContextualKeyword(token) { | |
| return 122 <= token && token <= 152; | |
| } | |
| ts_isContextualKeyword = isContextualKeyword; | |
| function isNonContextualKeyword(token) { | |
| return isKeyword(token) && !isContextualKeyword(token); | |
| } | |
| ts_isNonContextualKeyword = isNonContextualKeyword; | |
| function isFutureReservedKeyword(token) { | |
| return 113 <= token && token <= 121; | |
| } | |
| ts_isFutureReservedKeyword = isFutureReservedKeyword; | |
| function isStringANonContextualKeyword(name) { | |
| var token = ts_stringToToken(name); | |
| return token !== undefined && isNonContextualKeyword(token); | |
| } | |
| ts_isStringANonContextualKeyword = isStringANonContextualKeyword; | |
| function isStringAKeyword(name) { | |
| var token = ts_stringToToken(name); | |
| return token !== undefined && isKeyword(token); | |
| } | |
| ts_isStringAKeyword = isStringAKeyword; | |
| function isIdentifierANonContextualKeyword(_a) { | |
| var originalKeywordKind = _a.originalKeywordKind; | |
| return !!originalKeywordKind && !isContextualKeyword(originalKeywordKind); | |
| } | |
| ts_isIdentifierANonContextualKeyword = isIdentifierANonContextualKeyword; | |
| function isTrivia(token) { | |
| return 2 <= token && token <= 7; | |
| } | |
| ts_isTrivia = isTrivia; | |
| function getFunctionFlags(node) { | |
| if (!node) { | |
| return 4; | |
| } | |
| var flags = 0; | |
| switch (node.kind) { | |
| case 244: | |
| case 201: | |
| case 161: | |
| if (node.asteriskToken) { | |
| flags |= 1; | |
| } | |
| case 202: | |
| if (hasModifier(node, 256)) { | |
| flags |= 2; | |
| } | |
| break; | |
| } | |
| if (!node.body) { | |
| flags |= 4; | |
| } | |
| return flags; | |
| } | |
| ts_getFunctionFlags = getFunctionFlags; | |
| function isAsyncFunction(node) { | |
| switch (node.kind) { | |
| case 244: | |
| case 201: | |
| case 202: | |
| case 161: | |
| return node.body !== undefined | |
| && node.asteriskToken === undefined | |
| && hasModifier(node, 256); | |
| } | |
| return false; | |
| } | |
| ts_isAsyncFunction = isAsyncFunction; | |
| function isStringOrNumericLiteralLike(node) { | |
| return ts_isStringLiteralLike(node) || ts_isNumericLiteral(node); | |
| } | |
| ts_isStringOrNumericLiteralLike = isStringOrNumericLiteralLike; | |
| function isSignedNumericLiteral(node) { | |
| return ts_isPrefixUnaryExpression(node) && (node.operator === 39 || node.operator === 40) && ts_isNumericLiteral(node.operand); | |
| } | |
| ts_isSignedNumericLiteral = isSignedNumericLiteral; | |
| function hasDynamicName(declaration) { | |
| var name = ts_getNameOfDeclaration(declaration); | |
| return !!name && isDynamicName(name); | |
| } | |
| ts_hasDynamicName = hasDynamicName; | |
| function isDynamicName(name) { | |
| if (!(name.kind === 154 || name.kind === 195)) { | |
| return false; | |
| } | |
| var expr = ts_isElementAccessExpression(name) ? name.argumentExpression : name.expression; | |
| return !isStringOrNumericLiteralLike(expr) && | |
| !isSignedNumericLiteral(expr) && | |
| !isWellKnownSymbolSyntactically(expr); | |
| } | |
| ts_isDynamicName = isDynamicName; | |
| function isWellKnownSymbolSyntactically(node) { | |
| return ts_isPropertyAccessExpression(node) && isESSymbolIdentifier(node.expression); | |
| } | |
| ts_isWellKnownSymbolSyntactically = isWellKnownSymbolSyntactically; | |
| function getPropertyNameForPropertyNameNode(name) { | |
| switch (name.kind) { | |
| case 75: | |
| case 76: | |
| return name.escapedText; | |
| case 10: | |
| case 8: | |
| return ts_escapeLeadingUnderscores(name.text); | |
| case 154: | |
| var nameExpression = name.expression; | |
| if (isWellKnownSymbolSyntactically(nameExpression)) { | |
| return getPropertyNameForKnownSymbolName(ts_idText(nameExpression.name)); | |
| } | |
| else if (isStringOrNumericLiteralLike(nameExpression)) { | |
| return ts_escapeLeadingUnderscores(nameExpression.text); | |
| } | |
| return undefined; | |
| default: | |
| return ts_Debug.assertNever(name); | |
| } | |
| } | |
| ts_getPropertyNameForPropertyNameNode = getPropertyNameForPropertyNameNode; | |
| function isPropertyNameLiteral(node) { | |
| switch (node.kind) { | |
| case 75: | |
| case 10: | |
| case 14: | |
| case 8: | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_isPropertyNameLiteral = isPropertyNameLiteral; | |
| function getTextOfIdentifierOrLiteral(node) { | |
| return ts_isIdentifierOrPrivateIdentifier(node) ? ts_idText(node) : node.text; | |
| } | |
| ts_getTextOfIdentifierOrLiteral = getTextOfIdentifierOrLiteral; | |
| function getEscapedTextOfIdentifierOrLiteral(node) { | |
| return ts_isIdentifierOrPrivateIdentifier(node) ? node.escapedText : ts_escapeLeadingUnderscores(node.text); | |
| } | |
| ts_getEscapedTextOfIdentifierOrLiteral = getEscapedTextOfIdentifierOrLiteral; | |
| function getPropertyNameForUniqueESSymbol(symbol) { | |
| return "__@" + ts_getSymbolId(symbol) + "@" + symbol.escapedName; | |
| } | |
| ts_getPropertyNameForUniqueESSymbol = getPropertyNameForUniqueESSymbol; | |
| function getPropertyNameForKnownSymbolName(symbolName) { | |
| return "__@" + symbolName; | |
| } | |
| ts_getPropertyNameForKnownSymbolName = getPropertyNameForKnownSymbolName; | |
| function getSymbolNameForPrivateIdentifier(containingClassSymbol, description) { | |
| return "__#" + ts_getSymbolId(containingClassSymbol) + "@" + description; | |
| } | |
| ts_getSymbolNameForPrivateIdentifier = getSymbolNameForPrivateIdentifier; | |
| function isKnownSymbol(symbol) { | |
| return ts_startsWith(symbol.escapedName, "__@"); | |
| } | |
| ts_isKnownSymbol = isKnownSymbol; | |
| function isESSymbolIdentifier(node) { | |
| return node.kind === 75 && node.escapedText === "Symbol"; | |
| } | |
| ts_isESSymbolIdentifier = isESSymbolIdentifier; | |
| function isPushOrUnshiftIdentifier(node) { | |
| return node.escapedText === "push" || node.escapedText === "unshift"; | |
| } | |
| ts_isPushOrUnshiftIdentifier = isPushOrUnshiftIdentifier; | |
| function isParameterDeclaration(node) { | |
| var root = getRootDeclaration(node); | |
| return root.kind === 156; | |
| } | |
| ts_isParameterDeclaration = isParameterDeclaration; | |
| function getRootDeclaration(node) { | |
| while (node.kind === 191) { | |
| node = node.parent.parent; | |
| } | |
| return node; | |
| } | |
| ts_getRootDeclaration = getRootDeclaration; | |
| function nodeStartsNewLexicalEnvironment(node) { | |
| var kind = node.kind; | |
| return kind === 162 | |
| || kind === 201 | |
| || kind === 244 | |
| || kind === 202 | |
| || kind === 161 | |
| || kind === 163 | |
| || kind === 164 | |
| || kind === 249 | |
| || kind === 290; | |
| } | |
| ts_nodeStartsNewLexicalEnvironment = nodeStartsNewLexicalEnvironment; | |
| function nodeIsSynthesized(range) { | |
| return positionIsSynthesized(range.pos) | |
| || positionIsSynthesized(range.end); | |
| } | |
| ts_nodeIsSynthesized = nodeIsSynthesized; | |
| function getOriginalSourceFile(sourceFile) { | |
| return ts_getParseTreeNode(sourceFile, ts_isSourceFile) || sourceFile; | |
| } | |
| ts_getOriginalSourceFile = getOriginalSourceFile; | |
| function getExpressionAssociativity(expression) { | |
| var operator = getOperator(expression); | |
| var hasArguments = expression.kind === 197 && expression.arguments !== undefined; | |
| return getOperatorAssociativity(expression.kind, operator, hasArguments); | |
| } | |
| ts_getExpressionAssociativity = getExpressionAssociativity; | |
| function getOperatorAssociativity(kind, operator, hasArguments) { | |
| switch (kind) { | |
| case 197: | |
| return hasArguments ? 0 : 1; | |
| case 207: | |
| case 204: | |
| case 205: | |
| case 203: | |
| case 206: | |
| case 210: | |
| case 212: | |
| return 1; | |
| case 209: | |
| switch (operator) { | |
| case 42: | |
| case 62: | |
| case 63: | |
| case 64: | |
| case 66: | |
| case 65: | |
| case 67: | |
| case 68: | |
| case 69: | |
| case 70: | |
| case 71: | |
| case 72: | |
| case 74: | |
| case 73: | |
| return 1; | |
| } | |
| } | |
| return 0; | |
| } | |
| ts_getOperatorAssociativity = getOperatorAssociativity; | |
| function getExpressionPrecedence(expression) { | |
| var operator = getOperator(expression); | |
| var hasArguments = expression.kind === 197 && expression.arguments !== undefined; | |
| return getOperatorPrecedence(expression.kind, operator, hasArguments); | |
| } | |
| ts_getExpressionPrecedence = getExpressionPrecedence; | |
| function getOperator(expression) { | |
| if (expression.kind === 209) { | |
| return expression.operatorToken.kind; | |
| } | |
| else if (expression.kind === 207 || expression.kind === 208) { | |
| return expression.operator; | |
| } | |
| else { | |
| return expression.kind; | |
| } | |
| } | |
| ts_getOperator = getOperator; | |
| function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) { | |
| switch (nodeKind) { | |
| case 326: | |
| return 0; | |
| case 213: | |
| return 1; | |
| case 212: | |
| return 2; | |
| case 210: | |
| return 4; | |
| case 209: | |
| switch (operatorKind) { | |
| case 27: | |
| return 0; | |
| case 62: | |
| case 63: | |
| case 64: | |
| case 66: | |
| case 65: | |
| case 67: | |
| case 68: | |
| case 69: | |
| case 70: | |
| case 71: | |
| case 72: | |
| case 74: | |
| case 73: | |
| return 3; | |
| default: | |
| return getBinaryOperatorPrecedence(operatorKind); | |
| } | |
| case 207: | |
| case 204: | |
| case 205: | |
| case 203: | |
| case 206: | |
| return 16; | |
| case 208: | |
| return 17; | |
| case 196: | |
| return 18; | |
| case 197: | |
| return hasArguments ? 19 : 18; | |
| case 198: | |
| case 194: | |
| case 195: | |
| return 19; | |
| case 104: | |
| case 102: | |
| case 75: | |
| case 100: | |
| case 106: | |
| case 91: | |
| case 8: | |
| case 9: | |
| case 10: | |
| case 192: | |
| case 193: | |
| case 201: | |
| case 202: | |
| case 214: | |
| case 266: | |
| case 267: | |
| case 270: | |
| case 13: | |
| case 14: | |
| case 211: | |
| case 200: | |
| case 215: | |
| return 20; | |
| default: | |
| return -1; | |
| } | |
| } | |
| ts_getOperatorPrecedence = getOperatorPrecedence; | |
| function getBinaryOperatorPrecedence(kind) { | |
| switch (kind) { | |
| case 60: | |
| return 4; | |
| case 56: | |
| return 5; | |
| case 55: | |
| return 6; | |
| case 51: | |
| return 7; | |
| case 52: | |
| return 8; | |
| case 50: | |
| return 9; | |
| case 34: | |
| case 35: | |
| case 36: | |
| case 37: | |
| return 10; | |
| case 29: | |
| case 31: | |
| case 32: | |
| case 33: | |
| case 98: | |
| case 97: | |
| case 123: | |
| return 11; | |
| case 47: | |
| case 48: | |
| case 49: | |
| return 12; | |
| case 39: | |
| case 40: | |
| return 13; | |
| case 41: | |
| case 43: | |
| case 44: | |
| return 14; | |
| case 42: | |
| return 15; | |
| } | |
| return -1; | |
| } | |
| ts_getBinaryOperatorPrecedence = getBinaryOperatorPrecedence; | |
| function createDiagnosticCollection() { | |
| var nonFileDiagnostics = []; | |
| var filesWithDiagnostics = []; | |
| var fileDiagnostics = ts_createMap(); | |
| var hasReadNonFileDiagnostics = false; | |
| return { | |
| add: add, | |
| lookup: lookup, | |
| getGlobalDiagnostics: getGlobalDiagnostics, | |
| getDiagnostics: getDiagnostics, | |
| reattachFileDiagnostics: reattachFileDiagnostics | |
| }; | |
| function reattachFileDiagnostics(newFile) { | |
| ts_forEach(fileDiagnostics.get(newFile.fileName), function (diagnostic) { return diagnostic.file = newFile; }); | |
| } | |
| function lookup(diagnostic) { | |
| var diagnostics; | |
| if (diagnostic.file) { | |
| diagnostics = fileDiagnostics.get(diagnostic.file.fileName); | |
| } | |
| else { | |
| diagnostics = nonFileDiagnostics; | |
| } | |
| if (!diagnostics) { | |
| return undefined; | |
| } | |
| var result = ts_binarySearch(diagnostics, diagnostic, ts_identity, compareDiagnosticsSkipRelatedInformation); | |
| if (result >= 0) { | |
| return diagnostics[result]; | |
| } | |
| return undefined; | |
| } | |
| function add(diagnostic) { | |
| var diagnostics; | |
| if (diagnostic.file) { | |
| diagnostics = fileDiagnostics.get(diagnostic.file.fileName); | |
| if (!diagnostics) { | |
| diagnostics = []; | |
| fileDiagnostics.set(diagnostic.file.fileName, diagnostics); | |
| ts_insertSorted(filesWithDiagnostics, diagnostic.file.fileName, ts_compareStringsCaseSensitive); | |
| } | |
| } | |
| else { | |
| if (hasReadNonFileDiagnostics) { | |
| hasReadNonFileDiagnostics = false; | |
| nonFileDiagnostics = nonFileDiagnostics.slice(); | |
| } | |
| diagnostics = nonFileDiagnostics; | |
| } | |
| ts_insertSorted(diagnostics, diagnostic, compareDiagnostics); | |
| } | |
| function getGlobalDiagnostics() { | |
| hasReadNonFileDiagnostics = true; | |
| return nonFileDiagnostics; | |
| } | |
| function getDiagnostics(fileName) { | |
| if (fileName) { | |
| return fileDiagnostics.get(fileName) || []; | |
| } | |
| var fileDiags = ts_flatMapToMutable(filesWithDiagnostics, function (f) { return fileDiagnostics.get(f); }); | |
| if (!nonFileDiagnostics.length) { | |
| return fileDiags; | |
| } | |
| fileDiags.unshift.apply(fileDiags, nonFileDiagnostics); | |
| return fileDiags; | |
| } | |
| } | |
| ts_createDiagnosticCollection = createDiagnosticCollection; | |
| var templateSubstitutionRegExp = /\$\{/g; | |
| function escapeTemplateSubstitution(str) { | |
| return str.replace(templateSubstitutionRegExp, "\\${"); | |
| } | |
| var doubleQuoteEscapedCharsRegExp = /[\\\"\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g; | |
| var singleQuoteEscapedCharsRegExp = /[\\\'\u0000-\u001f\t\v\f\b\r\n\u2028\u2029\u0085]/g; | |
| var backtickQuoteEscapedCharsRegExp = /[\\\`]/g; | |
| var escapedCharsMap = ts_createMapFromTemplate({ | |
| "\t": "\\t", | |
| "\v": "\\v", | |
| "\f": "\\f", | |
| "\b": "\\b", | |
| "\r": "\\r", | |
| "\n": "\\n", | |
| "\\": "\\\\", | |
| "\"": "\\\"", | |
| "\'": "\\\'", | |
| "\`": "\\\`", | |
| "\u2028": "\\u2028", | |
| "\u2029": "\\u2029", | |
| "\u0085": "\\u0085" | |
| }); | |
| function encodeUtf16EscapeSequence(charCode) { | |
| var hexCharCode = charCode.toString(16).toUpperCase(); | |
| var paddedHexCode = ("0000" + hexCharCode).slice(-4); | |
| return "\\u" + paddedHexCode; | |
| } | |
| function getReplacement(c, offset, input) { | |
| if (c.charCodeAt(0) === 0) { | |
| var lookAhead = input.charCodeAt(offset + c.length); | |
| if (lookAhead >= 48 && lookAhead <= 57) { | |
| return "\\x00"; | |
| } | |
| return "\\0"; | |
| } | |
| return escapedCharsMap.get(c) || encodeUtf16EscapeSequence(c.charCodeAt(0)); | |
| } | |
| function escapeString(s, quoteChar) { | |
| var escapedCharsRegExp = quoteChar === 96 ? backtickQuoteEscapedCharsRegExp : | |
| quoteChar === 39 ? singleQuoteEscapedCharsRegExp : | |
| doubleQuoteEscapedCharsRegExp; | |
| return s.replace(escapedCharsRegExp, getReplacement); | |
| } | |
| ts_escapeString = escapeString; | |
| var nonAsciiCharacters = /[^\u0000-\u007F]/g; | |
| function escapeNonAsciiString(s, quoteChar) { | |
| s = escapeString(s, quoteChar); | |
| return nonAsciiCharacters.test(s) ? | |
| s.replace(nonAsciiCharacters, function (c) { return encodeUtf16EscapeSequence(c.charCodeAt(0)); }) : | |
| s; | |
| } | |
| ts_escapeNonAsciiString = escapeNonAsciiString; | |
| var jsxDoubleQuoteEscapedCharsRegExp = /[\"\u0000-\u001f\u2028\u2029\u0085]/g; | |
| var jsxSingleQuoteEscapedCharsRegExp = /[\'\u0000-\u001f\u2028\u2029\u0085]/g; | |
| var jsxEscapedCharsMap = ts_createMapFromTemplate({ | |
| "\"": """, | |
| "\'": "'" | |
| }); | |
| function encodeJsxCharacterEntity(charCode) { | |
| var hexCharCode = charCode.toString(16).toUpperCase(); | |
| return "&#x" + hexCharCode + ";"; | |
| } | |
| function getJsxAttributeStringReplacement(c) { | |
| if (c.charCodeAt(0) === 0) { | |
| return "�"; | |
| } | |
| return jsxEscapedCharsMap.get(c) || encodeJsxCharacterEntity(c.charCodeAt(0)); | |
| } | |
| function escapeJsxAttributeString(s, quoteChar) { | |
| var escapedCharsRegExp = quoteChar === 39 ? jsxSingleQuoteEscapedCharsRegExp : | |
| jsxDoubleQuoteEscapedCharsRegExp; | |
| return s.replace(escapedCharsRegExp, getJsxAttributeStringReplacement); | |
| } | |
| ts_escapeJsxAttributeString = escapeJsxAttributeString; | |
| function stripQuotes(name) { | |
| var length = name.length; | |
| if (length >= 2 && name.charCodeAt(0) === name.charCodeAt(length - 1) && isQuoteOrBacktick(name.charCodeAt(0))) { | |
| return name.substring(1, length - 1); | |
| } | |
| return name; | |
| } | |
| ts_stripQuotes = stripQuotes; | |
| function isQuoteOrBacktick(charCode) { | |
| return charCode === 39 || | |
| charCode === 34 || | |
| charCode === 96; | |
| } | |
| function isIntrinsicJsxName(name) { | |
| var ch = name.charCodeAt(0); | |
| return (ch >= 97 && ch <= 122) || ts_stringContains(name, "-"); | |
| } | |
| ts_isIntrinsicJsxName = isIntrinsicJsxName; | |
| var indentStrings = ["", " "]; | |
| function getIndentString(level) { | |
| if (indentStrings[level] === undefined) { | |
| indentStrings[level] = getIndentString(level - 1) + indentStrings[1]; | |
| } | |
| return indentStrings[level]; | |
| } | |
| ts_getIndentString = getIndentString; | |
| function getIndentSize() { | |
| return indentStrings[1].length; | |
| } | |
| ts_getIndentSize = getIndentSize; | |
| function createTextWriter(newLine) { | |
| var output; | |
| var indent; | |
| var lineStart; | |
| var lineCount; | |
| var linePos; | |
| var hasTrailingComment = false; | |
| function updateLineCountAndPosFor(s) { | |
| var lineStartsOfS = ts_computeLineStarts(s); | |
| if (lineStartsOfS.length > 1) { | |
| lineCount = lineCount + lineStartsOfS.length - 1; | |
| linePos = output.length - s.length + ts_last(lineStartsOfS); | |
| lineStart = (linePos - output.length) === 0; | |
| } | |
| else { | |
| lineStart = false; | |
| } | |
| } | |
| function writeText(s) { | |
| if (s && s.length) { | |
| if (lineStart) { | |
| s = getIndentString(indent) + s; | |
| lineStart = false; | |
| } | |
| output += s; | |
| updateLineCountAndPosFor(s); | |
| } | |
| } | |
| function write(s) { | |
| if (s) | |
| hasTrailingComment = false; | |
| writeText(s); | |
| } | |
| function writeComment(s) { | |
| if (s) | |
| hasTrailingComment = true; | |
| writeText(s); | |
| } | |
| function reset() { | |
| output = ""; | |
| indent = 0; | |
| lineStart = true; | |
| lineCount = 0; | |
| linePos = 0; | |
| hasTrailingComment = false; | |
| } | |
| function rawWrite(s) { | |
| if (s !== undefined) { | |
| output += s; | |
| updateLineCountAndPosFor(s); | |
| hasTrailingComment = false; | |
| } | |
| } | |
| function writeLiteral(s) { | |
| if (s && s.length) { | |
| write(s); | |
| } | |
| } | |
| function writeLine() { | |
| if (!lineStart) { | |
| output += newLine; | |
| lineCount++; | |
| linePos = output.length; | |
| lineStart = true; | |
| hasTrailingComment = false; | |
| } | |
| } | |
| function getTextPosWithWriteLine() { | |
| return lineStart ? output.length : (output.length + newLine.length); | |
| } | |
| reset(); | |
| return { | |
| write: write, | |
| rawWrite: rawWrite, | |
| writeLiteral: writeLiteral, | |
| writeLine: writeLine, | |
| increaseIndent: function () { indent++; }, | |
| decreaseIndent: function () { indent--; }, | |
| getIndent: function () { return indent; }, | |
| getTextPos: function () { return output.length; }, | |
| getLine: function () { return lineCount; }, | |
| getColumn: function () { return lineStart ? indent * getIndentSize() : output.length - linePos; }, | |
| getText: function () { return output; }, | |
| isAtStartOfLine: function () { return lineStart; }, | |
| hasTrailingComment: function () { return hasTrailingComment; }, | |
| hasTrailingWhitespace: function () { return !!output.length && ts_isWhiteSpaceLike(output.charCodeAt(output.length - 1)); }, | |
| clear: reset, | |
| reportInaccessibleThisError: ts_noop, | |
| reportPrivateInBaseOfClassExpression: ts_noop, | |
| reportInaccessibleUniqueSymbolError: ts_noop, | |
| trackSymbol: ts_noop, | |
| writeKeyword: write, | |
| writeOperator: write, | |
| writeParameter: write, | |
| writeProperty: write, | |
| writePunctuation: write, | |
| writeSpace: write, | |
| writeStringLiteral: write, | |
| writeSymbol: function (s, _) { return write(s); }, | |
| writeTrailingSemicolon: write, | |
| writeComment: writeComment, | |
| getTextPosWithWriteLine: getTextPosWithWriteLine | |
| }; | |
| } | |
| ts_createTextWriter = createTextWriter; | |
| function getTrailingSemicolonDeferringWriter(writer) { | |
| var pendingTrailingSemicolon = false; | |
| function commitPendingTrailingSemicolon() { | |
| if (pendingTrailingSemicolon) { | |
| writer.writeTrailingSemicolon(";"); | |
| pendingTrailingSemicolon = false; | |
| } | |
| } | |
| return __assign(__assign({}, writer), { writeTrailingSemicolon: function () { | |
| pendingTrailingSemicolon = true; | |
| }, | |
| writeLiteral: function (s) { | |
| commitPendingTrailingSemicolon(); | |
| writer.writeLiteral(s); | |
| }, | |
| writeStringLiteral: function (s) { | |
| commitPendingTrailingSemicolon(); | |
| writer.writeStringLiteral(s); | |
| }, | |
| writeSymbol: function (s, sym) { | |
| commitPendingTrailingSemicolon(); | |
| writer.writeSymbol(s, sym); | |
| }, | |
| writePunctuation: function (s) { | |
| commitPendingTrailingSemicolon(); | |
| writer.writePunctuation(s); | |
| }, | |
| writeKeyword: function (s) { | |
| commitPendingTrailingSemicolon(); | |
| writer.writeKeyword(s); | |
| }, | |
| writeOperator: function (s) { | |
| commitPendingTrailingSemicolon(); | |
| writer.writeOperator(s); | |
| }, | |
| writeParameter: function (s) { | |
| commitPendingTrailingSemicolon(); | |
| writer.writeParameter(s); | |
| }, | |
| writeSpace: function (s) { | |
| commitPendingTrailingSemicolon(); | |
| writer.writeSpace(s); | |
| }, | |
| writeProperty: function (s) { | |
| commitPendingTrailingSemicolon(); | |
| writer.writeProperty(s); | |
| }, | |
| writeComment: function (s) { | |
| commitPendingTrailingSemicolon(); | |
| writer.writeComment(s); | |
| }, | |
| writeLine: function () { | |
| commitPendingTrailingSemicolon(); | |
| writer.writeLine(); | |
| }, | |
| increaseIndent: function () { | |
| commitPendingTrailingSemicolon(); | |
| writer.increaseIndent(); | |
| }, | |
| decreaseIndent: function () { | |
| commitPendingTrailingSemicolon(); | |
| writer.decreaseIndent(); | |
| } }); | |
| } | |
| ts_getTrailingSemicolonDeferringWriter = getTrailingSemicolonDeferringWriter; | |
| function getResolvedExternalModuleName(host, file, referenceFile) { | |
| return file.moduleName || getExternalModuleNameFromPath(host, file.fileName, referenceFile && referenceFile.fileName); | |
| } | |
| ts_getResolvedExternalModuleName = getResolvedExternalModuleName; | |
| function getExternalModuleNameFromDeclaration(host, resolver, declaration) { | |
| var file = resolver.getExternalModuleFileFromDeclaration(declaration); | |
| if (!file || file.isDeclarationFile) { | |
| return undefined; | |
| } | |
| return getResolvedExternalModuleName(host, file); | |
| } | |
| ts_getExternalModuleNameFromDeclaration = getExternalModuleNameFromDeclaration; | |
| function getExternalModuleNameFromPath(host, fileName, referencePath) { | |
| var getCanonicalFileName = function (f) { return host.getCanonicalFileName(f); }; | |
| var dir = ts_toPath(referencePath ? ts_getDirectoryPath(referencePath) : host.getCommonSourceDirectory(), host.getCurrentDirectory(), getCanonicalFileName); | |
| var filePath = ts_getNormalizedAbsolutePath(fileName, host.getCurrentDirectory()); | |
| var relativePath = ts_getRelativePathToDirectoryOrUrl(dir, filePath, dir, getCanonicalFileName, false); | |
| var extensionless = removeFileExtension(relativePath); | |
| return referencePath ? ts_ensurePathIsNonModuleName(extensionless) : extensionless; | |
| } | |
| ts_getExternalModuleNameFromPath = getExternalModuleNameFromPath; | |
| function getOwnEmitOutputFilePath(fileName, host, extension) { | |
| var compilerOptions = host.getCompilerOptions(); | |
| var emitOutputFilePathWithoutExtension; | |
| if (compilerOptions.outDir) { | |
| emitOutputFilePathWithoutExtension = removeFileExtension(getSourceFilePathInNewDir(fileName, host, compilerOptions.outDir)); | |
| } | |
| else { | |
| emitOutputFilePathWithoutExtension = removeFileExtension(fileName); | |
| } | |
| return emitOutputFilePathWithoutExtension + extension; | |
| } | |
| ts_getOwnEmitOutputFilePath = getOwnEmitOutputFilePath; | |
| function getDeclarationEmitOutputFilePath(fileName, host) { | |
| return getDeclarationEmitOutputFilePathWorker(fileName, host.getCompilerOptions(), host.getCurrentDirectory(), host.getCommonSourceDirectory(), function (f) { return host.getCanonicalFileName(f); }); | |
| } | |
| ts_getDeclarationEmitOutputFilePath = getDeclarationEmitOutputFilePath; | |
| function getDeclarationEmitOutputFilePathWorker(fileName, options, currentDirectory, commonSourceDirectory, getCanonicalFileName) { | |
| var outputDir = options.declarationDir || options.outDir; | |
| var path = outputDir | |
| ? getSourceFilePathInNewDirWorker(fileName, outputDir, currentDirectory, commonSourceDirectory, getCanonicalFileName) | |
| : fileName; | |
| return removeFileExtension(path) + ".d.ts"; | |
| } | |
| ts_getDeclarationEmitOutputFilePathWorker = getDeclarationEmitOutputFilePathWorker; | |
| function getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit) { | |
| var options = host.getCompilerOptions(); | |
| if (options.outFile || options.out) { | |
| var moduleKind = getEmitModuleKind(options); | |
| var moduleEmitEnabled_1 = options.emitDeclarationOnly || moduleKind === ts_ModuleKind.AMD || moduleKind === ts_ModuleKind.System; | |
| return ts_filter(host.getSourceFiles(), function (sourceFile) { | |
| return (moduleEmitEnabled_1 || !ts_isExternalModule(sourceFile)) && | |
| sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit); | |
| }); | |
| } | |
| else { | |
| var sourceFiles = targetSourceFile === undefined ? host.getSourceFiles() : [targetSourceFile]; | |
| return ts_filter(sourceFiles, function (sourceFile) { return sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit); }); | |
| } | |
| } | |
| ts_getSourceFilesToEmit = getSourceFilesToEmit; | |
| function sourceFileMayBeEmitted(sourceFile, host, forceDtsEmit) { | |
| var options = host.getCompilerOptions(); | |
| return !(options.noEmitForJsFiles && isSourceFileJS(sourceFile)) && | |
| !sourceFile.isDeclarationFile && | |
| !host.isSourceFileFromExternalLibrary(sourceFile) && | |
| !(isJsonSourceFile(sourceFile) && host.getResolvedProjectReferenceToRedirect(sourceFile.fileName)) && | |
| (forceDtsEmit || !host.isSourceOfProjectReferenceRedirect(sourceFile.fileName)); | |
| } | |
| ts_sourceFileMayBeEmitted = sourceFileMayBeEmitted; | |
| function getSourceFilePathInNewDir(fileName, host, newDirPath) { | |
| return getSourceFilePathInNewDirWorker(fileName, newDirPath, host.getCurrentDirectory(), host.getCommonSourceDirectory(), function (f) { return host.getCanonicalFileName(f); }); | |
| } | |
| ts_getSourceFilePathInNewDir = getSourceFilePathInNewDir; | |
| function getSourceFilePathInNewDirWorker(fileName, newDirPath, currentDirectory, commonSourceDirectory, getCanonicalFileName) { | |
| var sourceFilePath = ts_getNormalizedAbsolutePath(fileName, currentDirectory); | |
| var isSourceFileInCommonSourceDirectory = getCanonicalFileName(sourceFilePath).indexOf(getCanonicalFileName(commonSourceDirectory)) === 0; | |
| sourceFilePath = isSourceFileInCommonSourceDirectory ? sourceFilePath.substring(commonSourceDirectory.length) : sourceFilePath; | |
| return ts_combinePaths(newDirPath, sourceFilePath); | |
| } | |
| ts_getSourceFilePathInNewDirWorker = getSourceFilePathInNewDirWorker; | |
| function writeFile(host, diagnostics, fileName, data, writeByteOrderMark, sourceFiles) { | |
| host.writeFile(fileName, data, writeByteOrderMark, function (hostErrorMessage) { | |
| diagnostics.add(createCompilerDiagnostic(ts_Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage)); | |
| }, sourceFiles); | |
| } | |
| ts_writeFile = writeFile; | |
| function ensureDirectoriesExist(directoryPath, createDirectory, directoryExists) { | |
| if (directoryPath.length > ts_getRootLength(directoryPath) && !directoryExists(directoryPath)) { | |
| var parentDirectory = ts_getDirectoryPath(directoryPath); | |
| ensureDirectoriesExist(parentDirectory, createDirectory, directoryExists); | |
| createDirectory(directoryPath); | |
| } | |
| } | |
| function writeFileEnsuringDirectories(path, data, writeByteOrderMark, writeFile, createDirectory, directoryExists) { | |
| try { | |
| writeFile(path, data, writeByteOrderMark); | |
| } | |
| catch (_a) { | |
| ensureDirectoriesExist(ts_getDirectoryPath(ts_normalizePath(path)), createDirectory, directoryExists); | |
| writeFile(path, data, writeByteOrderMark); | |
| } | |
| } | |
| ts_writeFileEnsuringDirectories = writeFileEnsuringDirectories; | |
| function getLineOfLocalPosition(currentSourceFile, pos) { | |
| return ts_getLineAndCharacterOfPosition(currentSourceFile, pos).line; | |
| } | |
| ts_getLineOfLocalPosition = getLineOfLocalPosition; | |
| function getLineOfLocalPositionFromLineMap(lineMap, pos) { | |
| return ts_computeLineAndCharacterOfPosition(lineMap, pos).line; | |
| } | |
| ts_getLineOfLocalPositionFromLineMap = getLineOfLocalPositionFromLineMap; | |
| function getFirstConstructorWithBody(node) { | |
| return ts_find(node.members, function (member) { return ts_isConstructorDeclaration(member) && nodeIsPresent(member.body); }); | |
| } | |
| ts_getFirstConstructorWithBody = getFirstConstructorWithBody; | |
| function getSetAccessorValueParameter(accessor) { | |
| if (accessor && accessor.parameters.length > 0) { | |
| var hasThis = accessor.parameters.length === 2 && parameterIsThisKeyword(accessor.parameters[0]); | |
| return accessor.parameters[hasThis ? 1 : 0]; | |
| } | |
| } | |
| ts_getSetAccessorValueParameter = getSetAccessorValueParameter; | |
| function getSetAccessorTypeAnnotationNode(accessor) { | |
| var parameter = getSetAccessorValueParameter(accessor); | |
| return parameter && parameter.type; | |
| } | |
| ts_getSetAccessorTypeAnnotationNode = getSetAccessorTypeAnnotationNode; | |
| function getThisParameter(signature) { | |
| if (signature.parameters.length && !ts_isJSDocSignature(signature)) { | |
| var thisParameter = signature.parameters[0]; | |
| if (parameterIsThisKeyword(thisParameter)) { | |
| return thisParameter; | |
| } | |
| } | |
| } | |
| ts_getThisParameter = getThisParameter; | |
| function parameterIsThisKeyword(parameter) { | |
| return isThisIdentifier(parameter.name); | |
| } | |
| ts_parameterIsThisKeyword = parameterIsThisKeyword; | |
| function isThisIdentifier(node) { | |
| return !!node && node.kind === 75 && identifierIsThisKeyword(node); | |
| } | |
| ts_isThisIdentifier = isThisIdentifier; | |
| function identifierIsThisKeyword(id) { | |
| return id.originalKeywordKind === 104; | |
| } | |
| ts_identifierIsThisKeyword = identifierIsThisKeyword; | |
| function getAllAccessorDeclarations(declarations, accessor) { | |
| var firstAccessor; | |
| var secondAccessor; | |
| var getAccessor; | |
| var setAccessor; | |
| if (hasDynamicName(accessor)) { | |
| firstAccessor = accessor; | |
| if (accessor.kind === 163) { | |
| getAccessor = accessor; | |
| } | |
| else if (accessor.kind === 164) { | |
| setAccessor = accessor; | |
| } | |
| else { | |
| ts_Debug.fail("Accessor has wrong kind"); | |
| } | |
| } | |
| else { | |
| ts_forEach(declarations, function (member) { | |
| if (ts_isAccessor(member) | |
| && hasModifier(member, 32) === hasModifier(accessor, 32)) { | |
| var memberName = getPropertyNameForPropertyNameNode(member.name); | |
| var accessorName = getPropertyNameForPropertyNameNode(accessor.name); | |
| if (memberName === accessorName) { | |
| if (!firstAccessor) { | |
| firstAccessor = member; | |
| } | |
| else if (!secondAccessor) { | |
| secondAccessor = member; | |
| } | |
| if (member.kind === 163 && !getAccessor) { | |
| getAccessor = member; | |
| } | |
| if (member.kind === 164 && !setAccessor) { | |
| setAccessor = member; | |
| } | |
| } | |
| } | |
| }); | |
| } | |
| return { | |
| firstAccessor: firstAccessor, | |
| secondAccessor: secondAccessor, | |
| getAccessor: getAccessor, | |
| setAccessor: setAccessor | |
| }; | |
| } | |
| ts_getAllAccessorDeclarations = getAllAccessorDeclarations; | |
| function getEffectiveTypeAnnotationNode(node) { | |
| if (!isInJSFile(node) && ts_isFunctionDeclaration(node)) | |
| return undefined; | |
| var type = node.type; | |
| if (type || !isInJSFile(node)) | |
| return type; | |
| return ts_isJSDocPropertyLikeTag(node) ? node.typeExpression && node.typeExpression.type : ts_getJSDocType(node); | |
| } | |
| ts_getEffectiveTypeAnnotationNode = getEffectiveTypeAnnotationNode; | |
| function getTypeAnnotationNode(node) { | |
| return node.type; | |
| } | |
| ts_getTypeAnnotationNode = getTypeAnnotationNode; | |
| function getEffectiveReturnTypeNode(node) { | |
| return ts_isJSDocSignature(node) ? | |
| node.type && node.type.typeExpression && node.type.typeExpression.type : | |
| node.type || (isInJSFile(node) ? ts_getJSDocReturnType(node) : undefined); | |
| } | |
| ts_getEffectiveReturnTypeNode = getEffectiveReturnTypeNode; | |
| function getJSDocTypeParameterDeclarations(node) { | |
| return ts_flatMap(ts_getJSDocTags(node), function (tag) { return isNonTypeAliasTemplate(tag) ? tag.typeParameters : undefined; }); | |
| } | |
| ts_getJSDocTypeParameterDeclarations = getJSDocTypeParameterDeclarations; | |
| function isNonTypeAliasTemplate(tag) { | |
| return ts_isJSDocTemplateTag(tag) && !(tag.parent.kind === 303 && tag.parent.tags.some(isJSDocTypeAlias)); | |
| } | |
| function getEffectiveSetAccessorTypeAnnotationNode(node) { | |
| var parameter = getSetAccessorValueParameter(node); | |
| return parameter && getEffectiveTypeAnnotationNode(parameter); | |
| } | |
| ts_getEffectiveSetAccessorTypeAnnotationNode = getEffectiveSetAccessorTypeAnnotationNode; | |
| function emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments) { | |
| emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, node.pos, leadingComments); | |
| } | |
| ts_emitNewLineBeforeLeadingComments = emitNewLineBeforeLeadingComments; | |
| function emitNewLineBeforeLeadingCommentsOfPosition(lineMap, writer, pos, leadingComments) { | |
| if (leadingComments && leadingComments.length && pos !== leadingComments[0].pos && | |
| getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, leadingComments[0].pos)) { | |
| writer.writeLine(); | |
| } | |
| } | |
| ts_emitNewLineBeforeLeadingCommentsOfPosition = emitNewLineBeforeLeadingCommentsOfPosition; | |
| function emitNewLineBeforeLeadingCommentOfPosition(lineMap, writer, pos, commentPos) { | |
| if (pos !== commentPos && | |
| getLineOfLocalPositionFromLineMap(lineMap, pos) !== getLineOfLocalPositionFromLineMap(lineMap, commentPos)) { | |
| writer.writeLine(); | |
| } | |
| } | |
| ts_emitNewLineBeforeLeadingCommentOfPosition = emitNewLineBeforeLeadingCommentOfPosition; | |
| function emitComments(text, lineMap, writer, comments, leadingSeparator, trailingSeparator, newLine, writeComment) { | |
| if (comments && comments.length > 0) { | |
| if (leadingSeparator) { | |
| writer.writeSpace(" "); | |
| } | |
| var emitInterveningSeparator = false; | |
| for (var _i = 0, comments_1 = comments; _i < comments_1.length; _i++) { | |
| var comment = comments_1[_i]; | |
| if (emitInterveningSeparator) { | |
| writer.writeSpace(" "); | |
| emitInterveningSeparator = false; | |
| } | |
| writeComment(text, lineMap, writer, comment.pos, comment.end, newLine); | |
| if (comment.hasTrailingNewLine) { | |
| writer.writeLine(); | |
| } | |
| else { | |
| emitInterveningSeparator = true; | |
| } | |
| } | |
| if (emitInterveningSeparator && trailingSeparator) { | |
| writer.writeSpace(" "); | |
| } | |
| } | |
| } | |
| ts_emitComments = emitComments; | |
| function emitDetachedComments(text, lineMap, writer, writeComment, node, newLine, removeComments) { | |
| var leadingComments; | |
| var currentDetachedCommentInfo; | |
| if (removeComments) { | |
| if (node.pos === 0) { | |
| leadingComments = ts_filter(ts_getLeadingCommentRanges(text, node.pos), isPinnedCommentLocal); | |
| } | |
| } | |
| else { | |
| leadingComments = ts_getLeadingCommentRanges(text, node.pos); | |
| } | |
| if (leadingComments) { | |
| var detachedComments = []; | |
| var lastComment = void 0; | |
| for (var _i = 0, leadingComments_1 = leadingComments; _i < leadingComments_1.length; _i++) { | |
| var comment = leadingComments_1[_i]; | |
| if (lastComment) { | |
| var lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, lastComment.end); | |
| var commentLine = getLineOfLocalPositionFromLineMap(lineMap, comment.pos); | |
| if (commentLine >= lastCommentLine + 2) { | |
| break; | |
| } | |
| } | |
| detachedComments.push(comment); | |
| lastComment = comment; | |
| } | |
| if (detachedComments.length) { | |
| var lastCommentLine = getLineOfLocalPositionFromLineMap(lineMap, ts_last(detachedComments).end); | |
| var nodeLine = getLineOfLocalPositionFromLineMap(lineMap, ts_skipTrivia(text, node.pos)); | |
| if (nodeLine >= lastCommentLine + 2) { | |
| emitNewLineBeforeLeadingComments(lineMap, writer, node, leadingComments); | |
| emitComments(text, lineMap, writer, detachedComments, false, true, newLine, writeComment); | |
| currentDetachedCommentInfo = { nodePos: node.pos, detachedCommentEndPos: ts_last(detachedComments).end }; | |
| } | |
| } | |
| } | |
| return currentDetachedCommentInfo; | |
| function isPinnedCommentLocal(comment) { | |
| return isPinnedComment(text, comment.pos); | |
| } | |
| } | |
| ts_emitDetachedComments = emitDetachedComments; | |
| function writeCommentRange(text, lineMap, writer, commentPos, commentEnd, newLine) { | |
| if (text.charCodeAt(commentPos + 1) === 42) { | |
| var firstCommentLineAndCharacter = ts_computeLineAndCharacterOfPosition(lineMap, commentPos); | |
| var lineCount = lineMap.length; | |
| var firstCommentLineIndent = void 0; | |
| for (var pos = commentPos, currentLine = firstCommentLineAndCharacter.line; pos < commentEnd; currentLine++) { | |
| var nextLineStart = (currentLine + 1) === lineCount | |
| ? text.length + 1 | |
| : lineMap[currentLine + 1]; | |
| if (pos !== commentPos) { | |
| if (firstCommentLineIndent === undefined) { | |
| firstCommentLineIndent = calculateIndent(text, lineMap[firstCommentLineAndCharacter.line], commentPos); | |
| } | |
| var currentWriterIndentSpacing = writer.getIndent() * getIndentSize(); | |
| var spacesToEmit = currentWriterIndentSpacing - firstCommentLineIndent + calculateIndent(text, pos, nextLineStart); | |
| if (spacesToEmit > 0) { | |
| var numberOfSingleSpacesToEmit = spacesToEmit % getIndentSize(); | |
| var indentSizeSpaceString = getIndentString((spacesToEmit - numberOfSingleSpacesToEmit) / getIndentSize()); | |
| writer.rawWrite(indentSizeSpaceString); | |
| while (numberOfSingleSpacesToEmit) { | |
| writer.rawWrite(" "); | |
| numberOfSingleSpacesToEmit--; | |
| } | |
| } | |
| else { | |
| writer.rawWrite(""); | |
| } | |
| } | |
| writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart); | |
| pos = nextLineStart; | |
| } | |
| } | |
| else { | |
| writer.writeComment(text.substring(commentPos, commentEnd)); | |
| } | |
| } | |
| ts_writeCommentRange = writeCommentRange; | |
| function writeTrimmedCurrentLine(text, commentEnd, writer, newLine, pos, nextLineStart) { | |
| var end = Math.min(commentEnd, nextLineStart - 1); | |
| var currentLineText = text.substring(pos, end).replace(/^\s+|\s+$/g, ""); | |
| if (currentLineText) { | |
| writer.writeComment(currentLineText); | |
| if (end !== commentEnd) { | |
| writer.writeLine(); | |
| } | |
| } | |
| else { | |
| writer.rawWrite(newLine); | |
| } | |
| } | |
| function calculateIndent(text, pos, end) { | |
| var currentLineIndent = 0; | |
| for (; pos < end && ts_isWhiteSpaceSingleLine(text.charCodeAt(pos)); pos++) { | |
| if (text.charCodeAt(pos) === 9) { | |
| currentLineIndent += getIndentSize() - (currentLineIndent % getIndentSize()); | |
| } | |
| else { | |
| currentLineIndent++; | |
| } | |
| } | |
| return currentLineIndent; | |
| } | |
| function hasModifiers(node) { | |
| return getModifierFlags(node) !== 0; | |
| } | |
| ts_hasModifiers = hasModifiers; | |
| function hasModifier(node, flags) { | |
| return !!getSelectedModifierFlags(node, flags); | |
| } | |
| ts_hasModifier = hasModifier; | |
| function hasStaticModifier(node) { | |
| return hasModifier(node, 32); | |
| } | |
| ts_hasStaticModifier = hasStaticModifier; | |
| function hasReadonlyModifier(node) { | |
| return hasModifier(node, 64); | |
| } | |
| ts_hasReadonlyModifier = hasReadonlyModifier; | |
| function getSelectedModifierFlags(node, flags) { | |
| return getModifierFlags(node) & flags; | |
| } | |
| ts_getSelectedModifierFlags = getSelectedModifierFlags; | |
| function getModifierFlags(node) { | |
| if (node.modifierFlagsCache & 536870912) { | |
| return node.modifierFlagsCache & ~536870912; | |
| } | |
| var flags = getModifierFlagsNoCache(node); | |
| node.modifierFlagsCache = flags | 536870912; | |
| return flags; | |
| } | |
| ts_getModifierFlags = getModifierFlags; | |
| function getModifierFlagsNoCache(node) { | |
| var flags = 0; | |
| if (node.modifiers) { | |
| for (var _i = 0, _a = node.modifiers; _i < _a.length; _i++) { | |
| var modifier = _a[_i]; | |
| flags |= modifierToFlag(modifier.kind); | |
| } | |
| } | |
| if (isInJSFile(node) && !!node.parent) { | |
| var tags = (ts_getJSDocPublicTag(node) ? 4 : 0) | |
| | (ts_getJSDocPrivateTag(node) ? 8 : 0) | |
| | (ts_getJSDocProtectedTag(node) ? 16 : 0) | |
| | (ts_getJSDocReadonlyTag(node) ? 64 : 0); | |
| flags |= tags; | |
| } | |
| if (node.flags & 4 || (node.kind === 75 && node.isInJSDocNamespace)) { | |
| flags |= 1; | |
| } | |
| return flags; | |
| } | |
| ts_getModifierFlagsNoCache = getModifierFlagsNoCache; | |
| function modifierToFlag(token) { | |
| switch (token) { | |
| case 120: return 32; | |
| case 119: return 4; | |
| case 118: return 16; | |
| case 117: return 8; | |
| case 122: return 128; | |
| case 89: return 1; | |
| case 130: return 2; | |
| case 81: return 2048; | |
| case 84: return 512; | |
| case 126: return 256; | |
| case 138: return 64; | |
| } | |
| return 0; | |
| } | |
| ts_modifierToFlag = modifierToFlag; | |
| function isLogicalOperator(token) { | |
| return token === 56 | |
| || token === 55 | |
| || token === 53; | |
| } | |
| ts_isLogicalOperator = isLogicalOperator; | |
| function isAssignmentOperator(token) { | |
| return token >= 62 && token <= 74; | |
| } | |
| ts_isAssignmentOperator = isAssignmentOperator; | |
| function tryGetClassExtendingExpressionWithTypeArguments(node) { | |
| var cls = tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node); | |
| return cls && !cls.isImplements ? cls.class : undefined; | |
| } | |
| ts_tryGetClassExtendingExpressionWithTypeArguments = tryGetClassExtendingExpressionWithTypeArguments; | |
| function tryGetClassImplementingOrExtendingExpressionWithTypeArguments(node) { | |
| return ts_isExpressionWithTypeArguments(node) | |
| && ts_isHeritageClause(node.parent) | |
| && ts_isClassLike(node.parent.parent) | |
| ? { class: node.parent.parent, isImplements: node.parent.token === 113 } | |
| : undefined; | |
| } | |
| ts_tryGetClassImplementingOrExtendingExpressionWithTypeArguments = tryGetClassImplementingOrExtendingExpressionWithTypeArguments; | |
| function isAssignmentExpression(node, excludeCompoundAssignment) { | |
| return ts_isBinaryExpression(node) | |
| && (excludeCompoundAssignment | |
| ? node.operatorToken.kind === 62 | |
| : isAssignmentOperator(node.operatorToken.kind)) | |
| && ts_isLeftHandSideExpression(node.left); | |
| } | |
| ts_isAssignmentExpression = isAssignmentExpression; | |
| function isDestructuringAssignment(node) { | |
| if (isAssignmentExpression(node, true)) { | |
| var kind = node.left.kind; | |
| return kind === 193 | |
| || kind === 192; | |
| } | |
| return false; | |
| } | |
| ts_isDestructuringAssignment = isDestructuringAssignment; | |
| function isExpressionWithTypeArgumentsInClassExtendsClause(node) { | |
| return tryGetClassExtendingExpressionWithTypeArguments(node) !== undefined; | |
| } | |
| ts_isExpressionWithTypeArgumentsInClassExtendsClause = isExpressionWithTypeArgumentsInClassExtendsClause; | |
| function isEntityNameExpression(node) { | |
| return node.kind === 75 || isPropertyAccessEntityNameExpression(node); | |
| } | |
| ts_isEntityNameExpression = isEntityNameExpression; | |
| function getFirstIdentifier(node) { | |
| switch (node.kind) { | |
| case 75: | |
| return node; | |
| case 153: | |
| do { | |
| node = node.left; | |
| } while (node.kind !== 75); | |
| return node; | |
| case 194: | |
| do { | |
| node = node.expression; | |
| } while (node.kind !== 75); | |
| return node; | |
| } | |
| } | |
| ts_getFirstIdentifier = getFirstIdentifier; | |
| function isDottedName(node) { | |
| return node.kind === 75 || node.kind === 104 || node.kind === 102 || | |
| node.kind === 194 && isDottedName(node.expression) || | |
| node.kind === 200 && isDottedName(node.expression); | |
| } | |
| ts_isDottedName = isDottedName; | |
| function isPropertyAccessEntityNameExpression(node) { | |
| return ts_isPropertyAccessExpression(node) && isEntityNameExpression(node.expression); | |
| } | |
| ts_isPropertyAccessEntityNameExpression = isPropertyAccessEntityNameExpression; | |
| function tryGetPropertyAccessOrIdentifierToString(expr) { | |
| if (ts_isPropertyAccessExpression(expr)) { | |
| var baseStr = tryGetPropertyAccessOrIdentifierToString(expr.expression); | |
| if (baseStr !== undefined) { | |
| return baseStr + "." + expr.name; | |
| } | |
| } | |
| else if (ts_isIdentifier(expr)) { | |
| return ts_unescapeLeadingUnderscores(expr.escapedText); | |
| } | |
| return undefined; | |
| } | |
| ts_tryGetPropertyAccessOrIdentifierToString = tryGetPropertyAccessOrIdentifierToString; | |
| function isPrototypeAccess(node) { | |
| return isBindableStaticAccessExpression(node) && getElementOrPropertyAccessName(node) === "prototype"; | |
| } | |
| ts_isPrototypeAccess = isPrototypeAccess; | |
| function isRightSideOfQualifiedNameOrPropertyAccess(node) { | |
| return (node.parent.kind === 153 && node.parent.right === node) || | |
| (node.parent.kind === 194 && node.parent.name === node); | |
| } | |
| ts_isRightSideOfQualifiedNameOrPropertyAccess = isRightSideOfQualifiedNameOrPropertyAccess; | |
| function isEmptyObjectLiteral(expression) { | |
| return expression.kind === 193 && | |
| expression.properties.length === 0; | |
| } | |
| ts_isEmptyObjectLiteral = isEmptyObjectLiteral; | |
| function isEmptyArrayLiteral(expression) { | |
| return expression.kind === 192 && | |
| expression.elements.length === 0; | |
| } | |
| ts_isEmptyArrayLiteral = isEmptyArrayLiteral; | |
| function getLocalSymbolForExportDefault(symbol) { | |
| return isExportDefaultSymbol(symbol) ? symbol.declarations[0].localSymbol : undefined; | |
| } | |
| ts_getLocalSymbolForExportDefault = getLocalSymbolForExportDefault; | |
| function isExportDefaultSymbol(symbol) { | |
| return symbol && ts_length(symbol.declarations) > 0 && hasModifier(symbol.declarations[0], 512); | |
| } | |
| function tryExtractTSExtension(fileName) { | |
| return ts_find(ts_supportedTSExtensionsForExtractExtension, function (extension) { return ts_fileExtensionIs(fileName, extension); }); | |
| } | |
| ts_tryExtractTSExtension = tryExtractTSExtension; | |
| function getExpandedCharCodes(input) { | |
| var output = []; | |
| var length = input.length; | |
| for (var i = 0; i < length; i++) { | |
| var charCode = input.charCodeAt(i); | |
| if (charCode < 0x80) { | |
| output.push(charCode); | |
| } | |
| else if (charCode < 0x800) { | |
| output.push((charCode >> 6) | 192); | |
| output.push((charCode & 63) | 128); | |
| } | |
| else if (charCode < 0x10000) { | |
| output.push((charCode >> 12) | 224); | |
| output.push(((charCode >> 6) & 63) | 128); | |
| output.push((charCode & 63) | 128); | |
| } | |
| else if (charCode < 0x20000) { | |
| output.push((charCode >> 18) | 240); | |
| output.push(((charCode >> 12) & 63) | 128); | |
| output.push(((charCode >> 6) & 63) | 128); | |
| output.push((charCode & 63) | 128); | |
| } | |
| else { | |
| ts_Debug.assert(false, "Unexpected code point"); | |
| } | |
| } | |
| return output; | |
| } | |
| var base64Digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; | |
| function convertToBase64(input) { | |
| var result = ""; | |
| var charCodes = getExpandedCharCodes(input); | |
| var i = 0; | |
| var length = charCodes.length; | |
| var byte1, byte2, byte3, byte4; | |
| while (i < length) { | |
| byte1 = charCodes[i] >> 2; | |
| byte2 = (charCodes[i] & 3) << 4 | charCodes[i + 1] >> 4; | |
| byte3 = (charCodes[i + 1] & 15) << 2 | charCodes[i + 2] >> 6; | |
| byte4 = charCodes[i + 2] & 63; | |
| if (i + 1 >= length) { | |
| byte3 = byte4 = 64; | |
| } | |
| else if (i + 2 >= length) { | |
| byte4 = 64; | |
| } | |
| result += base64Digits.charAt(byte1) + base64Digits.charAt(byte2) + base64Digits.charAt(byte3) + base64Digits.charAt(byte4); | |
| i += 3; | |
| } | |
| return result; | |
| } | |
| ts_convertToBase64 = convertToBase64; | |
| function getStringFromExpandedCharCodes(codes) { | |
| var output = ""; | |
| var i = 0; | |
| var length = codes.length; | |
| while (i < length) { | |
| var charCode = codes[i]; | |
| if (charCode < 0x80) { | |
| output += String.fromCharCode(charCode); | |
| i++; | |
| } | |
| else if ((charCode & 192) === 192) { | |
| var value = charCode & 63; | |
| i++; | |
| var nextCode = codes[i]; | |
| while ((nextCode & 192) === 128) { | |
| value = (value << 6) | (nextCode & 63); | |
| i++; | |
| nextCode = codes[i]; | |
| } | |
| output += String.fromCharCode(value); | |
| } | |
| else { | |
| output += String.fromCharCode(charCode); | |
| i++; | |
| } | |
| } | |
| return output; | |
| } | |
| function base64encode(host, input) { | |
| if (host && host.base64encode) { | |
| return host.base64encode(input); | |
| } | |
| return convertToBase64(input); | |
| } | |
| ts_base64encode = base64encode; | |
| function base64decode(host, input) { | |
| if (host && host.base64decode) { | |
| return host.base64decode(input); | |
| } | |
| var length = input.length; | |
| var expandedCharCodes = []; | |
| var i = 0; | |
| while (i < length) { | |
| if (input.charCodeAt(i) === base64Digits.charCodeAt(64)) { | |
| break; | |
| } | |
| var ch1 = base64Digits.indexOf(input[i]); | |
| var ch2 = base64Digits.indexOf(input[i + 1]); | |
| var ch3 = base64Digits.indexOf(input[i + 2]); | |
| var ch4 = base64Digits.indexOf(input[i + 3]); | |
| var code1 = ((ch1 & 63) << 2) | ((ch2 >> 4) & 3); | |
| var code2 = ((ch2 & 15) << 4) | ((ch3 >> 2) & 15); | |
| var code3 = ((ch3 & 3) << 6) | (ch4 & 63); | |
| if (code2 === 0 && ch3 !== 0) { | |
| expandedCharCodes.push(code1); | |
| } | |
| else if (code3 === 0 && ch4 !== 0) { | |
| expandedCharCodes.push(code1, code2); | |
| } | |
| else { | |
| expandedCharCodes.push(code1, code2, code3); | |
| } | |
| i += 4; | |
| } | |
| return getStringFromExpandedCharCodes(expandedCharCodes); | |
| } | |
| ts_base64decode = base64decode; | |
| function readJson(path, host) { | |
| try { | |
| var jsonText = host.readFile(path); | |
| if (!jsonText) | |
| return {}; | |
| var result = ts_parseConfigFileTextToJson(path, jsonText); | |
| if (result.error) { | |
| return {}; | |
| } | |
| return result.config; | |
| } | |
| catch (e) { | |
| return {}; | |
| } | |
| } | |
| ts_readJson = readJson; | |
| function directoryProbablyExists(directoryName, host) { | |
| return !host.directoryExists || host.directoryExists(directoryName); | |
| } | |
| ts_directoryProbablyExists = directoryProbablyExists; | |
| var carriageReturnLineFeed = "\r\n"; | |
| var lineFeed = "\n"; | |
| function getNewLineCharacter(options, getNewLine) { | |
| switch (options.newLine) { | |
| case 0: | |
| return carriageReturnLineFeed; | |
| case 1: | |
| return lineFeed; | |
| } | |
| return getNewLine ? getNewLine() : ts_sys ? ts_sys.newLine : carriageReturnLineFeed; | |
| } | |
| ts_getNewLineCharacter = getNewLineCharacter; | |
| function createRange(pos, end) { | |
| if (end === void 0) { end = pos; } | |
| ts_Debug.assert(end >= pos || end === -1); | |
| return { pos: pos, end: end }; | |
| } | |
| ts_createRange = createRange; | |
| function moveRangeEnd(range, end) { | |
| return createRange(range.pos, end); | |
| } | |
| ts_moveRangeEnd = moveRangeEnd; | |
| function moveRangePos(range, pos) { | |
| return createRange(pos, range.end); | |
| } | |
| ts_moveRangePos = moveRangePos; | |
| function moveRangePastDecorators(node) { | |
| return node.decorators && node.decorators.length > 0 | |
| ? moveRangePos(node, node.decorators.end) | |
| : node; | |
| } | |
| ts_moveRangePastDecorators = moveRangePastDecorators; | |
| function moveRangePastModifiers(node) { | |
| return node.modifiers && node.modifiers.length > 0 | |
| ? moveRangePos(node, node.modifiers.end) | |
| : moveRangePastDecorators(node); | |
| } | |
| ts_moveRangePastModifiers = moveRangePastModifiers; | |
| function isCollapsedRange(range) { | |
| return range.pos === range.end; | |
| } | |
| ts_isCollapsedRange = isCollapsedRange; | |
| function createTokenRange(pos, token) { | |
| return createRange(pos, pos + ts_tokenToString(token).length); | |
| } | |
| ts_createTokenRange = createTokenRange; | |
| function rangeIsOnSingleLine(range, sourceFile) { | |
| return rangeStartIsOnSameLineAsRangeEnd(range, range, sourceFile); | |
| } | |
| ts_rangeIsOnSingleLine = rangeIsOnSingleLine; | |
| function rangeStartPositionsAreOnSameLine(range1, range2, sourceFile) { | |
| return positionsAreOnSameLine(getStartPositionOfRange(range1, sourceFile), getStartPositionOfRange(range2, sourceFile), sourceFile); | |
| } | |
| ts_rangeStartPositionsAreOnSameLine = rangeStartPositionsAreOnSameLine; | |
| function rangeEndPositionsAreOnSameLine(range1, range2, sourceFile) { | |
| return positionsAreOnSameLine(range1.end, range2.end, sourceFile); | |
| } | |
| ts_rangeEndPositionsAreOnSameLine = rangeEndPositionsAreOnSameLine; | |
| function rangeStartIsOnSameLineAsRangeEnd(range1, range2, sourceFile) { | |
| return positionsAreOnSameLine(getStartPositionOfRange(range1, sourceFile), range2.end, sourceFile); | |
| } | |
| ts_rangeStartIsOnSameLineAsRangeEnd = rangeStartIsOnSameLineAsRangeEnd; | |
| function rangeEndIsOnSameLineAsRangeStart(range1, range2, sourceFile) { | |
| return positionsAreOnSameLine(range1.end, getStartPositionOfRange(range2, sourceFile), sourceFile); | |
| } | |
| ts_rangeEndIsOnSameLineAsRangeStart = rangeEndIsOnSameLineAsRangeStart; | |
| function isNodeArrayMultiLine(list, sourceFile) { | |
| return !positionsAreOnSameLine(list.pos, list.end, sourceFile); | |
| } | |
| ts_isNodeArrayMultiLine = isNodeArrayMultiLine; | |
| function positionsAreOnSameLine(pos1, pos2, sourceFile) { | |
| return pos1 === pos2 || | |
| getLineOfLocalPosition(sourceFile, pos1) === getLineOfLocalPosition(sourceFile, pos2); | |
| } | |
| ts_positionsAreOnSameLine = positionsAreOnSameLine; | |
| function getStartPositionOfRange(range, sourceFile) { | |
| return positionIsSynthesized(range.pos) ? -1 : ts_skipTrivia(sourceFile.text, range.pos); | |
| } | |
| ts_getStartPositionOfRange = getStartPositionOfRange; | |
| function isDeclarationNameOfEnumOrNamespace(node) { | |
| var parseNode = ts_getParseTreeNode(node); | |
| if (parseNode) { | |
| switch (parseNode.parent.kind) { | |
| case 248: | |
| case 249: | |
| return parseNode === parseNode.parent.name; | |
| } | |
| } | |
| return false; | |
| } | |
| ts_isDeclarationNameOfEnumOrNamespace = isDeclarationNameOfEnumOrNamespace; | |
| function getInitializedVariables(node) { | |
| return ts_filter(node.declarations, isInitializedVariable); | |
| } | |
| ts_getInitializedVariables = getInitializedVariables; | |
| function isInitializedVariable(node) { | |
| return node.initializer !== undefined; | |
| } | |
| function isWatchSet(options) { | |
| return options.watch && options.hasOwnProperty("watch"); | |
| } | |
| ts_isWatchSet = isWatchSet; | |
| function closeFileWatcher(watcher) { | |
| watcher.close(); | |
| } | |
| ts_closeFileWatcher = closeFileWatcher; | |
| function getCheckFlags(symbol) { | |
| return symbol.flags & 33554432 ? symbol.checkFlags : 0; | |
| } | |
| ts_getCheckFlags = getCheckFlags; | |
| function getDeclarationModifierFlagsFromSymbol(s) { | |
| if (s.valueDeclaration) { | |
| var flags = ts_getCombinedModifierFlags(s.valueDeclaration); | |
| return s.parent && s.parent.flags & 32 ? flags : flags & ~28; | |
| } | |
| if (getCheckFlags(s) & 6) { | |
| var checkFlags = s.checkFlags; | |
| var accessModifier = checkFlags & 1024 ? 8 : | |
| checkFlags & 256 ? 4 : | |
| 16; | |
| var staticModifier = checkFlags & 2048 ? 32 : 0; | |
| return accessModifier | staticModifier; | |
| } | |
| if (s.flags & 4194304) { | |
| return 4 | 32; | |
| } | |
| return 0; | |
| } | |
| ts_getDeclarationModifierFlagsFromSymbol = getDeclarationModifierFlagsFromSymbol; | |
| function skipAlias(symbol, checker) { | |
| return symbol.flags & 2097152 ? checker.getAliasedSymbol(symbol) : symbol; | |
| } | |
| ts_skipAlias = skipAlias; | |
| function getCombinedLocalAndExportSymbolFlags(symbol) { | |
| return symbol.exportSymbol ? symbol.exportSymbol.flags | symbol.flags : symbol.flags; | |
| } | |
| ts_getCombinedLocalAndExportSymbolFlags = getCombinedLocalAndExportSymbolFlags; | |
| function isWriteOnlyAccess(node) { | |
| return accessKind(node) === 1; | |
| } | |
| ts_isWriteOnlyAccess = isWriteOnlyAccess; | |
| function isWriteAccess(node) { | |
| return accessKind(node) !== 0; | |
| } | |
| ts_isWriteAccess = isWriteAccess; | |
| function accessKind(node) { | |
| var parent = node.parent; | |
| if (!parent) | |
| return 0; | |
| switch (parent.kind) { | |
| case 200: | |
| return accessKind(parent); | |
| case 208: | |
| case 207: | |
| var operator = parent.operator; | |
| return operator === 45 || operator === 46 ? writeOrReadWrite() : 0; | |
| case 209: | |
| var _a = parent, left = _a.left, operatorToken = _a.operatorToken; | |
| return left === node && isAssignmentOperator(operatorToken.kind) ? | |
| operatorToken.kind === 62 ? 1 : writeOrReadWrite() | |
| : 0; | |
| case 194: | |
| return parent.name !== node ? 0 : accessKind(parent); | |
| case 281: { | |
| var parentAccess = accessKind(parent.parent); | |
| return node === parent.name ? reverseAccessKind(parentAccess) : parentAccess; | |
| } | |
| case 282: | |
| return node === parent.objectAssignmentInitializer ? 0 : accessKind(parent.parent); | |
| case 192: | |
| return accessKind(parent); | |
| default: | |
| return 0; | |
| } | |
| function writeOrReadWrite() { | |
| return parent.parent && skipParenthesesUp(parent.parent).kind === 226 ? 1 : 2; | |
| } | |
| } | |
| function reverseAccessKind(a) { | |
| switch (a) { | |
| case 0: | |
| return 1; | |
| case 1: | |
| return 0; | |
| case 2: | |
| return 2; | |
| default: | |
| return ts_Debug.assertNever(a); | |
| } | |
| } | |
| function compareDataObjects(dst, src) { | |
| if (!dst || !src || Object.keys(dst).length !== Object.keys(src).length) { | |
| return false; | |
| } | |
| for (var e in dst) { | |
| if (typeof dst[e] === "object") { | |
| if (!compareDataObjects(dst[e], src[e])) { | |
| return false; | |
| } | |
| } | |
| else if (typeof dst[e] !== "function") { | |
| if (dst[e] !== src[e]) { | |
| return false; | |
| } | |
| } | |
| } | |
| return true; | |
| } | |
| ts_compareDataObjects = compareDataObjects; | |
| function clearMap(map, onDeleteValue) { | |
| map.forEach(onDeleteValue); | |
| map.clear(); | |
| } | |
| ts_clearMap = clearMap; | |
| function mutateMapSkippingNewValues(map, newMap, options) { | |
| var onDeleteValue = options.onDeleteValue, onExistingValue = options.onExistingValue; | |
| map.forEach(function (existingValue, key) { | |
| var valueInNewMap = newMap.get(key); | |
| if (valueInNewMap === undefined) { | |
| map.delete(key); | |
| onDeleteValue(existingValue, key); | |
| } | |
| else if (onExistingValue) { | |
| onExistingValue(existingValue, valueInNewMap, key); | |
| } | |
| }); | |
| } | |
| ts_mutateMapSkippingNewValues = mutateMapSkippingNewValues; | |
| function mutateMap(map, newMap, options) { | |
| mutateMapSkippingNewValues(map, newMap, options); | |
| var createNewValue = options.createNewValue; | |
| newMap.forEach(function (valueInNewMap, key) { | |
| if (!map.has(key)) { | |
| map.set(key, createNewValue(key, valueInNewMap)); | |
| } | |
| }); | |
| } | |
| ts_mutateMap = mutateMap; | |
| function isAbstractConstructorType(type) { | |
| return !!(getObjectFlags(type) & 16) && !!type.symbol && isAbstractConstructorSymbol(type.symbol); | |
| } | |
| ts_isAbstractConstructorType = isAbstractConstructorType; | |
| function isAbstractConstructorSymbol(symbol) { | |
| if (symbol.flags & 32) { | |
| var declaration = getClassLikeDeclarationOfSymbol(symbol); | |
| return !!declaration && hasModifier(declaration, 128); | |
| } | |
| return false; | |
| } | |
| ts_isAbstractConstructorSymbol = isAbstractConstructorSymbol; | |
| function getClassLikeDeclarationOfSymbol(symbol) { | |
| return ts_find(symbol.declarations, ts_isClassLike); | |
| } | |
| ts_getClassLikeDeclarationOfSymbol = getClassLikeDeclarationOfSymbol; | |
| function getObjectFlags(type) { | |
| return type.flags & 3899393 ? type.objectFlags : 0; | |
| } | |
| ts_getObjectFlags = getObjectFlags; | |
| function typeHasCallOrConstructSignatures(type, checker) { | |
| return checker.getSignaturesOfType(type, 0).length !== 0 || checker.getSignaturesOfType(type, 1).length !== 0; | |
| } | |
| ts_typeHasCallOrConstructSignatures = typeHasCallOrConstructSignatures; | |
| function forSomeAncestorDirectory(directory, callback) { | |
| return !!ts_forEachAncestorDirectory(directory, function (d) { return callback(d) ? true : undefined; }); | |
| } | |
| ts_forSomeAncestorDirectory = forSomeAncestorDirectory; | |
| function isUMDExportSymbol(symbol) { | |
| return !!symbol && !!symbol.declarations && !!symbol.declarations[0] && ts_isNamespaceExportDeclaration(symbol.declarations[0]); | |
| } | |
| ts_isUMDExportSymbol = isUMDExportSymbol; | |
| function showModuleSpecifier(_a) { | |
| var moduleSpecifier = _a.moduleSpecifier; | |
| return ts_isStringLiteral(moduleSpecifier) ? moduleSpecifier.text : getTextOfNode(moduleSpecifier); | |
| } | |
| ts_showModuleSpecifier = showModuleSpecifier; | |
| function getLastChild(node) { | |
| var lastChild; | |
| ts_forEachChild(node, function (child) { | |
| if (nodeIsPresent(child)) | |
| lastChild = child; | |
| }, function (children) { | |
| for (var i = children.length - 1; i >= 0; i--) { | |
| if (nodeIsPresent(children[i])) { | |
| lastChild = children[i]; | |
| break; | |
| } | |
| } | |
| }); | |
| return lastChild; | |
| } | |
| ts_getLastChild = getLastChild; | |
| function addToSeen(seen, key, value) { | |
| if (value === void 0) { value = true; } | |
| key = String(key); | |
| if (seen.has(key)) { | |
| return false; | |
| } | |
| seen.set(key, value); | |
| return true; | |
| } | |
| ts_addToSeen = addToSeen; | |
| function isObjectTypeDeclaration(node) { | |
| return ts_isClassLike(node) || ts_isInterfaceDeclaration(node) || ts_isTypeLiteralNode(node); | |
| } | |
| ts_isObjectTypeDeclaration = isObjectTypeDeclaration; | |
| function isTypeNodeKind(kind) { | |
| return (kind >= 168 && kind <= 188) | |
| || kind === 125 | |
| || kind === 148 | |
| || kind === 140 | |
| || kind === 151 | |
| || kind === 141 | |
| || kind === 128 | |
| || kind === 143 | |
| || kind === 144 | |
| || kind === 104 | |
| || kind === 110 | |
| || kind === 146 | |
| || kind === 100 | |
| || kind === 137 | |
| || kind === 216 | |
| || kind === 295 | |
| || kind === 296 | |
| || kind === 297 | |
| || kind === 298 | |
| || kind === 299 | |
| || kind === 300 | |
| || kind === 301; | |
| } | |
| ts_isTypeNodeKind = isTypeNodeKind; | |
| function isAccessExpression(node) { | |
| return node.kind === 194 || node.kind === 195; | |
| } | |
| ts_isAccessExpression = isAccessExpression; | |
| function isBundleFileTextLike(section) { | |
| switch (section.kind) { | |
| case "text": | |
| case "internal": | |
| return true; | |
| default: | |
| return false; | |
| } | |
| } | |
| ts_isBundleFileTextLike = isBundleFileTextLike; | |
| function getDotOrQuestionDotToken(node) { | |
| return node.questionDotToken || ts_createNode(24, node.expression.end, node.name.pos); | |
| } | |
| ts_getDotOrQuestionDotToken = getDotOrQuestionDotToken; | |
| function isNamedImportsOrExports(node) { | |
| return node.kind === 257 || node.kind === 261; | |
| } | |
| ts_isNamedImportsOrExports = isNamedImportsOrExports; | |
| function Symbol(flags, name) { | |
| this.flags = flags; | |
| this.escapedName = name; | |
| this.declarations = undefined; | |
| this.valueDeclaration = undefined; | |
| this.id = undefined; | |
| this.mergeId = undefined; | |
| this.parent = undefined; | |
| } | |
| function Type(checker, flags) { | |
| this.flags = flags; | |
| if (ts_Debug.isDebugging) { | |
| this.checker = checker; | |
| } | |
| } | |
| function Signature(checker, flags) { | |
| this.flags = flags; | |
| if (ts_Debug.isDebugging) { | |
| this.checker = checker; | |
| } | |
| } | |
| function Node(kind, pos, end) { | |
| this.pos = pos; | |
| this.end = end; | |
| this.kind = kind; | |
| this.id = 0; | |
| this.flags = 0; | |
| this.modifierFlagsCache = 0; | |
| this.transformFlags = 0; | |
| this.parent = undefined; | |
| this.original = undefined; | |
| } | |
| function SourceMapSource(fileName, text, skipTrivia) { | |
| this.fileName = fileName; | |
| this.text = text; | |
| this.skipTrivia = skipTrivia || (function (pos) { return pos; }); | |
| } | |
| ts_objectAllocator = { | |
| getNodeConstructor: function () { return Node; }, | |
| getTokenConstructor: function () { return Node; }, | |
| getIdentifierConstructor: function () { return Node; }, | |
| getPrivateIdentifierConstructor: function () { return Node; }, | |
| getSourceFileConstructor: function () { return Node; }, | |
| getSymbolConstructor: function () { return Symbol; }, | |
| getTypeConstructor: function () { return Type; }, | |
| getSignatureConstructor: function () { return Signature; }, | |
| getSourceMapSourceConstructor: function () { return SourceMapSource; }, | |
| }; | |
| function setObjectAllocator(alloc) { | |
| ts_objectAllocator = alloc; | |
| } | |
| ts_setObjectAllocator = setObjectAllocator; | |
| function formatStringFromArgs(text, args, baseIndex) { | |
| if (baseIndex === void 0) { baseIndex = 0; } | |
| return text.replace(/{(\d+)}/g, function (_match, index) { return "" + ts_Debug.assertDefined(args[+index + baseIndex]); }); | |
| } | |
| ts_formatStringFromArgs = formatStringFromArgs; | |
| function setLocalizedDiagnosticMessages(messages) { | |
| ts_localizedDiagnosticMessages = messages; | |
| } | |
| ts_setLocalizedDiagnosticMessages = setLocalizedDiagnosticMessages; | |
| function getLocaleSpecificMessage(message) { | |
| return ts_localizedDiagnosticMessages && ts_localizedDiagnosticMessages[message.key] || message.message; | |
| } | |
| ts_getLocaleSpecificMessage = getLocaleSpecificMessage; | |
| function createFileDiagnostic(file, start, length, message) { | |
| ts_Debug.assertGreaterThanOrEqual(start, 0); | |
| ts_Debug.assertGreaterThanOrEqual(length, 0); | |
| if (file) { | |
| ts_Debug.assertLessThanOrEqual(start, file.text.length); | |
| ts_Debug.assertLessThanOrEqual(start + length, file.text.length); | |
| } | |
| var text = getLocaleSpecificMessage(message); | |
| if (arguments.length > 4) { | |
| text = formatStringFromArgs(text, arguments, 4); | |
| } | |
| return { | |
| file: file, | |
| start: start, | |
| length: length, | |
| messageText: text, | |
| category: message.category, | |
| code: message.code, | |
| reportsUnnecessary: message.reportsUnnecessary, | |
| }; | |
| } | |
| ts_createFileDiagnostic = createFileDiagnostic; | |
| function formatMessage(_dummy, message) { | |
| var text = getLo |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment