tsc-ts 0.0.4 → 0.0.6

package/dist/api/compiler/checker-jsx.js

@@ -0,0 +1,1433 @@
+// JSX: element and fragment types, the `JSX` namespace, intrinsic elements, attributes and children.
+import { checkDeprecatedJsxAttribute, checkDeprecatedSignature } from './checker-deprecation.js';
+import { getSymbol, getTagName, getText, getTypeArguments, getExpression, Identifier, PropertySignatureDeclaration, } from './ast.js';
+import { getSourceFileOfNode, getSourceTextOfNode } from './binder-utilities.js';
+import { Diagnostic, chainDiagnostic } from './diagnostics.js';
+import { JsxEmit } from './options.js';
+import { parseIsolatedEntityName } from './parser.js';
+import { skipTrivia } from './scanner.js';
+import { createDiagnosticForNode } from './checker.js';
+import { newTypeMapper, } from './checker-types.js';
+import { createAnonymousType, createArrayType, createTupleType, createTypeReference, getIntersectionType, getPropagatingFlagsOfTypes, getStringLiteralType, getUnionType, intersectTypes, isErrorType, everyType, isArrayType, mapTypeEx, someType, typesOf, } from './checker-type-factory.js';
+import { getApparentType, getApplicableIndexInfo, getApplicableIndexInfoForName, getIndexTypeOfType, getPropertiesOfType, getPropertyOfType, getSignaturesOfType, getTypeOfPropertyOfType, getUnionSignatures, isArrayLikeType, } from './checker-members.js';
+import { getMergedSymbol, getExportsOfSymbol, getFirstIdentifier, getGlobalSymbol, getSymbolOfMeaning, resolveAlias, resolveEntityName, getSpellingSuggestionForName, resolveName, resolveSymbol, } from './checker-symbols.js';
+import { resolveExternalModule } from './checker-modules.js';
+import { fillMissingTypeArguments, getDeclaredTypeOfSymbol, getLocalTypeParametersOfClassOrInterfaceOrTypeAlias, getMinTypeArgumentCount, } from './checker-declared-types.js';
+import { getTypeAliasInstantiation } from './checker-type-nodes.js';
+import { getTypeOfSymbol } from './checker-symbol-types.js';
+import { getMinArgumentCount, getOrCreateTypeFromSignature, getParameterCount, getReturnTypeOfSignature, getTypeAtPosition, hasEffectiveRestParameter, } from './checker-signatures.js';
+import { instantiateType } from './instantiation.js';
+import { checkTypeRelatedTo, getRegularTypeOfObjectLiteral, isExactOptionalPropertyMismatch, isTypeRelatedTo, } from './relations.js';
+import { checkExpression, checkExpressionCached, checkExpressionEx, checkExpressionForMutableLocationEx, } from './checker-expressions.js';
+import { checkExpressionWithContextualType, findContextualNode, getApparentTypeOfContextualType, getApparentTypeOfContextualTypeEx, getContextualType, getContextualTypeEx, getTypeOfPropertyOfContextualType, getInferenceContext, } from './checker-contextual.js';
+import { checkNodeDeferred, checkSourceElement } from './checker-source-file.js';
+import { getResolvedSignature, resolveCall } from './checker-calls.js';
+import { addIntraExpressionInferenceSite, getInferredTypes, inferTypes, } from './checker-inference.js';
+import { isContextSensitive } from './checker-functions.js';
+import { checkSpreadPropOverrides, getSpreadType } from './checker-object-literals.js';
+import { isValidSpreadType } from './checker-destructuring.js';
+import { checkExpressionForMutableLocationWithContextualType, checkTypeRelatedToAndOptionallyElaborate, elaborateElement, elaborateError, getBestMatchIndexedAccessTypeOrUndefined, } from './checker-elaboration.js';
+import { getGlobalIterableType, getIterationTypeOfIterable, } from './checker-iteration.js';
+import { getIndexedAccessTypeOrUndefined, getPropertyNameFromIndex } from './checker-type-operators.js';
+import { removeMissingType } from './checker-symbol-types.js';
+import { typeToString } from './type-printer.js';
+import { getReducedType } from './checker-members.js';
+import { getNumberLiteralType } from './checker-type-factory.js';
+import { getIndexedAccessType } from './checker-type-operators.js';
+import { filterType, isTupleType } from './checker-type-factory.js';
+import { createTypeFromGenericGlobalType } from './checker-type-factory.js';
+import { isTypeAssignableTo } from './relations.js';
+import { copyDeclarations, declarationCount, getSymbolId, } from './symbol.js';
+// Names in the `JSX` namespace.
+const jsxNamespaceName = 'JSX';
+const jsxIntrinsicElementsName = 'IntrinsicElements';
+const jsxElementClassName = 'ElementClass';
+const jsxElementAttributesPropertyName = 'ElementAttributesProperty';
+const jsxElementChildrenAttributeName = 'ElementChildrenAttribute';
+const jsxElementName = 'Element';
+const jsxElementTypeName = 'ElementType';
+const jsxIntrinsicAttributesName = 'IntrinsicAttributes';
+const jsxIntrinsicClassAttributesName = 'IntrinsicClassAttributes';
+const jsxLibraryManagedAttributesName = 'LibraryManagedAttributes';
+/** Per-element JSX state. */
+class JsxElementLinks {
+    jsxFlags = 0 /* JsxFlags.None */;
+    resolvedJsxElementAttributesType = undefined;
+    resolvedSymbol = undefined;
+    /** The resolved `JSX` namespace; `unknownSymbol` when the local lookup failed. */
+    jsxNamespace = undefined;
+}
+/** Per-file JSX state: pragmas, factories and the implicit runtime import. */
+class JsxFileLinks {
+    localJsxNamespace = '';
+    localJsxFactory = undefined;
+    localJsxFragmentNamespace = '';
+    localJsxFragmentFactory = undefined;
+    jsxFragmentType = undefined;
+    /** `unknownSymbol` when there is no implicit import container. */
+    jsxImplicitImportContainer = undefined;
+}
+/** The checker's JSX caches. */
+export class JsxState {
+    elementLinks = new Map();
+    fileLinks = new Map();
+    /** getJsxIntrinsicConstructorType by attributes and element type ids. */
+    intrinsicConstructorTypes = new Map();
+    jsxNamespace = '';
+    jsxFactoryEntity = undefined;
+}
+function elementLinks(c, node) {
+    let links = c.jsx.elementLinks.get(node);
+    if (links === undefined) {
+        links = new JsxElementLinks();
+        c.jsx.elementLinks.set(node, links);
+    }
+    return links;
+}
+function fileLinks(c, file) {
+    let links = c.jsx.fileLinks.get(file);
+    if (links === undefined) {
+        links = new JsxFileLinks();
+        c.jsx.fileLinks.set(file, links);
+    }
+    return links;
+}
+// ---- Syntax helpers
+export function isJsxOpeningLikeElement(node) {
+    return node.kind === 287 /* SyntaxKind.JsxOpeningElement */ || node.kind === 286 /* SyntaxKind.JsxSelfClosingElement */;
+}
+function isIntrinsicJsxName(name) {
+    if (name.length === 0)
+        return false;
+    const ch = name.charCodeAt(0);
+    return (ch >= 0x61 && ch <= 0x7a) || name.includes('-');
+}
+/** Whether a tag name refers to an intrinsic element: a lowercase or dashed identifier, or `ns:name`. */
+export function isJsxIntrinsicTagName(tagName) {
+    return ((tagName.kind === 79 /* SyntaxKind.Identifier */ && isIntrinsicJsxName(getText(tagName))) ||
+        tagName.kind === 296 /* SyntaxKind.JsxNamespacedName */);
+}
+/** The text of an identifier or `ns:name`. */
+function jsxNameText(node) {
+    if (node.kind === 296 /* SyntaxKind.JsxNamespacedName */) {
+        const name = node;
+        return name.namespace.text + ':' + name.name.text;
+    }
+    return getText(node);
+}
+function getTextOfNode(node) {
+    return getSourceTextOfNode(getSourceFileOfNode(node), node);
+}
+function entityNameToString(node) {
+    switch (node.kind) {
+        case 109 /* SyntaxKind.ThisKeyword */:
+            return 'this';
+        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+            const access = node;
+            return entityNameToString(access.expression) + '.' + entityNameToString(access.name);
+        }
+        case 167 /* SyntaxKind.QualifiedName */:
+            return entityNameToString(node.left) + '.' + node.right.text;
+        case 296 /* SyntaxKind.JsxNamespacedName */:
+            return jsxNameText(node);
+    }
+    return getText(node);
+}
+export function getTagNameOf(node) {
+    return getTagName(node);
+}
+export function getAttributesOf(node) {
+    return node.kind === 286 /* SyntaxKind.JsxSelfClosingElement */
+        ? node.attributes
+        : node.attributes;
+}
+function getTypeArgumentListOf(node) {
+    return getTypeArguments(node);
+}
+function getChildrenOf(node) {
+    if (node.kind === 285 /* SyntaxKind.JsxElement */)
+        return node.children.nodes;
+    if (node.kind === 289 /* SyntaxKind.JsxFragment */)
+        return node.children.nodes;
+    return [];
+}
+/** Children that produce values: non-empty expressions, non-whitespace text and elements. */
+export function getSemanticJsxChildren(children) {
+    const result = [];
+    for (const child of children) {
+        if (child.kind === 295 /* SyntaxKind.JsxExpression */) {
+            if (child.expression !== undefined)
+                result.push(child);
+        }
+        else if (child.kind === 11 /* SyntaxKind.JsxText */) {
+            if (!child.containsOnlyTriviaWhiteSpaces)
+                result.push(child);
+        }
+        else
+            result.push(child);
+    }
+    return result;
+}
+function isHyphenatedJsxName(name) {
+    return name.includes('-');
+}
+function getPragma(file, name, argument) {
+    let result = undefined;
+    // The last pragma wins.
+    for (const pragma of file.pragmas)
+        if (pragma.name === name)
+            result = pragma.args.get(argument)?.value ?? '';
+    return result;
+}
+function isJsxTransformEnabled(c) {
+    const jsx = c.compilerOptions.jsx;
+    return jsx === JsxEmit.React || jsx === JsxEmit.ReactJSX || jsx === JsxEmit.ReactJSXDev;
+}
+function grammarErrorOnNode(c, node, message, ...args) {
+    if (getSourceFileOfNode(node).diagnostics.length !== 0)
+        return false;
+    c.error(node, message, ...args);
+    return true;
+}
+function grammarErrorAtPos(c, node, pos, length, message) {
+    const file = getSourceFileOfNode(node);
+    if (file.diagnostics.length !== 0)
+        return false;
+    c.addDiagnostic(new Diagnostic(file.diagnosticFile(), pos, pos + length, message, []));
+    return true;
+}
+// ---- The JSX namespace
+/** The name of the factory namespace in scope at `location`, such as `React`. */
+export function getJsxNamespace(c, location) {
+    if (location !== undefined) {
+        const file = getSourceFileOfNode(location);
+        const links = fileLinks(c, file);
+        if (location.kind === 290 /* SyntaxKind.JsxOpeningFragment */) {
+            if (links.localJsxFragmentNamespace !== '')
+                return links.localJsxFragmentNamespace;
+            const fragmentPragma = getPragma(file, 'jsxfrag', 'factory');
+            if (fragmentPragma !== undefined) {
+                links.localJsxFragmentFactory = parseIsolatedEntityName(fragmentPragma);
+                if (links.localJsxFragmentFactory !== undefined) {
+                    links.localJsxFragmentNamespace = getText(getFirstIdentifier(links.localJsxFragmentFactory));
+                    return links.localJsxFragmentNamespace;
+                }
+            }
+            const entity = getJsxFragmentFactoryEntity(c, location);
+            if (entity !== undefined) {
+                links.localJsxFragmentFactory = entity;
+                links.localJsxFragmentNamespace = getText(getFirstIdentifier(entity));
+                return links.localJsxFragmentNamespace;
+            }
+        }
+        else {
+            const local = getLocalJsxNamespace(c, file);
+            if (local !== '') {
+                links.localJsxNamespace = local;
+                return local;
+            }
+        }
+    }
+    const state = c.jsx;
+    if (state.jsxNamespace === '') {
+        state.jsxNamespace = 'React';
+        const factory = c.compilerOptions.jsxFactory;
+        if (factory !== undefined && factory !== '') {
+            state.jsxFactoryEntity = parseIsolatedEntityName(factory);
+            if (state.jsxFactoryEntity !== undefined)
+                state.jsxNamespace = getText(getFirstIdentifier(state.jsxFactoryEntity));
+        }
+        else {
+            const reactNamespace = c.compilerOptions.reactNamespace;
+            if (reactNamespace !== undefined && reactNamespace !== '')
+                state.jsxNamespace = reactNamespace;
+        }
+    }
+    if (state.jsxFactoryEntity === undefined)
+        state.jsxFactoryEntity = parseIsolatedEntityName(state.jsxNamespace + '.createElement');
+    return state.jsxNamespace;
+}
+function getLocalJsxNamespace(c, file) {
+    const links = fileLinks(c, file);
+    if (links.localJsxNamespace !== '')
+        return links.localJsxNamespace;
+    const pragma = getPragma(file, 'jsx', 'factory');
+    if (pragma !== undefined) {
+        links.localJsxFactory = parseIsolatedEntityName(pragma);
+        if (links.localJsxFactory !== undefined) {
+            links.localJsxNamespace = getText(getFirstIdentifier(links.localJsxFactory));
+            return links.localJsxNamespace;
+        }
+    }
+    return '';
+}
+function getJsxFactoryEntity(c, location) {
+    getJsxNamespace(c, location);
+    const local = fileLinks(c, getSourceFileOfNode(location)).localJsxFactory;
+    return local ?? c.jsx.jsxFactoryEntity;
+}
+function getJsxFragmentFactoryEntity(c, location) {
+    const file = getSourceFileOfNode(location);
+    const links = fileLinks(c, file);
+    if (links.localJsxFragmentFactory !== undefined)
+        return links.localJsxFragmentFactory;
+    const pragma = getPragma(file, 'jsxfrag', 'factory');
+    if (pragma !== undefined) {
+        links.localJsxFragmentFactory = parseIsolatedEntityName(pragma);
+        return links.localJsxFragmentFactory;
+    }
+    const factory = c.compilerOptions.jsxFragmentFactory;
+    if (factory !== undefined && factory !== '')
+        return parseIsolatedEntityName(factory);
+    return undefined;
+}
+/** The module of the automatic runtime's implicit import, such as `react/jsx-runtime`. */
+export function getJsxNamespaceContainerForImplicitImport(c, location) {
+    const file = getSourceFileOfNode(location);
+    const links = fileLinks(c, file);
+    const cached = links.jsxImplicitImportContainer;
+    if (cached !== undefined)
+        return cached === c.unknownSymbol ? undefined : cached;
+    const specifier = c.host.getJSXRuntimeImportSpecifier(file);
+    if (specifier === undefined) {
+        links.jsxImplicitImportContainer = c.unknownSymbol;
+        return undefined;
+    }
+    const mod = resolveExternalModule(c, specifier, getText(specifier), 995 /* Diagnostics.This_JSX_tag_requires_the_module_path_0_to_exist_but_none_could_be_found_Make_sure_you_have_types_for_the_appropriate_package_installed */, location, false);
+    const resolved = mod !== undefined && mod !== c.unknownSymbol ? resolveSymbol(c, mod) : undefined;
+    const result = resolved !== undefined ? getMergedSymbol(c, resolved) : undefined;
+    links.jsxImplicitImportContainer = result ?? c.unknownSymbol;
+    return result;
+}
+/** The `JSX` namespace for `location`: the factory's, the runtime module's, or the global one. */
+export function getJsxNamespaceAt(c, location) {
+    const links = elementLinks(c, location);
+    if (links.jsxNamespace !== undefined && links.jsxNamespace !== c.unknownSymbol)
+        return links.jsxNamespace;
+    if (links.jsxNamespace !== c.unknownSymbol) {
+        let resolvedNamespace = getJsxNamespaceContainerForImplicitImport(c, location);
+        if (resolvedNamespace === undefined || resolvedNamespace === c.unknownSymbol) {
+            const namespaceName = getJsxNamespace(c, location);
+            resolvedNamespace = resolveName(c, location, namespaceName, 1920 /* SymbolFlags.Namespace */, undefined, false, false);
+        }
+        if (resolvedNamespace !== undefined) {
+            const container = resolveSymbol(c, resolvedNamespace);
+            const candidate = resolveSymbol(c, getSymbolOfMeaning(c, getExportsOfSymbol(c, container), jsxNamespaceName, 1920 /* SymbolFlags.Namespace */));
+            if (candidate !== undefined && candidate !== c.unknownSymbol) {
+                links.jsxNamespace = candidate;
+                return candidate;
+            }
+        }
+        links.jsxNamespace = c.unknownSymbol;
+    }
+    const global = resolveSymbol(c, getGlobalSymbol(c, jsxNamespaceName, 1920 /* SymbolFlags.Namespace */, undefined));
+    return global === c.unknownSymbol ? undefined : global;
+}
+export function getJsxType(c, name, location) {
+    const namespace = getJsxNamespaceAt(c, location);
+    if (namespace !== undefined) {
+        const typeSymbol = getSymbolOfMeaning(c, getExportsOfSymbol(c, namespace), name, 788968 /* SymbolFlags.Type */);
+        if (typeSymbol !== undefined)
+            return getDeclaredTypeOfSymbol(c, typeSymbol);
+    }
+    return c.errorType;
+}
+/** `JSX.Element`, or the error type when it doesn't exist. */
+export function getJsxElementTypeAt(c, location) {
+    return getJsxType(c, jsxElementName, location);
+}
+function getJsxStatelessElementTypeAt(c, location) {
+    return getUnionType(c, [getJsxElementTypeAt(c, location), c.nullType]);
+}
+function getJsxElementClassTypeAt(c, location) {
+    const t = getJsxType(c, jsxElementClassName, location);
+    return isErrorType(c, t) ? undefined : t;
+}
+function getJsxElementTypeTypeAt(c, location) {
+    const ns = getJsxNamespaceAt(c, location);
+    if (ns === undefined)
+        return undefined;
+    const sym = getSymbolOfMeaning(c, getExportsOfSymbol(c, ns), jsxElementTypeName, 788968 /* SymbolFlags.Type */);
+    if (sym === undefined)
+        return undefined;
+    const t = instantiateAliasOrInterfaceWithDefaults(c, sym, []);
+    return t === undefined || isErrorType(c, t) ? undefined : t;
+}
+function instantiateAliasOrInterfaceWithDefaults(c, managedSym, typeArguments) {
+    const declaredManagedType = getDeclaredTypeOfSymbol(c, managedSym);
+    if ((managedSym.flags & 524288 /* SymbolFlags.TypeAlias */) !== 0) {
+        const params = c.symbolLinks(managedSym).typeParameters ?? [];
+        if (params.length >= typeArguments.length) {
+            const args = fillMissingTypeArguments(c, typeArguments, params, typeArguments.length, false);
+            return args.length === 0 ? declaredManagedType : getTypeAliasInstantiation(c, managedSym, args, undefined);
+        }
+    }
+    if ((declaredManagedType.objectFlags & 3 /* ObjectFlags.ClassOrInterface */) !== 0) {
+        const params = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c, managedSym);
+        if (params.length >= typeArguments.length) {
+            const args = fillMissingTypeArguments(c, typeArguments, params, typeArguments.length, false);
+            return createTypeReference(c, declaredManagedType, args);
+        }
+    }
+    return undefined;
+}
+/**
+ * The single property name of `JSX.ElementAttributesProperty` or `JSX.ElementChildrenAttribute`: `''` when
+ * the interface is empty, `InternalSymbolName.Missing` when it doesn't exist.
+ */
+function getNameFromJsxElementAttributesContainer(c, containerName, ns) {
+    if (ns !== undefined) {
+        const sym = getSymbolOfMeaning(c, getExportsOfSymbol(c, ns), containerName, 788968 /* SymbolFlags.Type */);
+        if (sym !== undefined) {
+            const props = getPropertiesOfType(c, getDeclaredTypeOfSymbol(c, sym));
+            if (props.length === 0)
+                return '';
+            if (props.length === 1)
+                return props[0].name;
+            if (declarationCount(sym) !== 0)
+                c.error(sym.declaration, 752 /* Diagnostics.The_global_type_JSX_0_may_not_have_more_than_one_property */, containerName);
+        }
+    }
+    return "\uFFFEmissing" /* InternalSymbolName.Missing */;
+}
+function getJsxElementPropertiesName(c, ns) {
+    return getNameFromJsxElementAttributesContainer(c, jsxElementAttributesPropertyName, ns);
+}
+export function getJsxElementChildrenPropertyName(c, ns) {
+    const jsx = c.compilerOptions.jsx;
+    // The automatic runtime always passes children as `children`.
+    if (jsx === JsxEmit.ReactJSX || jsx === JsxEmit.ReactJSXDev)
+        return 'children';
+    return getNameFromJsxElementAttributesContainer(c, jsxElementChildrenAttributeName, ns);
+}
+function getJsxLibraryManagedAttributes(c, ns) {
+    return ns !== undefined
+        ? getSymbolOfMeaning(c, getExportsOfSymbol(c, ns), jsxLibraryManagedAttributesName, 788968 /* SymbolFlags.Type */)
+        : undefined;
+}
+// ---- Intrinsic elements and props types
+/**
+ * The `JSX.IntrinsicElements` property or index signature for an intrinsic tag, recording which in the
+ * element's flags; `unknownSymbol` when neither exists.
+ */
+export function getIntrinsicTagSymbol(c, node) {
+    const links = elementLinks(c, node);
+    if (links.resolvedSymbol !== undefined)
+        return links.resolvedSymbol;
+    const intrinsicElementsType = getJsxType(c, jsxIntrinsicElementsName, node);
+    if (!isErrorType(c, intrinsicElementsType)) {
+        const tagName = getTagNameOf(node);
+        const propName = jsxNameText(tagName);
+        const intrinsicProp = getPropertyOfType(c, intrinsicElementsType, propName);
+        if (intrinsicProp !== undefined) {
+            links.jsxFlags |= 1 /* JsxFlags.IntrinsicNamedElement */;
+            links.resolvedSymbol = intrinsicProp;
+            return intrinsicProp;
+        }
+        const info = getApplicableIndexInfo(c, intrinsicElementsType, getStringLiteralType(c, propName));
+        if ((info !== undefined && info !== c.anyBaseTypeIndexInfo) ||
+            getApplicableIndexInfoForName(c, intrinsicElementsType, propName) !== undefined) {
+            links.jsxFlags |= 2 /* JsxFlags.IntrinsicIndexedElement */;
+            links.resolvedSymbol = intrinsicElementsType.symbol ?? c.unknownSymbol;
+            return links.resolvedSymbol;
+        }
+        c.error(node, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, propName, 'JSX.' + jsxIntrinsicElementsName);
+        links.resolvedSymbol = c.unknownSymbol;
+        return c.unknownSymbol;
+    }
+    if (c.noImplicitAny)
+        c.error(node, 1697 /* Diagnostics.JSX_element_implicitly_has_type_any_because_no_interface_JSX_0_exists */, jsxIntrinsicElementsName);
+    links.resolvedSymbol = c.unknownSymbol;
+    return c.unknownSymbol;
+}
+/** The props type of an intrinsic element. */
+function getIntrinsicAttributesTypeFromJsxOpeningLikeElement(c, node) {
+    const links = elementLinks(c, node);
+    if (links.resolvedJsxElementAttributesType !== undefined)
+        return links.resolvedJsxElementAttributesType;
+    const symbol = getIntrinsicTagSymbol(c, node);
+    let result = c.errorType;
+    if ((links.jsxFlags & 1 /* JsxFlags.IntrinsicNamedElement */) !== 0)
+        result = getTypeOfSymbol(c, symbol);
+    else if ((links.jsxFlags & 2 /* JsxFlags.IntrinsicIndexedElement */) !== 0) {
+        const info = getApplicableIndexInfoForName(c, getJsxType(c, jsxIntrinsicElementsName, node), jsxNameText(getTagNameOf(node)));
+        if (info !== undefined)
+            result = info.valueType;
+    }
+    links.resolvedJsxElementAttributesType = result;
+    return result;
+}
+function getIntrinsicAttributesTypeFromStringLiteralType(c, t, location) {
+    const intrinsicElementsType = getJsxType(c, jsxIntrinsicElementsName, location);
+    if (isErrorType(c, intrinsicElementsType))
+        return c.anyType;
+    const name = t.stringValue;
+    const intrinsicProp = getPropertyOfType(c, intrinsicElementsType, name);
+    if (intrinsicProp !== undefined)
+        return getTypeOfSymbol(c, intrinsicProp);
+    return getIndexTypeOfType(c, intrinsicElementsType, c.stringType);
+}
+/** A `(props: result) => JSX.Element` signature for an intrinsic element. */
+function createSignatureForJSXIntrinsic(c, node, result) {
+    return newJsxIntrinsicSignature(c, result, getJsxElementTypeForIntrinsic(c, node));
+}
+/** The return type of createSignatureForJSXIntrinsic: `JSX.Element` at `node`, or the error type. */
+function getJsxElementTypeForIntrinsic(c, node) {
+    let elementType = c.errorType;
+    const namespace = getJsxNamespaceAt(c, node);
+    if (namespace !== undefined) {
+        const typeSymbol = getSymbolOfMeaning(c, getExportsOfSymbol(c, namespace), jsxElementName, 788968 /* SymbolFlags.Type */);
+        if (typeSymbol !== undefined)
+            elementType = getDeclaredTypeOfSymbol(c, typeSymbol);
+    }
+    return elementType;
+}
+function newJsxIntrinsicSignature(c, result, elementType) {
+    const parameterSymbol = c.newSymbol(1 /* SymbolFlags.FunctionScopedVariable */, 'props');
+    c.symbolTypes.set(getSymbolId(parameterSymbol), result);
+    return c.newSignature(0 /* SignatureFlags.None */, undefined, [], undefined, [parameterSymbol], elementType, 1);
+}
+/**
+ * `getOrCreateTypeFromSignature(createSignatureForJSXIntrinsic(node, result))`, the type that
+ * getStaticTypeOfReferencedJsxConstructor gives an intrinsic element: `new (props: result) =>
+ * JSX.Element`. tsgo creates a new one for every element, which makes each element's
+ * `LibraryManagedAttributes<C, P>` a new instantiation; it is a function of the two types, so one is
+ * kept per pair.
+ */
+function getJsxIntrinsicConstructorType(c, node, result) {
+    const elementType = getJsxElementTypeForIntrinsic(c, node);
+    const key = result.id + ',' + elementType.id;
+    let t = c.jsx.intrinsicConstructorTypes.get(key);
+    if (t === undefined) {
+        t = getOrCreateTypeFromSignature(c, newJsxIntrinsicSignature(c, result, elementType));
+        c.jsx.intrinsicConstructorTypes.set(key, t);
+    }
+    return t;
+}
+function getJsxReferenceKind(c, node) {
+    const tagName = getTagNameOf(node);
+    if (isJsxIntrinsicTagName(tagName))
+        return 2 /* JsxReferenceKind.Mixed */;
+    const tagType = getApparentType(c, checkExpression(c, tagName));
+    if (getSignaturesOfType(c, tagType, 1 /* SignatureKind.Construct */).length !== 0)
+        return 0 /* JsxReferenceKind.Component */;
+    if (getSignaturesOfType(c, tagType, 0 /* SignatureKind.Call */).length !== 0)
+        return 1 /* JsxReferenceKind.Function */;
+    return 2 /* JsxReferenceKind.Mixed */;
+}
+function getUninstantiatedJsxSignaturesOfType(c, elementType, caller) {
+    if ((elementType.flags & 32 /* TypeFlags.String */) !== 0)
+        return [c.anySignature];
+    if ((elementType.flags & 1024 /* TypeFlags.StringLiteral */) !== 0) {
+        const intrinsicType = getIntrinsicAttributesTypeFromStringLiteralType(c, elementType, caller);
+        if (intrinsicType === undefined) {
+            c.error(caller, 516 /* Diagnostics.Property_0_does_not_exist_on_type_1 */, elementType.stringValue, 'JSX.' + jsxIntrinsicElementsName);
+            return [];
+        }
+        return [createSignatureForJSXIntrinsic(c, caller, intrinsicType)];
+    }
+    const apparentElemType = getApparentType(c, elementType);
+    // Prefer construct signatures.
+    let signatures = getSignaturesOfType(c, apparentElemType, 1 /* SignatureKind.Construct */);
+    if (signatures.length === 0)
+        signatures = getSignaturesOfType(c, apparentElemType, 0 /* SignatureKind.Call */);
+    if (signatures.length === 0 && (apparentElemType.flags & 134217728 /* TypeFlags.Union */) !== 0) {
+        const lists = [];
+        for (const t of typesOf(apparentElemType))
+            lists.push(getUninstantiatedJsxSignaturesOfType(c, t, caller));
+        signatures = getUnionSignatures(c, lists);
+    }
+    return signatures;
+}
+function getTypeOfFirstParameterOfSignatureWithFallback(c, sig, fallback) {
+    return sig.parameters.length > 0 ? getTypeAtPosition(c, sig, 0) : fallback;
+}
+/** The props type a signature expects of an element's attributes. */
+export function getEffectiveFirstArgumentForJsxSignature(c, signature, node) {
+    if (node.kind === 290 /* SyntaxKind.JsxOpeningFragment */ || getJsxReferenceKind(c, node) !== 0 /* JsxReferenceKind.Component */)
+        return getJsxPropsTypeFromCallSignature(c, signature, node);
+    return getJsxPropsTypeFromClassType(c, signature, node);
+}
+function getJsxPropsTypeFromCallSignature(c, sig, context) {
+    let propsType = getTypeOfFirstParameterOfSignatureWithFallback(c, sig, c.unknownType);
+    propsType = getJsxManagedAttributesFromLocatedAttributes(c, context, getJsxNamespaceAt(c, context), propsType);
+    const intrinsicAttribs = getJsxType(c, jsxIntrinsicAttributesName, context);
+    if (!isErrorType(c, intrinsicAttribs))
+        propsType = intersectTypes(c, intrinsicAttribs, propsType);
+    return propsType;
+}
+function getJsxPropsTypeFromClassType(c, sig, context) {
+    const ns = getJsxNamespaceAt(c, context);
+    const forcedLookupLocation = getJsxElementPropertiesName(c, ns);
+    let attributesType;
+    if (forcedLookupLocation === "\uFFFEmissing" /* InternalSymbolName.Missing */)
+        attributesType = getTypeOfFirstParameterOfSignatureWithFallback(c, sig, c.unknownType);
+    else if (forcedLookupLocation === '')
+        attributesType = getReturnTypeOfSignature(c, sig);
+    else {
+        attributesType = getJsxPropsTypeForSignatureFromMember(c, sig, forcedLookupLocation);
+        if (attributesType === undefined && getAttributesOf(context).properties.nodes.length !== 0)
+            c.error(context, 751 /* Diagnostics.JSX_element_class_does_not_support_attributes_because_it_does_not_have_a_0_property */, forcedLookupLocation);
+    }
+    if (attributesType === undefined)
+        return c.unknownType;
+    attributesType = getJsxManagedAttributesFromLocatedAttributes(c, context, ns, attributesType);
+    if ((attributesType.flags & 1 /* TypeFlags.Any */) !== 0)
+        return attributesType;
+    let apparentAttributesType = attributesType;
+    const intrinsicClassAttribs = getJsxType(c, jsxIntrinsicClassAttributesName, context);
+    if (!isErrorType(c, intrinsicClassAttribs)) {
+        const typeParams = getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(c, intrinsicClassAttribs.symbol);
+        const hostClassType = getReturnTypeOfSignature(c, sig);
+        let libraryManagedAttributeType = intrinsicClassAttribs;
+        if (typeParams.length !== 0) {
+            const inferredArgs = fillMissingTypeArguments(c, [hostClassType], typeParams, getMinTypeArgumentCount(c, typeParams), false);
+            libraryManagedAttributeType = instantiateType(c, intrinsicClassAttribs, newTypeMapper(typeParams, inferredArgs));
+        }
+        apparentAttributesType = intersectTypes(c, libraryManagedAttributeType, apparentAttributesType);
+    }
+    const intrinsicAttribs = getJsxType(c, jsxIntrinsicAttributesName, context);
+    if (!isErrorType(c, intrinsicAttribs))
+        apparentAttributesType = intersectTypes(c, intrinsicAttribs, apparentAttributesType);
+    return apparentAttributesType;
+}
+function getJsxPropsTypeForSignatureFromMember(c, sig, name) {
+    if (sig.composite !== undefined) {
+        // `props` of a union or intersection signature is an input: intersect the members' instance props.
+        const results = [];
+        for (const signature of sig.composite.signatures) {
+            const instance = getReturnTypeOfSignature(c, signature);
+            if ((instance.flags & 1 /* TypeFlags.Any */) !== 0)
+                return instance;
+            const propType = getTypeOfPropertyOfType(c, instance, name);
+            if (propType === undefined)
+                return undefined;
+            results.push(propType);
+        }
+        return getIntersectionType(c, results);
+    }
+    const instanceType = getReturnTypeOfSignature(c, sig);
+    if ((instanceType.flags & 1 /* TypeFlags.Any */) !== 0)
+        return instanceType;
+    return getTypeOfPropertyOfType(c, instanceType, name);
+}
+function getJsxManagedAttributesFromLocatedAttributes(c, context, ns, attributesType) {
+    const managedSym = getJsxLibraryManagedAttributes(c, ns);
+    if (managedSym !== undefined) {
+        const ctorType = getStaticTypeOfReferencedJsxConstructor(c, context);
+        const result = instantiateAliasOrInterfaceWithDefaults(c, managedSym, [ctorType, attributesType]);
+        if (result !== undefined)
+            return result;
+    }
+    return attributesType;
+}
+function getStaticTypeOfReferencedJsxConstructor(c, context) {
+    if (context.kind === 290 /* SyntaxKind.JsxOpeningFragment */)
+        return getJSXFragmentType(c, context);
+    const tagName = getTagNameOf(context);
+    if (isJsxIntrinsicTagName(tagName)) {
+        const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(c, context);
+        return getJsxIntrinsicConstructorType(c, context, result);
+    }
+    const tagType = checkExpressionCached(c, tagName);
+    if ((tagType.flags & 1024 /* TypeFlags.StringLiteral */) !== 0) {
+        const result = getIntrinsicAttributesTypeFromStringLiteralType(c, tagType, context);
+        if (result === undefined)
+            return c.errorType;
+        return getJsxIntrinsicConstructorType(c, context, result);
+    }
+    return tagType;
+}
+/** The type of the fragment factory, such as `React.Fragment`. */
+function getJSXFragmentType(c, node) {
+    const links = fileLinks(c, getSourceFileOfNode(node));
+    if (links.jsxFragmentType !== undefined)
+        return links.jsxFragmentType;
+    const jsxFragmentFactoryName = getJsxNamespace(c, node);
+    // `null` is allowed as the fragment factory.
+    const shouldResolveFactoryReference = (c.compilerOptions.jsx === JsxEmit.React ||
+        (c.compilerOptions.jsxFragmentFactory !== undefined && c.compilerOptions.jsxFragmentFactory !== '')) &&
+        jsxFragmentFactoryName !== 'null';
+    if (!shouldResolveFactoryReference) {
+        links.jsxFragmentType = c.anyType;
+        return c.anyType;
+    }
+    let jsxFactorySymbol = getJsxNamespaceContainerForImplicitImport(c, node);
+    if (jsxFactorySymbol === undefined) {
+        const shouldModuleRefErr = c.compilerOptions.jsx !== JsxEmit.Preserve && c.compilerOptions.jsx !== JsxEmit.ReactNative;
+        let flags = 111551 /* SymbolFlags.Value */;
+        if (!shouldModuleRefErr)
+            flags &= ~384 /* SymbolFlags.Enum */;
+        jsxFactorySymbol = resolveName(c, node, jsxFragmentFactoryName, flags, 999 /* Diagnostics.Using_JSX_fragments_requires_fragment_factory_0_to_be_in_scope_but_it_could_not_be_found */, true, false);
+    }
+    if (jsxFactorySymbol === undefined) {
+        links.jsxFragmentType = c.errorType;
+        return c.errorType;
+    }
+    if (jsxFactorySymbol.name === 'Fragment') {
+        links.jsxFragmentType = getTypeOfSymbol(c, jsxFactorySymbol);
+        return links.jsxFragmentType;
+    }
+    const resolvedAlias = (jsxFactorySymbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0 ? resolveAlias(c, jsxFactorySymbol) : jsxFactorySymbol;
+    const typeSymbol = getSymbolOfMeaning(c, getExportsOfSymbol(c, resolvedAlias), 'Fragment', 2 /* SymbolFlags.BlockScopedVariable */);
+    links.jsxFragmentType = typeSymbol !== undefined ? getTypeOfSymbol(c, typeSymbol) : c.errorType;
+    return links.jsxFragmentType;
+}
+// ---- Attributes and children
+export function checkJsxAttribute(c, node, checkMode) {
+    const initializer = node.initializer;
+    // `<Elem attr />` is `<Elem attr={true} />`.
+    return initializer !== undefined ? checkExpressionForMutableLocationEx(c, initializer, checkMode) : c.trueType;
+}
+export function checkJsxChildren(c, node, checkMode) {
+    const childTypes = [];
+    for (const child of getChildrenOf(node)) {
+        // Whitespace-only text isn't a child in React.
+        if (child.kind === 11 /* SyntaxKind.JsxText */) {
+            if (!child.containsOnlyTriviaWhiteSpaces)
+                childTypes.push(c.stringType);
+        }
+        else if (child.kind === 295 /* SyntaxKind.JsxExpression */ && child.expression === undefined)
+            continue;
+        else
+            childTypes.push(checkExpressionForMutableLocationEx(c, child, checkMode));
+    }
+    return childTypes;
+}
+function parentHasSemanticJsxChildren(openingLikeElement) {
+    const parent = openingLikeElement.parent;
+    if (parent === undefined)
+        return false;
+    if (parent.kind === 285 /* SyntaxKind.JsxElement */ && parent.openingElement === openingLikeElement)
+        return getSemanticJsxChildren(parent.children.nodes).length !== 0;
+    if (parent.kind === 289 /* SyntaxKind.JsxFragment */ && parent.openingFragment === openingLikeElement)
+        return getSemanticJsxChildren(parent.children.nodes).length !== 0;
+    return false;
+}
+function createJsxAttributesType(c, symbol, table, objectFlags) {
+    const result = createAnonymousType(c, symbol, table, [], [], []);
+    result.objectFlags |=
+        objectFlags | 8192 /* ObjectFlags.FreshLiteral */ | 128 /* ObjectFlags.ObjectLiteral */ | 131072 /* ObjectFlags.ContainsObjectOrArrayLiteral */;
+    return result;
+}
+/** The object type of an element's attributes and children, like an object literal's. */
+export function createJsxAttributesTypeFromAttributesProperty(c, openingLikeElement, checkMode) {
+    const allAttributesTable = c.strictNullChecks ? new Map() : undefined;
+    let attributesTable = new Map();
+    let attributesSymbol = undefined;
+    let attributeParent = openingLikeElement;
+    let spread = c.emptyJsxObjectType;
+    let hasSpreadAnyType = false;
+    let typeToIntersect = undefined;
+    let explicitlySpecifyChildrenAttribute = false;
+    let objectFlags = 2048 /* ObjectFlags.JsxAttributes */;
+    const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(c, getJsxNamespaceAt(c, openingLikeElement));
+    if (openingLikeElement.kind !== 290 /* SyntaxKind.JsxOpeningFragment */) {
+        const attributes = getAttributesOf(openingLikeElement);
+        attributesSymbol = attributes.symbol;
+        attributeParent = attributes;
+        const contextualType = getContextualType(c, attributes);
+        for (const attributeDecl of attributes.properties.nodes) {
+            if (attributeDecl.kind === 292 /* SyntaxKind.JsxAttribute */) {
+                const member = getSymbol(attributeDecl);
+                const exprType = checkJsxAttribute(c, attributeDecl, checkMode);
+                objectFlags |= exprType.objectFlags & 458752 /* ObjectFlags.PropagatingFlags */;
+                const attributeSymbol = c.newSymbol(4 /* SymbolFlags.Property */ | member.flags, member.name);
+                copyDeclarations(attributeSymbol, member);
+                attributeSymbol.parent = member.parent;
+                if (member.valueDeclaration !== undefined)
+                    attributeSymbol.valueDeclaration = member.valueDeclaration;
+                const id = getSymbolId(attributeSymbol);
+                c.symbolTypes.set(id, exprType);
+                c.symbolTargets.set(id, member);
+                attributesTable.set(attributeSymbol.name, attributeSymbol);
+                if (allAttributesTable !== undefined)
+                    allAttributesTable.set(attributeSymbol.name, attributeSymbol);
+                if (jsxNameText(attributeDecl.name) === jsxChildrenPropertyName)
+                    explicitlySpecifyChildrenAttribute = true;
+                if (contextualType !== undefined)
+                    checkDeprecatedJsxAttribute(c, contextualType, attributeDecl);
+                if (contextualType !== undefined &&
+                    (checkMode & 2 /* CheckMode.Inferential */) !== 0 &&
+                    (checkMode & 4 /* CheckMode.SkipContextSensitive */) === 0 &&
+                    isContextSensitive(c, attributeDecl)) {
+                    // Inferences flowing between context-sensitive attributes are made before fixing.
+                    const inferenceContext = getInferenceContext(c, attributes);
+                    const initializer = attributeDecl.initializer;
+                    if (inferenceContext !== undefined && initializer !== undefined)
+                        addIntraExpressionInferenceSite(inferenceContext, getExpression(initializer), exprType);
+                }
+            }
+            else {
+                if (attributesTable.size !== 0) {
+                    // Attribute objects are fresh, and so are spreads after the first one.
+                    objectFlags |= 8192 /* ObjectFlags.FreshLiteral */;
+                    spread = getSpreadType(c, spread, createJsxAttributesType(c, attributesSymbol, attributesTable, objectFlags), attributesSymbol, objectFlags, false);
+                    attributesTable = new Map();
+                }
+                const expression = attributeDecl.expression;
+                const exprType = getReducedType(c, checkExpressionEx(c, expression, checkMode & 2 /* CheckMode.Inferential */));
+                if ((exprType.flags & 1 /* TypeFlags.Any */) !== 0)
+                    hasSpreadAnyType = true;
+                if (isValidSpreadType(c, exprType)) {
+                    spread = getSpreadType(c, spread, exprType, attributesSymbol, objectFlags, false);
+                    if (allAttributesTable !== undefined)
+                        checkSpreadPropOverrides(c, exprType, allAttributesTable, attributeDecl);
+                }
+                else {
+                    c.error(expression, 830 /* Diagnostics.Spread_types_may_only_be_created_from_object_types */);
+                    typeToIntersect =
+                        typeToIntersect !== undefined ? getIntersectionType(c, [typeToIntersect, exprType]) : exprType;
+                }
+            }
+        }
+        if (!hasSpreadAnyType && attributesTable.size !== 0) {
+            objectFlags |= 8192 /* ObjectFlags.FreshLiteral */;
+            spread = getSpreadType(c, spread, createJsxAttributesType(c, attributesSymbol, attributesTable, objectFlags), attributesSymbol, objectFlags, false);
+        }
+    }
+    if (parentHasSemanticJsxChildren(openingLikeElement)) {
+        const childTypes = checkJsxChildren(c, openingLikeElement.parent, checkMode);
+        if (!hasSpreadAnyType && jsxChildrenPropertyName !== "\uFFFEmissing" /* InternalSymbolName.Missing */ && jsxChildrenPropertyName !== '') {
+            // Children overwrite a `children` attribute; one from a spread isn't reported.
+            if (explicitlySpecifyChildrenAttribute)
+                c.error(attributeParent, 842 /* Diagnostics.X_0_are_specified_twice_The_attribute_named_0_will_be_overwritten */, jsxChildrenPropertyName);
+            let childrenContextualType = undefined;
+            if (openingLikeElement.kind === 287 /* SyntaxKind.JsxOpeningElement */) {
+                const contextualType = getApparentTypeOfContextualType(c, getAttributesOf(openingLikeElement));
+                if (contextualType !== undefined)
+                    childrenContextualType = getTypeOfPropertyOfContextualType(c, contextualType, jsxChildrenPropertyName);
+            }
+            const childrenPropSymbol = c.newSymbol(4 /* SymbolFlags.Property */, jsxChildrenPropertyName);
+            const id = getSymbolId(childrenPropSymbol);
+            if (childTypes.length === 1)
+                c.symbolTypes.set(id, childTypes[0]);
+            else if (childrenContextualType !== undefined && someType(childrenContextualType, (t) => isTupleLikeType(c, t)))
+                c.symbolTypes.set(id, createTupleType(c, childTypes));
+            else
+                c.symbolTypes.set(id, createArrayType(c, getUnionType(c, childTypes)));
+            // A property signature in the attributes declares the synthetic `children` property, so it is
+            // checked as an excess property like the attributes.
+            const childrenDeclaration = new PropertySignatureDeclaration(undefined, new Identifier(jsxChildrenPropertyName), undefined, undefined, undefined);
+            childrenDeclaration.parent = attributeParent;
+            childrenDeclaration.symbol = childrenPropSymbol;
+            childrenPropSymbol.valueDeclaration = childrenDeclaration;
+            const childPropMap = new Map();
+            childPropMap.set(jsxChildrenPropertyName, childrenPropSymbol);
+            spread = getSpreadType(c, spread, createAnonymousType(c, attributesSymbol, childPropMap, [], [], []), attributesSymbol, objectFlags | getPropagatingFlagsOfTypes(childTypes, 0 /* TypeFlags.None */), false);
+        }
+    }
+    if (hasSpreadAnyType)
+        return c.anyType;
+    if (typeToIntersect !== undefined)
+        return spread !== c.emptyJsxObjectType ? getIntersectionType(c, [typeToIntersect, spread]) : typeToIntersect;
+    if (spread === c.emptyJsxObjectType)
+        return createJsxAttributesType(c, attributesSymbol, attributesTable, objectFlags);
+    return spread;
+}
+export function isTupleLikeType(c, t) {
+    if (isTupleType(t) || getPropertyOfType(c, t, '0') !== undefined)
+        return true;
+    if (isArrayLikeType(c, t)) {
+        const lengthType = getTypeOfPropertyOfType(c, t, 'length');
+        if (lengthType !== undefined)
+            return everyType(lengthType, (u) => (u.flags & 2048 /* TypeFlags.NumberLiteral */) !== 0);
+    }
+    return false;
+}
+export function isArrayOrTupleLikeType(c, t) {
+    return isArrayLikeType(c, t) || isTupleLikeType(c, t);
+}
+// ---- Signature resolution
+/** The attributes argument of an element, if it has attributes or children. */
+export function getEffectiveJsxArguments(node) {
+    const attributes = getAttributesOf(node);
+    if (attributes.properties.nodes.length !== 0 ||
+        (node.kind === 287 /* SyntaxKind.JsxOpeningElement */ && node.parent.children.nodes.length !== 0))
+        return [attributes];
+    return [];
+}
+/** Whether `signature` accepts the element's attributes, reporting why not when `reportErrors`. */
+export function checkApplicableSignatureForJsxCallLikeElement(c, node, signature, relation, checkMode, reportErrors, diagnosticOutput) {
+    // Function components get props, context and an updater; only props come from attributes.
+    const paramType = getEffectiveFirstArgumentForJsxSignature(c, signature, node);
+    const attributesType = node.kind === 290 /* SyntaxKind.JsxOpeningFragment */
+        ? createJsxAttributesTypeFromAttributesProperty(c, node, 0 /* CheckMode.Normal */)
+        : checkExpressionWithContextualType(c, getAttributesOf(node), paramType, undefined, checkMode);
+    const checkAttributesType = (checkMode & 4 /* CheckMode.SkipContextSensitive */) !== 0
+        ? getRegularTypeOfObjectLiteral(c, attributesType)
+        : attributesType;
+    if (!checkTagNameDoesNotExpectTooManyArguments(c, node, reportErrors, diagnosticOutput))
+        return false;
+    const errorNode = reportErrors
+        ? node.kind === 290 /* SyntaxKind.JsxOpeningFragment */
+            ? node
+            : getTagNameOf(node)
+        : undefined;
+    const attributes = node.kind === 290 /* SyntaxKind.JsxOpeningFragment */ ? undefined : getAttributesOf(node);
+    return checkTypeRelatedToAndOptionallyElaborate(c, checkAttributesType, paramType, relation, errorNode, attributes, undefined, diagnosticOutput);
+}
+/** Whether a function component's required parameters fit what the factory passes it. */
+function checkTagNameDoesNotExpectTooManyArguments(c, node, reportErrors, diagnosticOutput) {
+    // The automatic runtime's factories aren't looked at.
+    if (getJsxNamespaceContainerForImplicitImport(c, node) !== undefined)
+        return true;
+    if (node.kind === 290 /* SyntaxKind.JsxOpeningFragment */)
+        return true;
+    const tagName = getTagNameOf(node);
+    if (isJsxIntrinsicTagName(tagName))
+        return true;
+    const tagType = checkExpression(c, tagName);
+    const tagCallSignatures = getSignaturesOfType(c, tagType, 0 /* SignatureKind.Call */);
+    if (tagCallSignatures.length === 0)
+        return true;
+    const factory = getJsxFactoryEntity(c, node);
+    if (factory === undefined)
+        return true;
+    const factorySymbol = resolveEntityName(c, factory, 111551 /* SymbolFlags.Value */, true, false, node);
+    if (factorySymbol === undefined)
+        return true;
+    const callSignatures = getSignaturesOfType(c, getTypeOfSymbol(c, factorySymbol), 0 /* SignatureKind.Call */);
+    if (callSignatures.length === 0)
+        return true;
+    let hasFirstParamSignatures = false;
+    let maxParamCount = 0;
+    // Some first parameter must expect a function component that takes the element's arguments.
+    for (const sig of callSignatures) {
+        const firstParam = getTypeAtPosition(c, sig, 0);
+        for (const paramSig of getSignaturesOfType(c, firstParam, 0 /* SignatureKind.Call */)) {
+            hasFirstParamSignatures = true;
+            if (hasEffectiveRestParameter(c, paramSig))
+                return true;
+            maxParamCount = Math.max(maxParamCount, getParameterCount(c, paramSig));
+        }
+    }
+    // Generic factories have no signatures to look at.
+    if (!hasFirstParamSignatures)
+        return true;
+    let absoluteMinArgCount = Number.MAX_SAFE_INTEGER;
+    for (const tagSig of tagCallSignatures)
+        absoluteMinArgCount = Math.min(absoluteMinArgCount, getMinArgumentCount(c, tagSig));
+    if (absoluteMinArgCount <= maxParamCount)
+        return true;
+    if (reportErrors) {
+        const diagnostic = createDiagnosticForNode(tagName, 1381 /* Diagnostics.Tag_0_expects_at_least_1_arguments_but_the_JSX_factory_2_provides_at_most_3 */, [entityNameToString(tagName), String(absoluteMinArgCount), entityNameToString(factory), String(maxParamCount)]);
+        const tagNameSymbol = getSymbolOfTagName(c, tagName);
+        if (tagNameSymbol !== undefined && tagNameSymbol.valueDeclaration !== undefined)
+            diagnostic.addRelatedInfo(createDiagnosticForNode(tagNameSymbol.valueDeclaration, 860 /* Diagnostics.X_0_is_declared_here */, [
+                entityNameToString(tagName),
+            ]));
+        reportDiagnostic(c, diagnostic, diagnosticOutput);
+    }
+    return false;
+}
+function getSymbolOfTagName(c, tagName) {
+    if (tagName.kind === 79 /* SyntaxKind.Identifier */ || tagName.kind === 212 /* SyntaxKind.PropertyAccessExpression */)
+        return resolveEntityName(c, tagName, 111551 /* SymbolFlags.Value */, true, false, undefined);
+    return undefined;
+}
+function reportDiagnostic(c, diagnostic, output) {
+    if (output !== undefined)
+        output.push(diagnostic);
+    else
+        c.addDiagnostic(diagnostic);
+}
+export function resolveJsxOpeningLikeElement(c, node, checkMode) {
+    const isJsxOpenFragment = node.kind === 290 /* SyntaxKind.JsxOpeningFragment */;
+    let exprTypes;
+    if (!isJsxOpenFragment) {
+        const tagName = getTagNameOf(node);
+        if (isJsxIntrinsicTagName(tagName)) {
+            const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(c, node);
+            const fakeSignature = createSignatureForJSXIntrinsic(c, node, result);
+            const attributes = getAttributesOf(node);
+            checkTypeAssignableToAndOptionallyElaborateJsx(c, checkExpressionWithContextualType(c, attributes, getEffectiveFirstArgumentForJsxSignature(c, fakeSignature, node), undefined, 0 /* CheckMode.Normal */), result, tagName, attributes);
+            const typeArguments = getTypeArgumentListOf(node);
+            if (typeArguments !== undefined && typeArguments.nodes.length !== 0) {
+                for (const t of typeArguments.nodes)
+                    checkSourceElement(c, t);
+                const file = getSourceFileOfNode(node);
+                c.addDiagnostic(new Diagnostic(file.diagnosticFile(), skipTrivia(file.text, typeArguments.pos), typeArguments.end, 712 /* Diagnostics.Expected_0_type_arguments_but_got_1 */, ['0', String(typeArguments.nodes.length)]));
+            }
+            return fakeSignature;
+        }
+        exprTypes = checkExpression(c, tagName);
+    }
+    else
+        exprTypes = getJSXFragmentType(c, node);
+    const apparentType = getApparentType(c, exprTypes);
+    if (isErrorType(c, apparentType))
+        return resolveErrorCall(c, node);
+    const signatures = getUninstantiatedJsxSignaturesOfType(c, exprTypes, node);
+    if (isUntypedFunctionCall(c, exprTypes, apparentType, signatures.length))
+        return resolveUntypedCall(c, node);
+    if (signatures.length === 0) {
+        const errorNode = isJsxOpenFragment ? node : getTagNameOf(node);
+        c.error(errorNode, 749 /* Diagnostics.JSX_element_type_0_does_not_have_any_construct_or_call_signatures */, getTextOfNode(errorNode));
+        return resolveErrorCall(c, node);
+    }
+    return resolveCall(c, node, signatures, checkMode, 0 /* SignatureFlags.None */, undefined);
+}
+function checkTypeAssignableToAndOptionallyElaborateJsx(c, source, target, errorNode, expr) {
+    return checkTypeRelatedToAndOptionallyElaborate(c, source, target, c.assignableRelation, errorNode, expr, undefined, undefined);
+}
+function isUntypedFunctionCall(c, funcType, apparentFuncType, numCallSignatures) {
+    if ((funcType.flags & 1 /* TypeFlags.Any */) !== 0)
+        return true;
+    if ((apparentFuncType.flags & 1 /* TypeFlags.Any */) !== 0)
+        return true;
+    if ((funcType.flags & 524288 /* TypeFlags.TypeParameter */) !== 0)
+        return false;
+    return (numCallSignatures === 0 &&
+        (apparentFuncType.flags & 134217728 /* TypeFlags.Union */) === 0 &&
+        (getReducedType(c, apparentFuncType).flags & 262144 /* TypeFlags.Never */) === 0 &&
+        isTypeAssignableTo(c, funcType, c.globalFunctionType));
+}
+function resolveUntypedCall(c, node) {
+    if (node.kind !== 290 /* SyntaxKind.JsxOpeningFragment */) {
+        // Type arguments are checked even though an untyped element can't accept them: they get their
+        // diagnostics and mark what they reference as used.
+        const typeArguments = getTypeArgumentListOf(node);
+        if (typeArguments !== undefined)
+            for (const t of typeArguments.nodes)
+                checkSourceElement(c, t);
+        checkExpression(c, getAttributesOf(node));
+    }
+    return c.anySignature;
+}
+function resolveErrorCall(c, node) {
+    resolveUntypedCall(c, node);
+    return c.unknownSignature;
+}
+/** The signature an element resolves to, computed once. */
+export function getResolvedJsxSignature(c, node) {
+    return getResolvedSignature(c, node, 0 /* CheckMode.Normal */);
+}
+/** Infers a generic component's type arguments from the element's attributes. */
+export function inferJsxTypeArguments(c, node, signature, checkMode, context) {
+    const paramType = getEffectiveFirstArgumentForJsxSignature(c, signature, node);
+    const checkAttrType = checkExpressionWithContextualType(c, getAttributesOf(node), paramType, context, checkMode);
+    inferTypes(c, context.inferences, checkAttrType, paramType, 0 /* InferencePriority.None */, false);
+    return getInferredTypes(c, context);
+}
+// ---- Checking
+/** Checks a JSX expression, element, fragment or attributes node. */
+export function checkJsx(c, node, checkMode) {
+    switch (node.kind) {
+        case 295 /* SyntaxKind.JsxExpression */:
+            return checkJsxExpression(c, node, checkMode);
+        case 285 /* SyntaxKind.JsxElement */:
+        case 286 /* SyntaxKind.JsxSelfClosingElement */: {
+            checkNodeDeferred(c, node);
+            return getJsxElementTypeAt(c, node);
+        }
+        case 289 /* SyntaxKind.JsxFragment */:
+            return checkJsxFragment(c, node);
+        case 293 /* SyntaxKind.JsxAttributes */:
+            return createJsxAttributesTypeFromAttributesProperty(c, node.parent, checkMode);
+    }
+    return c.errorType;
+}
+function checkJsxExpression(c, node, checkMode) {
+    checkGrammarJsxExpression(c, node);
+    if (node.expression === undefined)
+        return c.errorType;
+    const t = checkExpressionEx(c, node.expression, checkMode);
+    if (node.dotDotDotToken !== undefined && t !== c.anyType && !isArrayType(c, t))
+        c.error(node, 753 /* Diagnostics.JSX_spread_child_must_be_an_array_type */);
+    return t;
+}
+function checkJsxFragment(c, node) {
+    checkJsxOpeningLikeElementOrOpeningFragment(c, node.openingFragment);
+    // With a custom factory, fragments need a fragment factory too.
+    const file = getSourceFileOfNode(node);
+    const options = c.compilerOptions;
+    const hasFactory = options.jsxFactory !== undefined && options.jsxFactory !== '';
+    const hasFragmentFactory = options.jsxFragmentFactory !== undefined && options.jsxFragmentFactory !== '';
+    if (isJsxTransformEnabled(c) &&
+        (hasFactory || getPragma(file, 'jsx', 'factory') !== undefined) &&
+        !hasFragmentFactory &&
+        getPragma(file, 'jsxfrag', 'factory') === undefined)
+        c.error(node, hasFactory
+            ? 1819 /* Diagnostics.The_jsxFragmentFactory_compiler_option_must_be_provided_to_use_JSX_fragments_with_the_jsxFactory_compiler_option */
+            : 1820 /* Diagnostics.An_jsxFrag_pragma_is_required_when_using_an_jsx_pragma_with_JSX_fragments */);
+    checkJsxChildren(c, node, 0 /* CheckMode.Normal */);
+    const t = getJsxElementTypeAt(c, node);
+    return isErrorType(c, t) ? c.anyType : t;
+}
+/** The deferred check of an element: its signature, closing tag and children. */
+export function checkJsxElementDeferred(c, node) {
+    if (node.kind === 286 /* SyntaxKind.JsxSelfClosingElement */) {
+        checkJsxOpeningLikeElementOrOpeningFragment(c, node);
+        return;
+    }
+    const element = node;
+    checkJsxOpeningLikeElementOrOpeningFragment(c, element.openingElement);
+    const closingTagName = element.closingElement.tagName;
+    if (isJsxIntrinsicTagName(closingTagName))
+        getIntrinsicTagSymbol(c, element.closingElement);
+    else
+        checkExpression(c, closingTagName);
+    checkJsxChildren(c, node, 0 /* CheckMode.Normal */);
+}
+function checkJsxOpeningLikeElementOrOpeningFragment(c, node) {
+    const isNodeOpeningLikeElement = isJsxOpeningLikeElement(node);
+    if (isNodeOpeningLikeElement)
+        checkGrammarJsxElement(c, node);
+    checkJsxPreconditions(c, node);
+    markJsxAliasReferenced(c, node);
+    const sig = getResolvedJsxSignature(c, node);
+    checkDeprecatedSignature(c, sig, node);
+    if (!isNodeOpeningLikeElement)
+        return;
+    const elementTypeConstraint = getJsxElementTypeTypeAt(c, node);
+    if (elementTypeConstraint !== undefined) {
+        const tagName = getTagNameOf(node);
+        const tagType = isJsxIntrinsicTagName(tagName)
+            ? getStringLiteralType(c, jsxNameText(tagName))
+            : checkExpression(c, tagName);
+        const diagnostics = [];
+        if (!checkTypeRelatedTo(c, tagType, elementTypeConstraint, c.assignableRelation, tagName, 1868 /* Diagnostics.Its_type_0_is_not_a_valid_JSX_element_type */, diagnostics))
+            c.addDiagnostic(chainDiagnostic(diagnostics[0], 918 /* Diagnostics.X_0_cannot_be_used_as_a_JSX_component */, getTextOfNode(tagName)));
+    }
+    else
+        checkJsxReturnAssignableToAppropriateBound(c, getJsxReferenceKind(c, node), getReturnTypeOfSignature(c, sig), node);
+}
+function checkJsxPreconditions(c, errorNode) {
+    if (c.compilerOptions.jsx === undefined)
+        c.error(errorNode, 1807 /* Diagnostics.Cannot_use_JSX_unless_the_jsx_flag_is_provided */);
+    // A missing `JSX.Element` is the error type rather than absent, so TS2602 is never reported.
+}
+function checkJsxReturnAssignableToAppropriateBound(c, refKind, elemInstanceType, openingLikeElement) {
+    const diagnostics = [];
+    const tagName = getTagNameOf(openingLikeElement);
+    if (refKind === 1 /* JsxReferenceKind.Function */) {
+        const sfcReturnConstraint = getJsxStatelessElementTypeAt(c, openingLikeElement);
+        if (sfcReturnConstraint !== undefined)
+            checkTypeRelatedTo(c, elemInstanceType, sfcReturnConstraint, c.assignableRelation, tagName, 919 /* Diagnostics.Its_return_type_0_is_not_a_valid_JSX_element */, diagnostics);
+    }
+    else if (refKind === 0 /* JsxReferenceKind.Component */) {
+        const classConstraint = getJsxElementClassTypeAt(c, openingLikeElement);
+        if (classConstraint !== undefined)
+            checkTypeRelatedTo(c, elemInstanceType, classConstraint, c.assignableRelation, tagName, 920 /* Diagnostics.Its_instance_type_0_is_not_a_valid_JSX_element */, diagnostics);
+    }
+    else {
+        const sfcReturnConstraint = getJsxStatelessElementTypeAt(c, openingLikeElement);
+        const classConstraint = getJsxElementClassTypeAt(c, openingLikeElement);
+        if (sfcReturnConstraint === undefined || classConstraint === undefined)
+            return;
+        const combined = getUnionType(c, [sfcReturnConstraint, classConstraint]);
+        checkTypeRelatedTo(c, elemInstanceType, combined, c.assignableRelation, tagName, 921 /* Diagnostics.Its_element_type_0_is_not_a_valid_JSX_element */, diagnostics);
+    }
+    if (diagnostics.length !== 0)
+        c.addDiagnostic(chainDiagnostic(diagnostics[0], 918 /* Diagnostics.X_0_cannot_be_used_as_a_JSX_component */, getTextOfNode(tagName)));
+}
+/** Resolves the factory namespace, which must be in scope for the classic React transform. */
+function markJsxAliasReferenced(c, node) {
+    if (getJsxNamespaceContainerForImplicitImport(c, node) !== undefined)
+        return;
+    const jsxFactoryRefErr = c.compilerOptions.jsx === JsxEmit.React
+        ? 994 /* Diagnostics.This_JSX_tag_requires_0_to_be_in_scope_but_it_could_not_be_found */
+        : undefined;
+    const jsxFactoryNamespace = getJsxNamespace(c, node);
+    const jsxFactoryLocation = isJsxOpeningLikeElement(node) ? getTagNameOf(node) : node;
+    const shouldFactoryRefErr = c.compilerOptions.jsx !== JsxEmit.Preserve && c.compilerOptions.jsx !== JsxEmit.ReactNative;
+    let flags = 111551 /* SymbolFlags.Value */;
+    if (!shouldFactoryRefErr)
+        flags &= ~384 /* SymbolFlags.Enum */;
+    // `null` is allowed as the fragment factory.
+    if (!(node.kind === 290 /* SyntaxKind.JsxOpeningFragment */ && jsxFactoryNamespace === 'null'))
+        resolveName(c, jsxFactoryLocation, jsxFactoryNamespace, flags, jsxFactoryRefErr, true, false);
+    if (node.kind === 290 /* SyntaxKind.JsxOpeningFragment */) {
+        const file = getSourceFileOfNode(node);
+        const entity = getJsxFactoryEntity(c, file);
+        if (entity !== undefined)
+            resolveName(c, jsxFactoryLocation, getText(getFirstIdentifier(entity)), flags, jsxFactoryRefErr, true, false);
+    }
+}
+// ---- Grammar
+function checkGrammarJsxElement(c, node) {
+    checkGrammarJsxName(c, getTagNameOf(node));
+    checkGrammarTypeArguments(c, node, getTypeArgumentListOf(node));
+    const seen = new Set();
+    for (const attrNode of getAttributesOf(node).properties.nodes) {
+        if (attrNode.kind === 294 /* SyntaxKind.JsxSpreadAttribute */)
+            continue;
+        const attr = attrNode;
+        const textOfName = jsxNameText(attr.name);
+        if (seen.has(textOfName))
+            return grammarErrorOnNode(c, attr.name, 1805 /* Diagnostics.JSX_elements_cannot_have_multiple_attributes_with_the_same_name */);
+        seen.add(textOfName);
+        const initializer = attr.initializer;
+        if (initializer !== undefined &&
+            initializer.kind === 295 /* SyntaxKind.JsxExpression */ &&
+            initializer.expression === undefined)
+            return grammarErrorOnNode(c, initializer, 1804 /* Diagnostics.JSX_attributes_must_only_be_assigned_a_non_empty_expression */);
+    }
+    return false;
+}
+function checkGrammarJsxName(c, node) {
+    if (node.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
+        node.expression.kind === 296 /* SyntaxKind.JsxNamespacedName */)
+        return grammarErrorOnNode(c, node.expression, 776 /* Diagnostics.JSX_property_access_expressions_cannot_include_JSX_namespace_names */);
+    if (node.kind === 296 /* SyntaxKind.JsxNamespacedName */ &&
+        isJsxTransformEnabled(c) &&
+        !isIntrinsicJsxName(node.namespace.text))
+        return grammarErrorOnNode(c, node, 782 /* Diagnostics.React_components_cannot_include_JSX_namespace_names */);
+    return false;
+}
+function checkGrammarTypeArguments(c, node, typeArguments) {
+    if (typeArguments === undefined)
+        return false;
+    if (typeArguments.hasTrailingComma())
+        return grammarErrorAtPos(c, typeArguments.nodes[0], typeArguments.end - 1, 1, 5 /* Diagnostics.Trailing_comma_not_allowed */);
+    if (typeArguments.nodes.length === 0) {
+        const file = getSourceFileOfNode(node);
+        const start = typeArguments.pos - 1;
+        const end = skipTrivia(file.text, typeArguments.end) + 1;
+        return grammarErrorAtPos(c, file, start, end - start, 68 /* Diagnostics.Type_argument_list_cannot_be_empty */);
+    }
+    return false;
+}
+function checkGrammarJsxExpression(c, node) {
+    const expression = node.expression;
+    if (expression !== undefined &&
+        expression.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+        expression.operatorToken.kind === 27 /* SyntaxKind.CommaToken */)
+        return grammarErrorOnNode(c, expression, 1830 /* Diagnostics.JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array */);
+    return false;
+}
+// ---- Contextual types
+export function getContextualTypeForJsxExpression(c, node, contextFlags) {
+    const parent = node.parent;
+    if (parent.kind === 292 /* SyntaxKind.JsxAttribute */ || parent.kind === 294 /* SyntaxKind.JsxSpreadAttribute */)
+        return getContextualTypeEx(c, node, contextFlags);
+    if (parent.kind === 285 /* SyntaxKind.JsxElement */)
+        return getContextualTypeForChildJsxExpression(c, parent, node, contextFlags);
+    return undefined;
+}
+export function getContextualTypeForJsxAttribute(c, attribute, contextFlags) {
+    // While a function component's signature is tried, its attributes carry the parameter type.
+    if (attribute.kind === 292 /* SyntaxKind.JsxAttribute */) {
+        const attributesType = getApparentTypeOfContextualTypeEx(c, attribute.parent, contextFlags);
+        if (attributesType === undefined || (attributesType.flags & 1 /* TypeFlags.Any */) !== 0)
+            return undefined;
+        return getTypeOfPropertyOfContextualType(c, attributesType, jsxNameText(attribute.name));
+    }
+    return getContextualTypeEx(c, attribute.parent, contextFlags);
+}
+export function getContextualJsxElementAttributesType(c, node, contextFlags) {
+    if (node.kind === 287 /* SyntaxKind.JsxOpeningElement */) {
+        // Contextual types of an element's attributes are pushed onto the element, which spans the children.
+        // Cached contextual types were obtained without flags.
+        const index = findContextualNode(c, node.parent, contextFlags === 0 /* ContextFlags.None */);
+        if (index >= 0)
+            return c.inferenceCaches.contextualTypes[index];
+    }
+    const signature = c.resolvedSignatures.get(node.id) === c.resolvingSignature
+        ? c.resolvingSignature
+        : getResolvedJsxSignature(c, node);
+    return getEffectiveFirstArgumentForJsxSignature(c, signature, node);
+}
+function getContextualTypeForChildJsxExpression(c, node, child, contextFlags) {
+    const element = node;
+    const attributesType = getApparentTypeOfContextualTypeEx(c, element.openingElement.attributes, contextFlags);
+    // Children are the `children` attribute (named by `JSX.ElementChildrenAttribute`).
+    const jsxChildrenPropertyName = getJsxElementChildrenPropertyName(c, getJsxNamespaceAt(c, node));
+    if (attributesType === undefined ||
+        (attributesType.flags & 1 /* TypeFlags.Any */) !== 0 ||
+        jsxChildrenPropertyName === "\uFFFEmissing" /* InternalSymbolName.Missing */ ||
+        jsxChildrenPropertyName === '')
+        return undefined;
+    const realChildren = getSemanticJsxChildren(element.children.nodes);
+    const childIndex = realChildren.indexOf(child);
+    const childFieldType = getTypeOfPropertyOfContextualType(c, attributesType, jsxChildrenPropertyName);
+    if (childFieldType === undefined)
+        return undefined;
+    if (realChildren.length === 1)
+        return childFieldType;
+    return mapTypeEx(c, childFieldType, (t) => (isArrayLikeType(c, t) ? getIndexedAccessType(c, t, getNumberLiteralType(c, childIndex)) : t), true);
+}
+export function isJsxAttributesContextSensitive(c, node) {
+    for (const p of node.properties.nodes)
+        if (isContextSensitive(c, p))
+            return true;
+    if (node.parent.kind === 287 /* SyntaxKind.JsxOpeningElement */)
+        for (const child of node.parent.parent.children.nodes)
+            if (isContextSensitive(c, child))
+                return true;
+    return false;
+}
+// ---- Elaboration
+/** A child of an element that an error can be reported on. */
+class JsxElaborationElement {
+    errorNode;
+    innerExpression;
+    nameType;
+    isText;
+    constructor(errorNode, innerExpression, nameType, 
+    /** Text children report this message instead of a relation error. */
+    isText) {
+        this.errorNode = errorNode;
+        this.innerExpression = innerExpression;
+        this.nameType = nameType;
+        this.isText = isText;
+    }
+}
+function getElaborationElementForJsxChild(child, nameType) {
+    switch (child.kind) {
+        case 295 /* SyntaxKind.JsxExpression */:
+            return new JsxElaborationElement(child, child.expression, nameType, false);
+        case 11 /* SyntaxKind.JsxText */:
+            // Whitespace-only text isn't a child.
+            if (child.containsOnlyTriviaWhiteSpaces)
+                return undefined;
+            return new JsxElaborationElement(child, undefined, nameType, true);
+    }
+    return new JsxElaborationElement(child, child, nameType, false);
+}
+/** Reports attribute and children errors at the attributes and children themselves. */
+export function elaborateJsxComponents(c, node, source, target, relation, diagnosticOutput) {
+    let reportedError = false;
+    for (const prop of node.properties.nodes) {
+        if (prop.kind === 294 /* SyntaxKind.JsxSpreadAttribute */)
+            continue;
+        const attr = prop;
+        const name = jsxNameText(attr.name);
+        if (isHyphenatedJsxName(name))
+            continue;
+        const nameType = getStringLiteralType(c, name);
+        reportedError =
+            elaborateElement(c, source, target, relation, attr.name, attr.initializer, nameType, undefined, undefined, [], diagnosticOutput) || reportedError;
+    }
+    const opening = node.parent;
+    if (opening.kind !== 287 /* SyntaxKind.JsxOpeningElement */ || opening.parent.kind !== 285 /* SyntaxKind.JsxElement */)
+        return reportedError;
+    const containingElement = opening.parent;
+    let childrenPropName = getJsxElementChildrenPropertyName(c, getJsxNamespaceAt(c, node));
+    if (childrenPropName === "\uFFFEmissing" /* InternalSymbolName.Missing */)
+        childrenPropName = 'children';
+    const childrenNameType = getStringLiteralType(c, childrenPropName);
+    const childrenTargetType = getIndexedAccessType(c, target, childrenNameType);
+    const validChildren = getSemanticJsxChildren(containingElement.children.nodes);
+    if (validChildren.length === 0)
+        return reportedError;
+    const moreThanOneRealChildren = validChildren.length > 1;
+    let arrayLikeTargetParts;
+    let nonArrayLikeTargetParts;
+    const iterableType = getGlobalIterableType(c, false);
+    if (iterableType !== c.emptyGenericType) {
+        const anyIterable = createTypeFromGenericGlobalType(c, iterableType, [c.anyType, c.anyType, c.anyType]);
+        arrayLikeTargetParts = filterType(c, childrenTargetType, (t) => isTypeAssignableTo(c, t, anyIterable));
+        nonArrayLikeTargetParts = filterType(c, childrenTargetType, (t) => !isTypeAssignableTo(c, t, anyIterable));
+    }
+    else {
+        arrayLikeTargetParts = filterType(c, childrenTargetType, (t) => isArrayOrTupleLikeType(c, t));
+        nonArrayLikeTargetParts = filterType(c, childrenTargetType, (t) => !isArrayOrTupleLikeType(c, t));
+    }
+    const textMessage = 879 /* Diagnostics.X_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2 */;
+    const textArgs = [
+        getTextOfNode(opening.kind === 287 /* SyntaxKind.JsxOpeningElement */ ? getTagNameOf(opening) : opening),
+        childrenPropName,
+        typeToString(c, childrenTargetType),
+    ];
+    if (moreThanOneRealChildren) {
+        if (arrayLikeTargetParts !== c.neverType) {
+            const realSource = createTupleType(c, checkJsxChildren(c, containingElement, 0 /* CheckMode.Normal */));
+            const children = [];
+            let memberOffset = 0;
+            const allChildren = containingElement.children.nodes;
+            for (let i = 0; i < allChildren.length; i++) {
+                const e = getElaborationElementForJsxChild(allChildren[i], getNumberLiteralType(c, i - memberOffset));
+                if (e !== undefined)
+                    children.push(e);
+                else
+                    memberOffset++;
+            }
+            reportedError =
+                elaborateIterableOrArrayLikeTargetElementwise(c, children, realSource, arrayLikeTargetParts, relation, textMessage, textArgs, diagnosticOutput) || reportedError;
+        }
+        else if (!isTypeRelatedTo(c, getIndexedAccessType(c, source, childrenNameType), childrenTargetType, relation)) {
+            // Arity errors are reported both directly and through the output.
+            const diagnostic = c.error(containingElement.openingElement.tagName, 878 /* Diagnostics.This_JSX_tag_s_0_prop_expects_a_single_child_of_type_1_but_multiple_children_were_provided */, childrenPropName, typeToString(c, childrenTargetType));
+            reportDiagnostic(c, diagnostic, diagnosticOutput);
+            reportedError = true;
+        }
+    }
+    else if (nonArrayLikeTargetParts !== c.neverType) {
+        const e = getElaborationElementForJsxChild(validChildren[0], childrenNameType);
+        if (e !== undefined)
+            reportedError =
+                elaborateElement(c, source, target, relation, e.errorNode, e.innerExpression, e.nameType, undefined, e.isText ? textMessage : undefined, textArgs, diagnosticOutput) || reportedError;
+    }
+    else if (!isTypeRelatedTo(c, getIndexedAccessType(c, source, childrenNameType), childrenTargetType, relation)) {
+        const diagnostic = c.error(containingElement.openingElement.tagName, 877 /* Diagnostics.This_JSX_tag_s_0_prop_expects_type_1_which_requires_multiple_children_but_only_a_single_child_was_provided */, childrenPropName, typeToString(c, childrenTargetType));
+        reportDiagnostic(c, diagnostic, diagnosticOutput);
+        reportedError = true;
+    }
+    return reportedError;
+}
+function elaborateIterableOrArrayLikeTargetElementwise(c, elements, source, target, relation, textMessage, textArgs, diagnosticOutput) {
+    const tupleOrArrayLikeTargetParts = filterType(c, target, (t) => isArrayOrTupleLikeType(c, t));
+    const nonTupleOrArrayLikeTargetParts = filterType(c, target, (t) => !isArrayOrTupleLikeType(c, t));
+    // A non-array-like part means `Iterable` exists.
+    const iterationType = nonTupleOrArrayLikeTargetParts !== c.neverType
+        ? getIterationTypeOfIterable(c, 13 /* IterationUse.ForOf */, 0 /* IterationTypeKind.Yield */, nonTupleOrArrayLikeTargetParts, undefined)
+        : undefined;
+    let reportedError = false;
+    for (const e of elements) {
+        let targetPropType = iterationType;
+        const targetIndexedPropType = tupleOrArrayLikeTargetParts !== c.neverType
+            ? getBestMatchIndexedAccessTypeOrUndefined(c, source, tupleOrArrayLikeTargetParts, e.nameType)
+            : undefined;
+        if (targetIndexedPropType !== undefined && (targetIndexedPropType.flags & 33554432 /* TypeFlags.IndexedAccess */) === 0)
+            targetPropType =
+                iterationType !== undefined ? getUnionType(c, [iterationType, targetIndexedPropType]) : targetIndexedPropType;
+        if (targetPropType === undefined)
+            continue;
+        let sourcePropType = getIndexedAccessTypeOrUndefined(c, source, e.nameType, 0 /* AccessFlags.None */);
+        if (sourcePropType === undefined)
+            continue;
+        if (checkTypeRelatedTo(c, sourcePropType, targetPropType, relation, undefined, undefined, undefined))
+            continue;
+        const next = e.innerExpression;
+        const elaborated = next !== undefined &&
+            elaborateError(c, next, sourcePropType, targetPropType, relation, undefined, diagnosticOutput);
+        reportedError = true;
+        if (elaborated)
+            continue;
+        // Report on the child itself, with the expression's type when there is one.
+        const specificSource = next !== undefined
+            ? checkExpressionForMutableLocationWithContextualType(c, next, sourcePropType)
+            : sourcePropType;
+        if (e.isText) {
+            reportDiagnostic(c, createDiagnosticForNode(e.errorNode, textMessage, textArgs), diagnosticOutput);
+            continue;
+        }
+        if (c.exactOptionalPropertyTypes && isExactOptionalPropertyMismatch(c, specificSource, targetPropType)) {
+            reportDiagnostic(c, createDiagnosticForNode(e.errorNode, 583 /* Diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target */, [typeToString(c, specificSource), typeToString(c, targetPropType)]), diagnosticOutput);
+            continue;
+        }
+        const propName = getPropertyNameFromIndex(e.nameType);
+        const targetProp = propName !== undefined ? getPropertyOfType(c, tupleOrArrayLikeTargetParts, propName) : undefined;
+        const sourceProp = propName !== undefined ? getPropertyOfType(c, source, propName) : undefined;
+        const targetIsOptional = targetProp !== undefined && (targetProp.flags & 16777216 /* SymbolFlags.Optional */) !== 0;
+        const sourceIsOptional = sourceProp !== undefined && (sourceProp.flags & 16777216 /* SymbolFlags.Optional */) !== 0;
+        targetPropType = removeMissingType(c, targetPropType, targetIsOptional);
+        sourcePropType = removeMissingType(c, sourcePropType, targetIsOptional && sourceIsOptional);
+        const result = checkTypeRelatedTo(c, specificSource, targetPropType, relation, e.errorNode, undefined, diagnosticOutput);
+        if (result && specificSource !== sourcePropType)
+            checkTypeRelatedTo(c, sourcePropType, targetPropType, relation, e.errorNode, undefined, diagnosticOutput);
+    }
+    return reportedError;
+}
+/** Suggests `htmlFor` for `for`, `className` for `class`, or a similar property name. */
+export function getSuggestedSymbolForNonexistentJSXAttribute(c, name, containingType) {
+    const properties = getPropertiesOfType(c, containingType);
+    const jsxSpecific = name === 'for' ? 'htmlFor' : name === 'class' ? 'className' : '';
+    if (jsxSpecific !== '')
+        for (const p of properties)
+            if (p.name === jsxSpecific)
+                return p;
+    return getSpellingSuggestionForName(c, name, properties, 111551 /* SymbolFlags.Value */);
+}