@tslite/checker 1.9.0 → 1.12.0

package/dist/types.js

@@ -0,0 +1,355 @@
+export var JsxFlags;
+(function (JsxFlags) {
+    JsxFlags[JsxFlags["None"] = 0] = "None";
+    /** An element from a named property of the JSX.IntrinsicElements interface */
+    JsxFlags[JsxFlags["IntrinsicNamedElement"] = 1] = "IntrinsicNamedElement";
+    /** An element inferred from the string index signature of the JSX.IntrinsicElements interface */
+    JsxFlags[JsxFlags["IntrinsicIndexedElement"] = 2] = "IntrinsicIndexedElement";
+    JsxFlags[JsxFlags["IntrinsicElement"] = 3] = "IntrinsicElement";
+})(JsxFlags || (JsxFlags = {}));
+export var RelationComparisonResult;
+(function (RelationComparisonResult) {
+    RelationComparisonResult[RelationComparisonResult["None"] = 0] = "None";
+    RelationComparisonResult[RelationComparisonResult["Succeeded"] = 1] = "Succeeded";
+    RelationComparisonResult[RelationComparisonResult["Failed"] = 2] = "Failed";
+    RelationComparisonResult[RelationComparisonResult["Reported"] = 4] = "Reported";
+    RelationComparisonResult[RelationComparisonResult["ReportsUnmeasurable"] = 8] = "ReportsUnmeasurable";
+    RelationComparisonResult[RelationComparisonResult["ReportsUnreliable"] = 16] = "ReportsUnreliable";
+    RelationComparisonResult[RelationComparisonResult["ReportsMask"] = 24] = "ReportsMask";
+})(RelationComparisonResult || (RelationComparisonResult = {}));
+export class OperationCanceledException {
+}
+export var UnionReduction;
+(function (UnionReduction) {
+    UnionReduction[UnionReduction["None"] = 0] = "None";
+    UnionReduction[UnionReduction["Literal"] = 1] = "Literal";
+    UnionReduction[UnionReduction["Subtype"] = 2] = "Subtype";
+})(UnionReduction || (UnionReduction = {}));
+export var ContextFlags;
+(function (ContextFlags) {
+    ContextFlags[ContextFlags["None"] = 0] = "None";
+    ContextFlags[ContextFlags["Signature"] = 1] = "Signature";
+    ContextFlags[ContextFlags["NoConstraints"] = 2] = "NoConstraints";
+    ContextFlags[ContextFlags["Completions"] = 4] = "Completions";
+})(ContextFlags || (ContextFlags = {}));
+// NOTE: If modifying this enum, must modify `TypeFormatFlags` too!
+export var NodeBuilderFlags;
+(function (NodeBuilderFlags) {
+    NodeBuilderFlags[NodeBuilderFlags["None"] = 0] = "None";
+    // Options
+    NodeBuilderFlags[NodeBuilderFlags["NoTruncation"] = 1] = "NoTruncation";
+    NodeBuilderFlags[NodeBuilderFlags["WriteArrayAsGenericType"] = 2] = "WriteArrayAsGenericType";
+    NodeBuilderFlags[NodeBuilderFlags["GenerateNamesForShadowedTypeParams"] = 4] = "GenerateNamesForShadowedTypeParams";
+    NodeBuilderFlags[NodeBuilderFlags["UseStructuralFallback"] = 8] = "UseStructuralFallback";
+    NodeBuilderFlags[NodeBuilderFlags["ForbidIndexedAccessSymbolReferences"] = 16] = "ForbidIndexedAccessSymbolReferences";
+    NodeBuilderFlags[NodeBuilderFlags["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature";
+    NodeBuilderFlags[NodeBuilderFlags["UseFullyQualifiedType"] = 64] = "UseFullyQualifiedType";
+    NodeBuilderFlags[NodeBuilderFlags["UseOnlyExternalAliasing"] = 128] = "UseOnlyExternalAliasing";
+    NodeBuilderFlags[NodeBuilderFlags["SuppressAnyReturnType"] = 256] = "SuppressAnyReturnType";
+    NodeBuilderFlags[NodeBuilderFlags["WriteTypeParametersInQualifiedName"] = 512] = "WriteTypeParametersInQualifiedName";
+    NodeBuilderFlags[NodeBuilderFlags["MultilineObjectLiterals"] = 1024] = "MultilineObjectLiterals";
+    NodeBuilderFlags[NodeBuilderFlags["UseTypeOfFunction"] = 4096] = "UseTypeOfFunction";
+    NodeBuilderFlags[NodeBuilderFlags["OmitParameterModifiers"] = 8192] = "OmitParameterModifiers";
+    NodeBuilderFlags[NodeBuilderFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
+    NodeBuilderFlags[NodeBuilderFlags["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType";
+    NodeBuilderFlags[NodeBuilderFlags["NoTypeReduction"] = 536870912] = "NoTypeReduction";
+    // Error handling
+    NodeBuilderFlags[NodeBuilderFlags["AllowQualifedNameInPlaceOfIdentifier"] = 65536] = "AllowQualifedNameInPlaceOfIdentifier";
+    NodeBuilderFlags[NodeBuilderFlags["AllowAnonymousIdentifier"] = 131072] = "AllowAnonymousIdentifier";
+    NodeBuilderFlags[NodeBuilderFlags["AllowEmptyUnionOrIntersection"] = 262144] = "AllowEmptyUnionOrIntersection";
+    NodeBuilderFlags[NodeBuilderFlags["AllowEmptyTuple"] = 524288] = "AllowEmptyTuple";
+    NodeBuilderFlags[NodeBuilderFlags["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType";
+    NodeBuilderFlags[NodeBuilderFlags["AllowEmptyIndexInfoType"] = 2097152] = "AllowEmptyIndexInfoType";
+    // Errors (cont.)
+    NodeBuilderFlags[NodeBuilderFlags["AllowNodeModulesRelativePaths"] = 67108864] = "AllowNodeModulesRelativePaths";
+    NodeBuilderFlags[NodeBuilderFlags["DoNotIncludeSymbolChain"] = 134217728] = "DoNotIncludeSymbolChain";
+    NodeBuilderFlags[NodeBuilderFlags["IgnoreErrors"] = 70189056] = "IgnoreErrors";
+    // State
+    NodeBuilderFlags[NodeBuilderFlags["InTypeAlias"] = 8388608] = "InTypeAlias";
+    NodeBuilderFlags[NodeBuilderFlags["InInitialEntityName"] = 16777216] = "InInitialEntityName";
+    NodeBuilderFlags[NodeBuilderFlags["InReverseMappedType"] = 33554432] = "InReverseMappedType";
+})(NodeBuilderFlags || (NodeBuilderFlags = {}));
+// Ensure the shared flags between this and `NodeBuilderFlags` stay in alignment
+export var TypeFormatFlags;
+(function (TypeFormatFlags) {
+    TypeFormatFlags[TypeFormatFlags["None"] = 0] = "None";
+    TypeFormatFlags[TypeFormatFlags["NoTruncation"] = 1] = "NoTruncation";
+    TypeFormatFlags[TypeFormatFlags["WriteArrayAsGenericType"] = 2] = "WriteArrayAsGenericType";
+    // hole because there's a hole in node builder flags
+    TypeFormatFlags[TypeFormatFlags["UseStructuralFallback"] = 8] = "UseStructuralFallback";
+    // hole because there's a hole in node builder flags
+    TypeFormatFlags[TypeFormatFlags["WriteTypeArgumentsOfSignature"] = 32] = "WriteTypeArgumentsOfSignature";
+    TypeFormatFlags[TypeFormatFlags["UseFullyQualifiedType"] = 64] = "UseFullyQualifiedType";
+    // hole because `UseOnlyExternalAliasing` is here in node builder flags, but functions which take old flags use `SymbolFormatFlags` instead
+    TypeFormatFlags[TypeFormatFlags["SuppressAnyReturnType"] = 256] = "SuppressAnyReturnType";
+    // hole because `WriteTypeParametersInQualifiedName` is here in node builder flags, but functions which take old flags use `SymbolFormatFlags` for this instead
+    TypeFormatFlags[TypeFormatFlags["MultilineObjectLiterals"] = 1024] = "MultilineObjectLiterals";
+    TypeFormatFlags[TypeFormatFlags["UseTypeOfFunction"] = 4096] = "UseTypeOfFunction";
+    TypeFormatFlags[TypeFormatFlags["OmitParameterModifiers"] = 8192] = "OmitParameterModifiers";
+    TypeFormatFlags[TypeFormatFlags["UseAliasDefinedOutsideCurrentScope"] = 16384] = "UseAliasDefinedOutsideCurrentScope";
+    TypeFormatFlags[TypeFormatFlags["UseSingleQuotesForStringLiteralType"] = 268435456] = "UseSingleQuotesForStringLiteralType";
+    TypeFormatFlags[TypeFormatFlags["NoTypeReduction"] = 536870912] = "NoTypeReduction";
+    // Error Handling
+    TypeFormatFlags[TypeFormatFlags["AllowUniqueESSymbolType"] = 1048576] = "AllowUniqueESSymbolType";
+    // TypeFormatFlags exclusive
+    TypeFormatFlags[TypeFormatFlags["AddUndefined"] = 131072] = "AddUndefined";
+    TypeFormatFlags[TypeFormatFlags["WriteArrowStyleSignature"] = 262144] = "WriteArrowStyleSignature";
+    // State
+    TypeFormatFlags[TypeFormatFlags["InArrayType"] = 524288] = "InArrayType";
+    TypeFormatFlags[TypeFormatFlags["InElementType"] = 2097152] = "InElementType";
+    TypeFormatFlags[TypeFormatFlags["InFirstTypeArgument"] = 4194304] = "InFirstTypeArgument";
+    TypeFormatFlags[TypeFormatFlags["InTypeAlias"] = 8388608] = "InTypeAlias";
+    /** @deprecated */ TypeFormatFlags[TypeFormatFlags["WriteOwnNameForAnyLike"] = 0] = "WriteOwnNameForAnyLike";
+    TypeFormatFlags[TypeFormatFlags["NodeBuilderFlagsMask"] = 814773611] = "NodeBuilderFlagsMask";
+})(TypeFormatFlags || (TypeFormatFlags = {}));
+export var SymbolFormatFlags;
+(function (SymbolFormatFlags) {
+    SymbolFormatFlags[SymbolFormatFlags["None"] = 0] = "None";
+    // Write symbols's type argument if it is instantiated symbol
+    // eg. class C<T> { p: T }   <-- Show p as C<T>.p here
+    //     var a: C<number>;
+    //     var p = a.p; <--- Here p is property of C<number> so show it as C<number>.p instead of just C.p
+    SymbolFormatFlags[SymbolFormatFlags["WriteTypeParametersOrArguments"] = 1] = "WriteTypeParametersOrArguments";
+    // Use only external alias information to get the symbol name in the given context
+    // eg.  module m { export class c { } } import x = m.c;
+    // When this flag is specified m.c will be used to refer to the class instead of alias symbol x
+    SymbolFormatFlags[SymbolFormatFlags["UseOnlyExternalAliasing"] = 2] = "UseOnlyExternalAliasing";
+    // Build symbol name using any nodes needed, instead of just components of an entity name
+    SymbolFormatFlags[SymbolFormatFlags["AllowAnyNodeKind"] = 4] = "AllowAnyNodeKind";
+    // Prefer aliases which are not directly visible
+    SymbolFormatFlags[SymbolFormatFlags["UseAliasDefinedOutsideCurrentScope"] = 8] = "UseAliasDefinedOutsideCurrentScope";
+    // Skip building an accessible symbol chain
+    SymbolFormatFlags[SymbolFormatFlags["DoNotIncludeSymbolChain"] = 16] = "DoNotIncludeSymbolChain";
+})(SymbolFormatFlags || (SymbolFormatFlags = {}));
+export var SymbolAccessibility;
+(function (SymbolAccessibility) {
+    SymbolAccessibility[SymbolAccessibility["Accessible"] = 0] = "Accessible";
+    SymbolAccessibility[SymbolAccessibility["NotAccessible"] = 1] = "NotAccessible";
+    SymbolAccessibility[SymbolAccessibility["CannotBeNamed"] = 2] = "CannotBeNamed";
+})(SymbolAccessibility || (SymbolAccessibility = {}));
+export var TypePredicateKind;
+(function (TypePredicateKind) {
+    TypePredicateKind[TypePredicateKind["Identifier"] = 0] = "Identifier";
+    TypePredicateKind[TypePredicateKind["AssertsIdentifier"] = 1] = "AssertsIdentifier";
+})(TypePredicateKind || (TypePredicateKind = {}));
+export var CheckFlags;
+(function (CheckFlags) {
+    CheckFlags[CheckFlags["None"] = 0] = "None";
+    CheckFlags[CheckFlags["Instantiated"] = 1] = "Instantiated";
+    CheckFlags[CheckFlags["SyntheticProperty"] = 2] = "SyntheticProperty";
+    CheckFlags[CheckFlags["SyntheticMethod"] = 4] = "SyntheticMethod";
+    CheckFlags[CheckFlags["Readonly"] = 8] = "Readonly";
+    CheckFlags[CheckFlags["ReadPartial"] = 16] = "ReadPartial";
+    CheckFlags[CheckFlags["WritePartial"] = 32] = "WritePartial";
+    CheckFlags[CheckFlags["HasNonUniformType"] = 64] = "HasNonUniformType";
+    CheckFlags[CheckFlags["HasLiteralType"] = 128] = "HasLiteralType";
+    CheckFlags[CheckFlags["Late"] = 4096] = "Late";
+    CheckFlags[CheckFlags["ReverseMapped"] = 8192] = "ReverseMapped";
+    CheckFlags[CheckFlags["OptionalParameter"] = 16384] = "OptionalParameter";
+    CheckFlags[CheckFlags["RestParameter"] = 32768] = "RestParameter";
+    CheckFlags[CheckFlags["DeferredType"] = 65536] = "DeferredType";
+    CheckFlags[CheckFlags["HasNeverType"] = 131072] = "HasNeverType";
+    CheckFlags[CheckFlags["Mapped"] = 262144] = "Mapped";
+    CheckFlags[CheckFlags["StripOptional"] = 524288] = "StripOptional";
+    CheckFlags[CheckFlags["Synthetic"] = 6] = "Synthetic";
+    CheckFlags[CheckFlags["Discriminant"] = 192] = "Discriminant";
+    CheckFlags[CheckFlags["Partial"] = 48] = "Partial";
+})(CheckFlags || (CheckFlags = {}));
+export var NodeCheckFlags;
+(function (NodeCheckFlags) {
+    NodeCheckFlags[NodeCheckFlags["None"] = 0] = "None";
+    NodeCheckFlags[NodeCheckFlags["TypeChecked"] = 1] = "TypeChecked";
+    NodeCheckFlags[NodeCheckFlags["CaptureNewTarget"] = 8] = "CaptureNewTarget";
+    NodeCheckFlags[NodeCheckFlags["ContextChecked"] = 1024] = "ContextChecked";
+    NodeCheckFlags[NodeCheckFlags["CaptureArguments"] = 8192] = "CaptureArguments";
+    NodeCheckFlags[NodeCheckFlags["LoopWithCapturedBlockScopedBinding"] = 65536] = "LoopWithCapturedBlockScopedBinding";
+    NodeCheckFlags[NodeCheckFlags["ContainsCapturedBlockScopeBinding"] = 131072] = "ContainsCapturedBlockScopeBinding";
+    NodeCheckFlags[NodeCheckFlags["CapturedBlockScopedBinding"] = 262144] = "CapturedBlockScopedBinding";
+    NodeCheckFlags[NodeCheckFlags["BlockScopedBindingInLoop"] = 524288] = "BlockScopedBindingInLoop";
+    NodeCheckFlags[NodeCheckFlags["NeedsLoopOutParameter"] = 4194304] = "NeedsLoopOutParameter";
+    NodeCheckFlags[NodeCheckFlags["AssignmentsMarked"] = 8388608] = "AssignmentsMarked";
+})(NodeCheckFlags || (NodeCheckFlags = {}));
+export var TypeFlags;
+(function (TypeFlags) {
+    TypeFlags[TypeFlags["None"] = 0] = "None";
+    TypeFlags[TypeFlags["Any"] = 1] = "Any";
+    TypeFlags[TypeFlags["Unknown"] = 2] = "Unknown";
+    TypeFlags[TypeFlags["String"] = 4] = "String";
+    TypeFlags[TypeFlags["Number"] = 8] = "Number";
+    TypeFlags[TypeFlags["Boolean"] = 16] = "Boolean";
+    TypeFlags[TypeFlags["BigInt"] = 64] = "BigInt";
+    TypeFlags[TypeFlags["StringLiteral"] = 128] = "StringLiteral";
+    TypeFlags[TypeFlags["NumberLiteral"] = 256] = "NumberLiteral";
+    TypeFlags[TypeFlags["BooleanLiteral"] = 512] = "BooleanLiteral";
+    TypeFlags[TypeFlags["BigIntLiteral"] = 2048] = "BigIntLiteral";
+    TypeFlags[TypeFlags["ESSymbol"] = 4096] = "ESSymbol";
+    TypeFlags[TypeFlags["Void"] = 16384] = "Void";
+    TypeFlags[TypeFlags["Undefined"] = 32768] = "Undefined";
+    TypeFlags[TypeFlags["Null"] = 65536] = "Null";
+    TypeFlags[TypeFlags["Never"] = 131072] = "Never";
+    TypeFlags[TypeFlags["TypeParameter"] = 262144] = "TypeParameter";
+    TypeFlags[TypeFlags["Object"] = 524288] = "Object";
+    TypeFlags[TypeFlags["Union"] = 1048576] = "Union";
+    TypeFlags[TypeFlags["Intersection"] = 2097152] = "Intersection";
+    TypeFlags[TypeFlags["Index"] = 4194304] = "Index";
+    TypeFlags[TypeFlags["IndexedAccess"] = 8388608] = "IndexedAccess";
+    TypeFlags[TypeFlags["Conditional"] = 16777216] = "Conditional";
+    TypeFlags[TypeFlags["Substitution"] = 33554432] = "Substitution";
+    TypeFlags[TypeFlags["NonPrimitive"] = 67108864] = "NonPrimitive";
+    TypeFlags[TypeFlags["AnyOrUnknown"] = 3] = "AnyOrUnknown";
+    TypeFlags[TypeFlags["Nullable"] = 98304] = "Nullable";
+    TypeFlags[TypeFlags["Literal"] = 2944] = "Literal";
+    TypeFlags[TypeFlags["Unit"] = 101248] = "Unit";
+    TypeFlags[TypeFlags["StringOrNumberLiteral"] = 384] = "StringOrNumberLiteral";
+    TypeFlags[TypeFlags["DefinitelyFalsy"] = 117632] = "DefinitelyFalsy";
+    TypeFlags[TypeFlags["PossiblyFalsy"] = 117724] = "PossiblyFalsy";
+    TypeFlags[TypeFlags["Intrinsic"] = 67359327] = "Intrinsic";
+    TypeFlags[TypeFlags["Primitive"] = 121820] = "Primitive";
+    TypeFlags[TypeFlags["StringLike"] = 132] = "StringLike";
+    TypeFlags[TypeFlags["NumberLike"] = 264] = "NumberLike";
+    TypeFlags[TypeFlags["BigIntLike"] = 2112] = "BigIntLike";
+    TypeFlags[TypeFlags["BooleanLike"] = 528] = "BooleanLike";
+    TypeFlags[TypeFlags["ESSymbolLike"] = 4096] = "ESSymbolLike";
+    TypeFlags[TypeFlags["VoidLike"] = 49152] = "VoidLike";
+    TypeFlags[TypeFlags["DisjointDomains"] = 67230684] = "DisjointDomains";
+    TypeFlags[TypeFlags["UnionOrIntersection"] = 3145728] = "UnionOrIntersection";
+    TypeFlags[TypeFlags["StructuredType"] = 3670016] = "StructuredType";
+    TypeFlags[TypeFlags["TypeVariable"] = 8650752] = "TypeVariable";
+    TypeFlags[TypeFlags["InstantiableNonPrimitive"] = 58982400] = "InstantiableNonPrimitive";
+    TypeFlags[TypeFlags["InstantiablePrimitive"] = 4194304] = "InstantiablePrimitive";
+    TypeFlags[TypeFlags["Instantiable"] = 63176704] = "Instantiable";
+    TypeFlags[TypeFlags["StructuredOrInstantiable"] = 66846720] = "StructuredOrInstantiable";
+    TypeFlags[TypeFlags["ObjectFlagsType"] = 3899393] = "ObjectFlagsType";
+    TypeFlags[TypeFlags["Simplifiable"] = 25165824] = "Simplifiable";
+    TypeFlags[TypeFlags["Substructure"] = 66584576] = "Substructure";
+    // 'Narrowable' types are types where narrowing actually narrows.
+    // This *should* be every type other than null, undefined, void, and never
+    TypeFlags[TypeFlags["Narrowable"] = 133962719] = "Narrowable";
+    TypeFlags[TypeFlags["NotUnionOrUnit"] = 67637251] = "NotUnionOrUnit";
+    TypeFlags[TypeFlags["NotPrimitiveUnion"] = 66994179] = "NotPrimitiveUnion";
+    // The following flags are aggregated during union and intersection type construction
+    TypeFlags[TypeFlags["IncludesMask"] = 71031775] = "IncludesMask";
+    // The following flags are used for different purposes during union and intersection type construction
+    TypeFlags[TypeFlags["IncludesStructuredOrInstantiable"] = 262144] = "IncludesStructuredOrInstantiable";
+    TypeFlags[TypeFlags["IncludesNonWideningType"] = 4194304] = "IncludesNonWideningType";
+    TypeFlags[TypeFlags["IncludesWildcard"] = 8388608] = "IncludesWildcard";
+    TypeFlags[TypeFlags["IncludesEmptyObject"] = 16777216] = "IncludesEmptyObject";
+})(TypeFlags || (TypeFlags = {}));
+export var ObjectFlags;
+(function (ObjectFlags) {
+    ObjectFlags[ObjectFlags["None"] = 0] = "None";
+    ObjectFlags[ObjectFlags["Interface"] = 2] = "Interface";
+    ObjectFlags[ObjectFlags["Reference"] = 4] = "Reference";
+    ObjectFlags[ObjectFlags["Tuple"] = 8] = "Tuple";
+    ObjectFlags[ObjectFlags["Anonymous"] = 16] = "Anonymous";
+    ObjectFlags[ObjectFlags["Mapped"] = 32] = "Mapped";
+    ObjectFlags[ObjectFlags["Instantiated"] = 64] = "Instantiated";
+    ObjectFlags[ObjectFlags["ObjectLiteral"] = 128] = "ObjectLiteral";
+    ObjectFlags[ObjectFlags["EvolvingArray"] = 256] = "EvolvingArray";
+    ObjectFlags[ObjectFlags["ObjectLiteralPatternWithComputedProperties"] = 512] = "ObjectLiteralPatternWithComputedProperties";
+    ObjectFlags[ObjectFlags["ContainsSpread"] = 1024] = "ContainsSpread";
+    ObjectFlags[ObjectFlags["ReverseMapped"] = 2048] = "ReverseMapped";
+    ObjectFlags[ObjectFlags["JsxAttributes"] = 4096] = "JsxAttributes";
+    ObjectFlags[ObjectFlags["MarkerType"] = 8192] = "MarkerType";
+    ObjectFlags[ObjectFlags["JSLiteral"] = 16384] = "JSLiteral";
+    ObjectFlags[ObjectFlags["FreshLiteral"] = 32768] = "FreshLiteral";
+    ObjectFlags[ObjectFlags["ArrayLiteral"] = 65536] = "ArrayLiteral";
+    ObjectFlags[ObjectFlags["ObjectRestType"] = 131072] = "ObjectRestType";
+    ObjectFlags[ObjectFlags["PrimitiveUnion"] = 262144] = "PrimitiveUnion";
+    ObjectFlags[ObjectFlags["ContainsWideningType"] = 524288] = "ContainsWideningType";
+    ObjectFlags[ObjectFlags["ContainsObjectOrArrayLiteral"] = 1048576] = "ContainsObjectOrArrayLiteral";
+    ObjectFlags[ObjectFlags["NonInferrableType"] = 2097152] = "NonInferrableType";
+    ObjectFlags[ObjectFlags["IsGenericObjectTypeComputed"] = 4194304] = "IsGenericObjectTypeComputed";
+    ObjectFlags[ObjectFlags["IsGenericObjectType"] = 8388608] = "IsGenericObjectType";
+    ObjectFlags[ObjectFlags["IsGenericIndexTypeComputed"] = 16777216] = "IsGenericIndexTypeComputed";
+    ObjectFlags[ObjectFlags["IsGenericIndexType"] = 33554432] = "IsGenericIndexType";
+    ObjectFlags[ObjectFlags["CouldContainTypeVariablesComputed"] = 67108864] = "CouldContainTypeVariablesComputed";
+    ObjectFlags[ObjectFlags["CouldContainTypeVariables"] = 134217728] = "CouldContainTypeVariables";
+    ObjectFlags[ObjectFlags["ContainsIntersections"] = 268435456] = "ContainsIntersections";
+    ObjectFlags[ObjectFlags["IsNeverIntersectionComputed"] = 268435456] = "IsNeverIntersectionComputed";
+    ObjectFlags[ObjectFlags["IsNeverIntersection"] = 536870912] = "IsNeverIntersection";
+    ObjectFlags[ObjectFlags["ClassOrInterface"] = 2] = "ClassOrInterface";
+    ObjectFlags[ObjectFlags["RequiresWidening"] = 1572864] = "RequiresWidening";
+    ObjectFlags[ObjectFlags["PropagatingFlags"] = 3670016] = "PropagatingFlags";
+})(ObjectFlags || (ObjectFlags = {}));
+export var VarianceFlags;
+(function (VarianceFlags) {
+    VarianceFlags[VarianceFlags["Invariant"] = 0] = "Invariant";
+    VarianceFlags[VarianceFlags["Covariant"] = 1] = "Covariant";
+    VarianceFlags[VarianceFlags["Contravariant"] = 2] = "Contravariant";
+    VarianceFlags[VarianceFlags["Bivariant"] = 3] = "Bivariant";
+    VarianceFlags[VarianceFlags["Independent"] = 4] = "Independent";
+    VarianceFlags[VarianceFlags["VarianceMask"] = 7] = "VarianceMask";
+    VarianceFlags[VarianceFlags["Unmeasurable"] = 8] = "Unmeasurable";
+    VarianceFlags[VarianceFlags["Unreliable"] = 16] = "Unreliable";
+    VarianceFlags[VarianceFlags["AllowsStructuralFallback"] = 24] = "AllowsStructuralFallback";
+})(VarianceFlags || (VarianceFlags = {}));
+export var JsxReferenceKind;
+(function (JsxReferenceKind) {
+    JsxReferenceKind[JsxReferenceKind["Function"] = 0] = "Function";
+    JsxReferenceKind[JsxReferenceKind["Mixed"] = 1] = "Mixed";
+})(JsxReferenceKind || (JsxReferenceKind = {}));
+export var SignatureFlags;
+(function (SignatureFlags) {
+    SignatureFlags[SignatureFlags["None"] = 0] = "None";
+    SignatureFlags[SignatureFlags["HasRestParameter"] = 1] = "HasRestParameter";
+    SignatureFlags[SignatureFlags["HasLiteralTypes"] = 2] = "HasLiteralTypes";
+    SignatureFlags[SignatureFlags["IsInnerCallChain"] = 4] = "IsInnerCallChain";
+    SignatureFlags[SignatureFlags["IsOuterCallChain"] = 8] = "IsOuterCallChain";
+    // We do not propagate `IsInnerCallChain` to instantiated signatures, as that would result in us
+    // attempting to add `| undefined` on each recursive call to `getReturnTypeOfSignature` when
+    // instantiating the return type.
+    SignatureFlags[SignatureFlags["PropagatingFlags"] = 3] = "PropagatingFlags";
+    SignatureFlags[SignatureFlags["CallChainFlags"] = 12] = "CallChainFlags";
+})(SignatureFlags || (SignatureFlags = {}));
+export var IndexKind;
+(function (IndexKind) {
+    IndexKind[IndexKind["String"] = 0] = "String";
+    IndexKind[IndexKind["Number"] = 1] = "Number";
+})(IndexKind || (IndexKind = {}));
+export var TypeMapKind;
+(function (TypeMapKind) {
+    TypeMapKind[TypeMapKind["Simple"] = 0] = "Simple";
+    TypeMapKind[TypeMapKind["Array"] = 1] = "Array";
+    TypeMapKind[TypeMapKind["Function"] = 2] = "Function";
+    TypeMapKind[TypeMapKind["Composite"] = 3] = "Composite";
+    TypeMapKind[TypeMapKind["Merged"] = 4] = "Merged";
+})(TypeMapKind || (TypeMapKind = {}));
+export var InferencePriority;
+(function (InferencePriority) {
+    InferencePriority[InferencePriority["None"] = 0] = "None";
+    InferencePriority[InferencePriority["NakedTypeVariable"] = 1] = "NakedTypeVariable";
+    InferencePriority[InferencePriority["HomomorphicMappedType"] = 2] = "HomomorphicMappedType";
+    InferencePriority[InferencePriority["PartialHomomorphicMappedType"] = 4] = "PartialHomomorphicMappedType";
+    InferencePriority[InferencePriority["MappedTypeConstraint"] = 8] = "MappedTypeConstraint";
+    InferencePriority[InferencePriority["ContravariantConditional"] = 16] = "ContravariantConditional";
+    InferencePriority[InferencePriority["ReturnType"] = 32] = "ReturnType";
+    InferencePriority[InferencePriority["LiteralKeyof"] = 64] = "LiteralKeyof";
+    InferencePriority[InferencePriority["NoConstraints"] = 128] = "NoConstraints";
+    InferencePriority[InferencePriority["AlwaysStrict"] = 256] = "AlwaysStrict";
+    InferencePriority[InferencePriority["MaxValue"] = 512] = "MaxValue";
+    InferencePriority[InferencePriority["PriorityImpliesCombination"] = 104] = "PriorityImpliesCombination";
+    InferencePriority[InferencePriority["Circularity"] = -1] = "Circularity";
+})(InferencePriority || (InferencePriority = {}));
+export var InferenceFlags;
+(function (InferenceFlags) {
+    InferenceFlags[InferenceFlags["None"] = 0] = "None";
+    InferenceFlags[InferenceFlags["NoDefault"] = 1] = "NoDefault";
+    InferenceFlags[InferenceFlags["AnyDefault"] = 2] = "AnyDefault";
+    InferenceFlags[InferenceFlags["SkippedGenericFunction"] = 4] = "SkippedGenericFunction";
+})(InferenceFlags || (InferenceFlags = {}));
+/**
+ * Ternary values are defined such that
+ * x & y is False if either x or y is False.
+ * x & y is Maybe if either x or y is Maybe, but neither x or y is False.
+ * x & y is True if both x and y are True.
+ * x | y is False if both x and y are False.
+ * x | y is Maybe if either x or y is Maybe, but neither x or y is True.
+ * x | y is True if either x or y is True.
+ */
+export var Ternary;
+(function (Ternary) {
+    Ternary[Ternary["False"] = 0] = "False";
+    Ternary[Ternary["Maybe"] = 1] = "Maybe";
+    Ternary[Ternary["True"] = -1] = "True";
+})(Ternary || (Ternary = {}));

package/dist/utilities.d.ts

@@ -0,0 +1,34 @@
+import * as ts from "./_namespaces/ts.js";
+import { CheckFlags, ObjectFlags, SignatureFlags, TypeFlags } from "./_namespaces/ts.js";
+import type { CommentDirective, CommentDirectivesMap, DiagnosticCollection, IdentifierTypePredicate, IndexInfo, Signature, SourceFile, Symbol, Type, TypeChecker, TypePredicate } from "./_namespaces/ts.js";
+/** Os construtores de `Type` e de `Signature`, que o `objectAllocator` da parse tree não tem: só o checker os cria. */
+export interface TypeObjectAllocator {
+    getTypeConstructor(): new (checker: TypeChecker, flags: TypeFlags) => Type;
+    getSignatureConstructor(): new (checker: TypeChecker, flags: SignatureFlags) => Signature;
+}
+declare function Type(this: Type, checker: TypeChecker, flags: TypeFlags): void;
+declare function Signature(this: Signature, checker: TypeChecker, flags: SignatureFlags): void;
+export declare let typeObjectAllocator: TypeObjectAllocator;
+/**
+ * Troca os construtores de `Type` e de `Signature`: o par do `setObjectAllocator` da árvore, que na tag trocava os
+ * dois junto com os do nó, num alocador só (CK-64). O language service troca os dois pelos dele, com os métodos que os
+ * serviços chamam (`type.isUnion()`, `signature.getDocumentationComment()`), ao carregar. Vale para o checker criado
+ * depois da troca.
+ */
+export declare function setTypeObjectAllocator(alloc: TypeObjectAllocator): void;
+export declare function formatTypeFlags(flags: TypeFlags | undefined): string;
+export declare function formatObjectFlags(flags: ObjectFlags | undefined): string;
+/**
+ * A informação de depuração dos tipos, que o `Debug.enableDebugInfo` da parse tree não alcança: as flags e o texto do
+ * tipo, como propriedades do protótipo, para o depurador.
+ */
+export declare function enableTypeDebugInfo(): void;
+export declare function createCommentDirectivesMap(sourceFile: SourceFile, commentDirectives: CommentDirective[]): CommentDirectivesMap;
+export declare function getNameFromIndexInfo(info: IndexInfo): string | undefined;
+export declare function isIdentifierTypePredicate(predicate: TypePredicate): predicate is IdentifierTypePredicate;
+export declare function createDiagnosticCollection(): DiagnosticCollection;
+export declare function getCheckFlags(symbol: Symbol): CheckFlags;
+export declare function skipAlias(symbol: Symbol, checker: TypeChecker): ts.Symbol;
+export declare function getObjectFlags(type: Type): ObjectFlags;
+export declare function typeHasCallOrConstructSignatures(type: Type, checker: TypeChecker): boolean;
+export {};

package/dist/utilities.js

@@ -0,0 +1,157 @@
+// Modificado de microsoft/TypeScript v3.9.10, src/compiler/utilities.ts e src/compiler/debug.ts: os utilitários que só o
+// checker usa.
+import * as ts from "./_namespaces/ts.js";
+import { CommentDirectiveType, Debug, SymbolFlags, arrayFrom, binarySearch, compareDiagnostics, compareDiagnosticsSkipRelatedInformation, compareStringsCaseSensitive, createMap, createMapFromEntries, declarationNameToString, flatMapToMutable, forEach, getLineAndCharacterOfPosition, identity, insertSorted, } from "./_namespaces/ts.js";
+function Type(checker, flags) {
+    this.flags = flags;
+    if (Debug.isDebugging) {
+        this.checker = checker;
+    }
+}
+function Signature(checker, flags) {
+    this.flags = flags;
+    if (Debug.isDebugging) {
+        this.checker = checker;
+    }
+}
+export let typeObjectAllocator = {
+    getTypeConstructor: () => Type,
+    getSignatureConstructor: () => Signature,
+};
+/**
+ * Troca os construtores de `Type` e de `Signature`: o par do `setObjectAllocator` da árvore, que na tag trocava os
+ * dois junto com os do nó, num alocador só (CK-64). O language service troca os dois pelos dele, com os métodos que os
+ * serviços chamam (`type.isUnion()`, `signature.getDocumentationComment()`), ao carregar. Vale para o checker criado
+ * depois da troca.
+ */
+export function setTypeObjectAllocator(alloc) {
+    typeObjectAllocator = alloc;
+}
+export function formatTypeFlags(flags) {
+    return Debug.formatEnum(flags, ts.TypeFlags, /*isFlags*/ true);
+}
+export function formatObjectFlags(flags) {
+    return Debug.formatEnum(flags, ts.ObjectFlags, /*isFlags*/ true);
+}
+let isTypeDebugInfoEnabled = false;
+/**
+ * A informação de depuração dos tipos, que o `Debug.enableDebugInfo` da parse tree não alcança: as flags e o texto do
+ * tipo, como propriedades do protótipo, para o depurador.
+ */
+export function enableTypeDebugInfo() {
+    if (isTypeDebugInfoEnabled)
+        return;
+    Debug.enableDebugInfo();
+    Object.defineProperties(typeObjectAllocator.getTypeConstructor().prototype, {
+        __debugFlags: { get() { return formatTypeFlags(this.flags); } },
+        __debugObjectFlags: { get() { return this.flags & 524288 /* TypeFlags.Object */ ? formatObjectFlags(this.objectFlags) : ""; } },
+        __debugTypeToString: { value() { return this.checker.typeToString(this); } },
+    });
+    isTypeDebugInfoEnabled = true;
+}
+export function createCommentDirectivesMap(sourceFile, commentDirectives) {
+    const directivesByLine = createMapFromEntries(commentDirectives.map(commentDirective => ([
+        `${getLineAndCharacterOfPosition(sourceFile, commentDirective.range.end).line}`,
+        commentDirective,
+    ])));
+    const usedLines = createMap();
+    return { getUnusedExpectations, markUsed };
+    function getUnusedExpectations() {
+        return arrayFrom(directivesByLine.entries())
+            .filter(([line, directive]) => directive.type === CommentDirectiveType.ExpectError && !usedLines.get(line))
+            .map(([_, directive]) => directive);
+    }
+    function markUsed(line) {
+        if (!directivesByLine.has(`${line}`)) {
+            return false;
+        }
+        usedLines.set(`${line}`, true);
+        return true;
+    }
+}
+export function getNameFromIndexInfo(info) {
+    return info.declaration ? declarationNameToString(info.declaration.parameters[0].name) : undefined;
+}
+export function isIdentifierTypePredicate(predicate) {
+    return predicate && predicate.kind === 0 /* TypePredicateKind.Identifier */;
+}
+export function createDiagnosticCollection() {
+    let nonFileDiagnostics = []; // See GH#19873
+    const filesWithDiagnostics = [];
+    const fileDiagnostics = createMap();
+    let hasReadNonFileDiagnostics = false;
+    return {
+        add,
+        lookup,
+        getGlobalDiagnostics,
+        getDiagnostics,
+        reattachFileDiagnostics
+    };
+    function reattachFileDiagnostics(newFile) {
+        forEach(fileDiagnostics.get(newFile.fileName), diagnostic => diagnostic.file = newFile);
+    }
+    function lookup(diagnostic) {
+        let diagnostics;
+        if (diagnostic.file) {
+            diagnostics = fileDiagnostics.get(diagnostic.file.fileName);
+        }
+        else {
+            diagnostics = nonFileDiagnostics;
+        }
+        if (!diagnostics) {
+            return undefined;
+        }
+        const result = binarySearch(diagnostics, diagnostic, identity, compareDiagnosticsSkipRelatedInformation);
+        if (result >= 0) {
+            return diagnostics[result];
+        }
+        return undefined;
+    }
+    function add(diagnostic) {
+        let diagnostics;
+        if (diagnostic.file) {
+            diagnostics = fileDiagnostics.get(diagnostic.file.fileName);
+            if (!diagnostics) {
+                diagnostics = []; // See GH#19873
+                fileDiagnostics.set(diagnostic.file.fileName, diagnostics);
+                insertSorted(filesWithDiagnostics, diagnostic.file.fileName, compareStringsCaseSensitive);
+            }
+        }
+        else {
+            // If we've already read the non-file diagnostics, do not modify the existing array.
+            if (hasReadNonFileDiagnostics) {
+                hasReadNonFileDiagnostics = false;
+                nonFileDiagnostics = nonFileDiagnostics.slice();
+            }
+            diagnostics = nonFileDiagnostics;
+        }
+        insertSorted(diagnostics, diagnostic, compareDiagnostics);
+    }
+    function getGlobalDiagnostics() {
+        hasReadNonFileDiagnostics = true;
+        return nonFileDiagnostics;
+    }
+    function getDiagnostics(fileName) {
+        if (fileName) {
+            return fileDiagnostics.get(fileName) || [];
+        }
+        const fileDiags = flatMapToMutable(filesWithDiagnostics, f => fileDiagnostics.get(f));
+        if (!nonFileDiagnostics.length) {
+            return fileDiags;
+        }
+        fileDiags.unshift(...nonFileDiagnostics);
+        return fileDiags;
+    }
+}
+export function getCheckFlags(symbol) {
+    return symbol.flags & SymbolFlags.Transient ? symbol.checkFlags : 0;
+}
+export function skipAlias(symbol, checker) {
+    return symbol.flags & SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+}
+export function getObjectFlags(type) {
+    return type.flags & 3899393 /* TypeFlags.ObjectFlagsType */ ? type.objectFlags : 0;
+}
+export function typeHasCallOrConstructSignatures(type, checker) {
+    return checker.getSignaturesOfType(type).length !== 0;
+}

package/lib/lib.tslite.d.ts

@@ -0,0 +1,56 @@
+/*! *****************************************************************************
+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.
+***************************************************************************** */
+
+// A lib da cópia (CK-48): os aliases da lib dos embutidos do oráculo (`packages/oracle/lib/lib.tslite.d.ts`, CK-42), com
+// o texto da tag. Os embutidos nascem no checker: o `Array`, o `ReadonlyArray` e o `Promise` com o nome que o programa
+// escreve; o `PromiseLike`, o protocolo de iteração, o `Function`, o `String`, o `Number` e o `Boolean`, sem nome que um
+// programa alcance; e o `Object`, o `CallableFunction`, o `NewableFunction`, o `IArguments`, o `RegExp` e o `Symbol` o
+// checker não procura mais. A lib do oráculo continua a declarar todos, porque a tag os procura.
+
+/// <reference no-default-lib="true"/>
+
+declare type PropertyKey = string | number;
+
+type Partial<T> = {
+    [P in keyof T]?: T[P];
+};
+
+type Required<T> = {
+    [P in keyof T]-?: T[P];
+};
+
+type Readonly<T> = {
+    readonly [P in keyof T]: T[P];
+};
+
+type Pick<T, K extends keyof T> = {
+    [P in K]: T[P];
+};
+
+type Record<K extends keyof any, T> = {
+    [P in K]: T;
+};
+
+type Exclude<T, U> = T extends U ? never : T;
+
+type Extract<T, U> = T extends U ? T : never;
+
+type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
+
+type NonNullable<T> = T extends null | undefined ? never : T;
+
+type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never;
+
+type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;