@contentful/experience-design-system-extraction 2.36.2-dev-build-a6f80ae6.0 → 2.36.2-dev-build-7907fec3.0

package/dist/src/extract/react.js

@@ -1,2069 +0,0 @@
-import { Node, SyntaxKind, } from 'ts-morph';
-import { extractAllowedValues, getNodeDefinitions, getTypeReferenceName, getTypeTargetDeclarations, getValueTargetDeclarations, getJsxTagNameNode, extractTsxComponents, getRenderableExports, isIntrinsicJsxElement, } from './tsx-shared.js';
-import { shouldBeSlot } from './slot-detection.js';
-import { extractAllowedComponentsFromTypeText, extractAllowedComponentsFromJsdoc } from './slot-allowed-components.js';
-import { getSourceLineMetadata } from './source-line-metadata.js';
-import { collectTypePredicateComponentReferences, collectRuntimeTypeCheckComponentReferences, collectRenderedComponentReferences, collectArrayMapRenderComponentReferences, } from './structural-slot-evidence.js';
-const REACT_ELEMENT_GENERIC_TEST = /(?:React\.)?ReactElement\s*<\s*[A-Za-z_$][\w$.]*/;
-function isReactElementGenericSlotType(typeText) {
-    return REACT_ELEMENT_GENERIC_TEST.test(typeText);
-}
-const PROP_WRAPPER_TYPE_NAMES = new Set(['ExpandProps']);
-const CHILD_WRAPPER_TYPE_NAMES = new Set(['PropsWithChildren']);
-const TRANSPARENT_POLYMORPHIC_TYPE_NAMES = new Set(['PolymorphicProps', 'PropsWithAs', 'PropsWithHTMLElement']);
-const EXPANDABLE_DOM_ATTRIBUTE_TYPE_NAMES = new Set([
-    'HTMLProps',
-    'HTMLAttributes',
-    'ImgHTMLAttributes',
-    'LiHTMLAttributes',
-    'AnchorHTMLAttributes',
-    'ButtonHTMLAttributes',
-    'InputHTMLAttributes',
-    'FieldsetHTMLAttributes',
-    'LabelHTMLAttributes',
-    'SelectHTMLAttributes',
-    'SVGAttributes',
-    'SVGProps',
-    'TextareaHTMLAttributes',
-    'TdHTMLAttributes',
-]);
-function createTextControlSurface(onChangeType, specificProps) {
-    return [
-        { name: 'autoComplete', type: 'string', required: false },
-        ...specificProps,
-        { name: 'disabled', type: 'boolean', required: false },
-        { name: 'name', type: 'string', required: false },
-        { name: 'onChange', type: onChangeType, required: false },
-        { name: 'placeholder', type: 'string', required: false },
-        { name: 'readOnly', type: 'boolean', required: false },
-        { name: 'required', type: 'boolean', required: false },
-        {
-            name: 'value',
-            type: 'string | number | readonly string[]',
-            required: false,
-        },
-    ];
-}
-const DOM_ATTRIBUTE_PROP_SURFACES = {
-    HTMLProps: [],
-    HTMLAttributes: [
-        { name: 'className', type: 'string', required: false },
-        { name: 'hidden', type: 'boolean', required: false },
-        { name: 'id', type: 'string', required: false },
-        {
-            name: 'onClick',
-            type: 'MouseEventHandler<HTMLElement>',
-            required: false,
-        },
-        { name: 'style', type: 'CSSProperties', required: false },
-        { name: 'tabIndex', type: 'number', required: false },
-        { name: 'title', type: 'string', required: false },
-    ],
-    ImgHTMLAttributes: [
-        { name: 'alt', type: 'string', required: false },
-        { name: 'crossOrigin', type: 'string', required: false },
-        { name: 'height', type: 'number | string', required: false },
-        {
-            name: 'loading',
-            type: 'string',
-            required: false,
-            allowedValues: ['eager', 'lazy'],
-        },
-        { name: 'sizes', type: 'string', required: false },
-        { name: 'src', type: 'string', required: false },
-        { name: 'srcSet', type: 'string', required: false },
-        { name: 'width', type: 'number | string', required: false },
-    ],
-    LiHTMLAttributes: [],
-    AnchorHTMLAttributes: [
-        { name: 'download', type: 'boolean | string', required: false },
-        { name: 'href', type: 'string', required: false },
-        { name: 'hrefLang', type: 'string', required: false },
-        { name: 'referrerPolicy', type: 'string', required: false },
-        { name: 'rel', type: 'string', required: false },
-        {
-            name: 'target',
-            type: 'string',
-            required: false,
-            allowedValues: ['_blank', '_parent', '_self', '_top'],
-        },
-    ],
-    ButtonHTMLAttributes: [
-        { name: 'autoFocus', type: 'boolean', required: false },
-        { name: 'disabled', type: 'boolean', required: false },
-        { name: 'form', type: 'string', required: false },
-        { name: 'formAction', type: 'string', required: false },
-        { name: 'formMethod', type: 'string', required: false },
-        { name: 'formNoValidate', type: 'boolean', required: false },
-        { name: 'formTarget', type: 'string', required: false },
-        { name: 'name', type: 'string', required: false },
-        {
-            name: 'type',
-            type: 'string',
-            required: false,
-            allowedValues: ['button', 'reset', 'submit'],
-        },
-        {
-            name: 'value',
-            type: 'string | number | readonly string[]',
-            required: false,
-        },
-    ],
-    InputHTMLAttributes: createTextControlSurface('ChangeEventHandler<HTMLInputElement>', [
-        { name: 'checked', type: 'boolean', required: false },
-        { name: 'max', type: 'number | string', required: false },
-        { name: 'maxLength', type: 'number', required: false },
-        { name: 'min', type: 'number | string', required: false },
-        { name: 'minLength', type: 'number', required: false },
-        { name: 'type', type: 'string', required: false },
-    ]),
-    FieldsetHTMLAttributes: [
-        { name: 'disabled', type: 'boolean', required: false },
-        { name: 'form', type: 'string', required: false },
-        { name: 'name', type: 'string', required: false },
-    ],
-    LabelHTMLAttributes: [
-        { name: 'form', type: 'string', required: false },
-        { name: 'htmlFor', type: 'string', required: false },
-    ],
-    SelectHTMLAttributes: [
-        { name: 'autoComplete', type: 'string', required: false },
-        { name: 'disabled', type: 'boolean', required: false },
-        { name: 'form', type: 'string', required: false },
-        { name: 'multiple', type: 'boolean', required: false },
-        { name: 'name', type: 'string', required: false },
-        {
-            name: 'onChange',
-            type: 'ChangeEventHandler<HTMLSelectElement>',
-            required: false,
-        },
-        { name: 'required', type: 'boolean', required: false },
-        { name: 'size', type: 'number', required: false },
-        {
-            name: 'value',
-            type: 'string | number | readonly string[]',
-            required: false,
-        },
-    ],
-    SVGAttributes: [
-        {
-            name: 'focusable',
-            type: 'boolean | "auto"',
-            required: false,
-            allowedValues: ['auto'],
-        },
-        { name: 'height', type: 'number | string', required: false },
-        { name: 'viewBox', type: 'string', required: false },
-        { name: 'width', type: 'number | string', required: false },
-    ],
-    SVGProps: [],
-    TextareaHTMLAttributes: createTextControlSurface('ChangeEventHandler<HTMLTextAreaElement>', [
-        { name: 'cols', type: 'number', required: false },
-        { name: 'rows', type: 'number', required: false },
-        { name: 'wrap', type: 'string', required: false },
-    ]),
-    TdHTMLAttributes: [
-        {
-            name: 'align',
-            type: 'string',
-            required: false,
-            allowedValues: ['center', 'char', 'justify', 'left', 'right'],
-        },
-        { name: 'colSpan', type: 'number', required: false },
-        { name: 'headers', type: 'string', required: false },
-        { name: 'rowSpan', type: 'number', required: false },
-        { name: 'scope', type: 'string', required: false },
-    ],
-};
-const DOM_ATTRIBUTE_WRAPPER_PARENTS = {
-    HTMLProps: ['HTMLAttributes'],
-    AnchorHTMLAttributes: ['HTMLAttributes'],
-    ButtonHTMLAttributes: ['HTMLAttributes'],
-    ImgHTMLAttributes: ['HTMLAttributes'],
-    InputHTMLAttributes: ['HTMLAttributes'],
-    FieldsetHTMLAttributes: ['HTMLAttributes'],
-    LabelHTMLAttributes: ['HTMLAttributes'],
-    LiHTMLAttributes: ['HTMLAttributes'],
-    SelectHTMLAttributes: ['HTMLAttributes'],
-    SVGAttributes: ['HTMLAttributes'],
-    SVGProps: ['SVGAttributes'],
-    TdHTMLAttributes: ['HTMLAttributes'],
-    TextareaHTMLAttributes: ['HTMLAttributes'],
-};
-const DOM_ATTRIBUTE_WRAPPERS_WITH_SYNTHETIC_CHILDREN = new Set([
-    'LabelHTMLAttributes',
-]);
-const JSX_PRIMITIVE_DOM_ATTRIBUTE_SURFACES = {
-    'Primitive.button': 'ButtonHTMLAttributes',
-    'Primitive.input': 'InputHTMLAttributes',
-    'Primitive.label': 'LabelHTMLAttributes',
-};
-function getBoundedImportedJsxDomSurface(tagNameNode) {
-    if (!Node.isIdentifier(tagNameNode))
-        return undefined;
-    const localName = tagNameNode.getText();
-    if (!/label/i.test(localName))
-        return undefined;
-    const declarations = tagNameNode.getSymbol()?.getDeclarations() ?? [];
-    for (const declaration of declarations) {
-        if (!Node.isImportSpecifier(declaration))
-            continue;
-        const importDeclaration = declaration.getImportDeclaration();
-        const moduleSpecifier = importDeclaration.getModuleSpecifierValue();
-        const importedName = declaration.getNameNode().getText();
-        const aliasName = declaration.getAliasNode()?.getText();
-        if (/label/i.test(moduleSpecifier) ||
-            /label/i.test(importedName) ||
-            (aliasName !== undefined && /label/i.test(aliasName))) {
-            return 'LabelHTMLAttributes';
-        }
-    }
-    return undefined;
-}
-function isStencilFile(sourceFile) {
-    return sourceFile.getImportDeclarations().some((imp) => imp.getModuleSpecifierValue() === '@stencil/core');
-}
-function sourceFileUsesCreateContext(sourceFile) {
-    return sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression).some((call) => {
-        const expr = call.getExpression();
-        const text = expr.getText();
-        return text === 'createContext' || text === 'React.createContext';
-    });
-}
-function isNextJsComponent(filePath, exportedNames) {
-    const normalized = filePath.replace(/\\/g, '/');
-    const isAppRouterFile = /\/app\/.*\/(page|layout)\.[jt]sx?$/.test(normalized);
-    const hasNextExports = exportedNames.some((name) => name === 'generateMetadata' || name === 'generateStaticParams');
-    return isAppRouterFile || hasNextExports;
-}
-function isRepoLocalTransparentPolymorphicWrapperDeclaration(declaration, typeName) {
-    if (!Node.isTypeAliasDeclaration(declaration))
-        return false;
-    if (declaration.getSourceFile().getFilePath().includes('/node_modules/'))
-        return false;
-    if (!TRANSPARENT_POLYMORPHIC_TYPE_NAMES.has(typeName))
-        return false;
-    const typeParameters = declaration.getTypeParameters();
-    const typeNode = declaration.getTypeNode();
-    if (!typeNode)
-        return false;
-    if (typeName === 'PropsWithAs') {
-        if (typeParameters.length !== 2 || !Node.isIntersectionTypeNode(typeNode))
-            return false;
-        const [propsTypeNode, wrapperTypeNode] = typeNode.getTypeNodes();
-        if (!propsTypeNode || !wrapperTypeNode)
-            return false;
-        if (propsTypeNode.getText() !== typeParameters[0].getName())
-            return false;
-        if (!Node.isTypeLiteral(wrapperTypeNode))
-            return false;
-        if (wrapperTypeNode.getMembers().length !== 1)
-            return false;
-        const asProperty = wrapperTypeNode.getProperty('as');
-        if (!asProperty || !asProperty.hasQuestionToken())
-            return false;
-        return asProperty.getTypeNode()?.getText() === typeParameters[1].getName();
-    }
-    if (typeName === 'PropsWithHTMLElement') {
-        if (typeParameters.length !== 3)
-            return false;
-        if (!Node.isTypeReference(typeNode) && !Node.isExpressionWithTypeArguments(typeNode))
-            return false;
-        if (getTypeReferenceName(typeNode) !== 'Overwrite')
-            return false;
-        const [omittedDomPropsTypeNode, propsTypeNode] = typeNode.getTypeArguments();
-        if (!omittedDomPropsTypeNode || !propsTypeNode)
-            return false;
-        if (!Node.isTypeReference(omittedDomPropsTypeNode) &&
-            !Node.isExpressionWithTypeArguments(omittedDomPropsTypeNode)) {
-            return false;
-        }
-        if (getTypeReferenceName(omittedDomPropsTypeNode) !== 'Omit')
-            return false;
-        const [componentPropsTypeNode, omittedAdditionalPropsTypeNode] = omittedDomPropsTypeNode.getTypeArguments();
-        if (!componentPropsTypeNode || !omittedAdditionalPropsTypeNode)
-            return false;
-        if (getTypeReferenceName(componentPropsTypeNode) !== 'ComponentPropsWithoutRef') {
-            return false;
-        }
-        if (!Node.isTypeReference(componentPropsTypeNode) && !Node.isExpressionWithTypeArguments(componentPropsTypeNode)) {
-            return false;
-        }
-        if (componentPropsTypeNode.getTypeArguments()[0]?.getText() !== typeParameters[1].getName())
-            return false;
-        if (omittedAdditionalPropsTypeNode.getText() !== typeParameters[2].getName())
-            return false;
-        return propsTypeNode.getText() === typeParameters[0].getName();
-    }
-    if (typeName === 'PolymorphicProps') {
-        if (typeParameters.length !== 3)
-            return false;
-        if (!Node.isTypeReference(typeNode) && !Node.isExpressionWithTypeArguments(typeNode))
-            return false;
-        if (getTypeReferenceName(typeNode) !== 'PropsWithAs')
-            return false;
-        const [propsTypeNode, elementTypeNode] = typeNode.getTypeArguments();
-        if (!propsTypeNode || !elementTypeNode)
-            return false;
-        if (!Node.isTypeReference(propsTypeNode) && !Node.isExpressionWithTypeArguments(propsTypeNode)) {
-            return false;
-        }
-        if (getTypeReferenceName(propsTypeNode) !== 'PropsWithHTMLElement')
-            return false;
-        const propsTypeArgs = propsTypeNode.getTypeArguments();
-        const propsWithAsTargetNode = Node.isTypeReference(typeNode) ? typeNode.getTypeName() : typeNode.getExpression();
-        const propsWithHTMLElementTargetNode = Node.isTypeReference(propsTypeNode)
-            ? propsTypeNode.getTypeName()
-            : propsTypeNode.getExpression();
-        const hasExactPropsWithAsDeclaration = getTypeTargetDeclarations(propsWithAsTargetNode, true).some((declaration) => isRepoLocalTransparentPolymorphicWrapperDeclaration(declaration, 'PropsWithAs'));
-        const hasExactPropsWithHTMLElementDeclaration = getTypeTargetDeclarations(propsWithHTMLElementTargetNode, true).some((declaration) => isRepoLocalTransparentPolymorphicWrapperDeclaration(declaration, 'PropsWithHTMLElement'));
-        return (hasExactPropsWithAsDeclaration &&
-            hasExactPropsWithHTMLElementDeclaration &&
-            propsTypeArgs[0]?.getText() === typeParameters[0].getName() &&
-            propsTypeArgs[1]?.getText() === typeParameters[1].getName() &&
-            propsTypeArgs[2]?.getText() === typeParameters[2].getName() &&
-            elementTypeNode.getText() === typeParameters[1].getName());
-    }
-    return false;
-}
-function unwrapRepoLocalTransparentPolymorphicWrapper(typeNode, allowWorkspaceImportFallback) {
-    if (!Node.isTypeReference(typeNode) && !Node.isExpressionWithTypeArguments(typeNode)) {
-        return undefined;
-    }
-    const typeName = getTypeReferenceName(typeNode);
-    if (!typeName || !TRANSPARENT_POLYMORPHIC_TYPE_NAMES.has(typeName)) {
-        return undefined;
-    }
-    const firstTypeArg = typeNode.getTypeArguments()[0];
-    if (!firstTypeArg)
-        return undefined;
-    const targetNode = Node.isTypeReference(typeNode) ? typeNode.getTypeName() : typeNode.getExpression();
-    const declarations = getTypeTargetDeclarations(targetNode, allowWorkspaceImportFallback);
-    if (!declarations.some((declaration) => isRepoLocalTransparentPolymorphicWrapperDeclaration(declaration, typeName))) {
-        return undefined;
-    }
-    return firstTypeArg;
-}
-function isRepoLocalSupportedPolymorphicChain(typeNode, seen = new Set(), allowWorkspaceImportFallback = false) {
-    if (seen.has(typeNode))
-        return false;
-    seen.add(typeNode);
-    if (Node.isParenthesizedTypeNode(typeNode) || Node.isTypeOperatorTypeNode(typeNode)) {
-        return isRepoLocalSupportedPolymorphicChain(typeNode.getTypeNode(), seen, allowWorkspaceImportFallback);
-    }
-    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
-        const childTypes = typeNode.getTypeNodes();
-        return (childTypes.length > 0 &&
-            childTypes.every((child) => isRepoLocalSupportedPolymorphicChain(child, seen, allowWorkspaceImportFallback)));
-    }
-    if (Node.isTypeLiteral(typeNode) || Node.isInterfaceDeclaration(typeNode)) {
-        return true;
-    }
-    if (Node.isTypeReference(typeNode) || Node.isExpressionWithTypeArguments(typeNode)) {
-        const typeName = getTypeReferenceName(typeNode);
-        if (!typeName)
-            return false;
-        if (typeName === 'Omit' ||
-            typeName === 'Partial' ||
-            typeName === 'Readonly' ||
-            typeName === 'Required' ||
-            typeName === 'NonNullable' ||
-            typeName === 'MappedOmit') {
-            const wrappedType = typeNode.getTypeArguments()[0];
-            return wrappedType
-                ? isRepoLocalSupportedPolymorphicChain(wrappedType, seen, allowWorkspaceImportFallback)
-                : false;
-        }
-        if (!TRANSPARENT_POLYMORPHIC_TYPE_NAMES.has(typeName)) {
-            const targetNode = Node.isTypeReference(typeNode) ? typeNode.getTypeName() : typeNode.getExpression();
-            for (const declaration of getTypeTargetDeclarations(targetNode, allowWorkspaceImportFallback)) {
-                if (!declaration)
-                    continue;
-                if (Node.isInterfaceDeclaration(declaration)) {
-                    if (declaration
-                        .getHeritageClauses()
-                        .some((clause) => clause
-                        .getTypeNodes()
-                        .every((heritageTypeNode) => isRepoLocalSupportedPolymorphicChain(heritageTypeNode, seen, allowWorkspaceImportFallback)))) {
-                        return true;
-                    }
-                }
-                if (Node.isTypeAliasDeclaration(declaration)) {
-                    const aliasedTypeNode = declaration.getTypeNode();
-                    if (aliasedTypeNode &&
-                        isRepoLocalSupportedPolymorphicChain(aliasedTypeNode, seen, allowWorkspaceImportFallback)) {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
-        const wrappedTypeNode = unwrapRepoLocalTransparentPolymorphicWrapper(typeNode, allowWorkspaceImportFallback);
-        return wrappedTypeNode
-            ? isRepoLocalSupportedPolymorphicChain(wrappedTypeNode, seen, allowWorkspaceImportFallback)
-            : false;
-    }
-    return false;
-}
-function isRenderPropType(type) {
-    const callSignatures = type.getCallSignatures();
-    if (callSignatures.length === 0)
-        return false;
-    const returnType = callSignatures[0].getReturnType();
-    const returnText = returnType.getText();
-    return /ReactNode|ReactElement|JSX\.Element|Element/.test(returnText);
-}
-function extractPropsFromType(type, slotNames, typeNode) {
-    const supportsRepoLocalPolymorphicAlias = typeNode !== undefined && isRepoLocalSupportedPolymorphicChain(typeNode, new Set(), true);
-    const suppressNeverChildrenSlot = supportsRepoLocalPolymorphicAlias;
-    const isPureDomWrapper = typeNode !== undefined && isPureExpandableDomAttributeWrapperType(typeNode);
-    const symbolExtraction = supportsRepoLocalPolymorphicAlias || isPureDomWrapper
-        ? { props: [], hasChildren: false }
-        : extractPropsFromTypeSymbols(type, slotNames, suppressNeverChildrenSlot);
-    const syntaxExtraction = typeNode &&
-        (symbolExtraction.props.length === 0 ||
-            shouldMergeDomSyntaxExtraction(typeNode) ||
-            containsImportedOmitWrappedCustomProps(typeNode))
-        ? extractPropsFromTypeNode(typeNode, slotNames, undefined, new Set(), false, suppressNeverChildrenSlot)
-        : { props: [], hasChildren: false };
-    const propsByName = new Map();
-    const useSyntaxOnly = typeNode !== undefined && shouldMergeDomSyntaxExtraction(typeNode);
-    if (!useSyntaxOnly) {
-        for (const prop of symbolExtraction.props) {
-            propsByName.set(prop.name, prop);
-        }
-    }
-    for (const prop of syntaxExtraction.props) {
-        propsByName.set(prop.name, prop);
-    }
-    return {
-        props: [...propsByName.values()].sort((a, b) => a.name.localeCompare(b.name)),
-        hasChildren: symbolExtraction.hasChildren || syntaxExtraction.hasChildren,
-    };
-}
-function extractPropsFromTypeSymbols(type, slotNames, suppressNeverChildrenSlot = false) {
-    const props = [];
-    let hasChildren = false;
-    for (const property of type.getProperties()) {
-        const name = property.getName();
-        if (name === 'children') {
-            if (suppressNeverChildrenSlot) {
-                const declaration = property.getValueDeclaration() ?? property.getDeclarations()[0];
-                if (declaration && property.getTypeAtLocation(declaration).isNever()) {
-                    continue;
-                }
-            }
-            hasChildren = true;
-            continue;
-        }
-        if (slotNames.has(name))
-            continue;
-        const declaration = property.getValueDeclaration() ?? property.getDeclarations()[0];
-        if (!declaration)
-            continue;
-        const propType = property.getTypeAtLocation(declaration);
-        const declarationTypeText = 'getTypeNode' in declaration && typeof declaration.getTypeNode === 'function'
-            ? declaration.getTypeNode()?.getText()
-            : undefined;
-        const typeText = propType.isAny() && declarationTypeText ? declarationTypeText : propType.getText(declaration);
-        const required = !property.isOptional();
-        const allowedValues = extractAllowedValues(propType);
-        props.push({
-            name,
-            type: typeText,
-            required,
-            ...(allowedValues && { allowedValues }),
-            ...getSourceLineMetadata(declaration),
-        });
-    }
-    return {
-        props: props.sort((a, b) => a.name.localeCompare(b.name)),
-        hasChildren,
-    };
-}
-function filterExcludedSyntaxProps(extraction, excludedProps) {
-    if (excludedProps.size === 0)
-        return extraction;
-    return {
-        ...extraction,
-        props: extraction.props.filter((prop) => !excludedProps.has(prop.name)),
-    };
-}
-function extractPropsFromInterfaceDeclaration(declaration, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot) {
-    const hasExpandableDomHeritage = declaration
-        .getHeritageClauses()
-        .some((clause) => clause.getTypeNodes().some((typeNode) => collectExpandableDomAttributeWrapperContexts(typeNode).length > 0));
-    const symbolType = hasExpandableDomHeritage
-        ? declaration
-            .getType()
-            .getProperties()
-            .filter((symbol) => {
-            const decl = symbol.getValueDeclaration() ?? symbol.getDeclarations()[0];
-            return decl?.getParent() === declaration;
-        })
-            .reduce((acc, symbol) => {
-            const decl = symbol.getValueDeclaration() ?? symbol.getDeclarations()[0];
-            if (!decl)
-                return acc;
-            const propType = symbol.getTypeAtLocation(decl);
-            const typeText = propType.isAny()
-                ? (('getTypeNode' in decl &&
-                    typeof decl.getTypeNode === 'function'
-                    ? decl.getTypeNode()?.getText()
-                    : undefined) ?? propType.getText(decl))
-                : propType.getText(decl);
-            const name = symbol.getName();
-            if (name === 'children') {
-                if (suppressNeverChildrenSlot && propType.isNever())
-                    return acc;
-                acc.hasChildren = true;
-                return acc;
-            }
-            if (slotNames.has(name))
-                return acc;
-            const required = !symbol.isOptional();
-            const allowedValues = extractAllowedValues(propType);
-            acc.props.push({
-                name,
-                type: typeText,
-                required,
-                ...(allowedValues && { allowedValues }),
-                ...getSourceLineMetadata(decl),
-            });
-            return acc;
-        }, { props: [], hasChildren: false })
-        : extractPropsFromTypeSymbols(declaration.getType(), slotNames, suppressNeverChildrenSlot);
-    const ownProps = filterExcludedSyntaxProps(symbolType, excludedProps);
-    const inheritedProps = declaration
-        .getHeritageClauses()
-        .flatMap((clause) => clause
-        .getTypeNodes()
-        .flatMap((heritageTypeNode) => extractPropsFromTypeNode(heritageTypeNode, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot).props));
-    return {
-        props: [...ownProps.props, ...inheritedProps].sort((a, b) => a.name.localeCompare(b.name)),
-        hasChildren: ownProps.hasChildren,
-    };
-}
-function getMappedOmitEquivalentArgs(typeNode) {
-    if (!Node.isTypeReference(typeNode) && !Node.isExpressionWithTypeArguments(typeNode)) {
-        return undefined;
-    }
-    const [wrappedType, omittedProps] = typeNode.getTypeArguments();
-    if (!wrappedType || !omittedProps)
-        return undefined;
-    const targetNode = Node.isTypeReference(typeNode) ? typeNode.getTypeName() : typeNode.getExpression();
-    for (const declaration of getTypeTargetDeclarations(targetNode, true)) {
-        if (!Node.isTypeAliasDeclaration(declaration))
-            continue;
-        if (declaration.getTypeParameters().length !== 2)
-            continue;
-        const mappedTypeNode = declaration.getTypeNode();
-        const [sourceTypeParameter, excludedKeysParameter] = declaration.getTypeParameters();
-        const sourceTypeParameterName = sourceTypeParameter.getName();
-        const excludedKeysParameterName = excludedKeysParameter.getName();
-        if (!mappedTypeNode)
-            continue;
-        if (Node.isTypeReference(mappedTypeNode) || Node.isExpressionWithTypeArguments(mappedTypeNode)) {
-            if (getTypeReferenceName(mappedTypeNode) !== 'Omit')
-                continue;
-            const [innerWrappedType, innerOmittedProps] = mappedTypeNode.getTypeArguments();
-            if (!innerWrappedType || !innerOmittedProps)
-                continue;
-            if (innerWrappedType.getText() !== sourceTypeParameterName)
-                continue;
-            if (innerOmittedProps.getText() !== excludedKeysParameterName)
-                continue;
-            return { wrappedType, omittedProps };
-        }
-        if (!Node.isMappedTypeNode(mappedTypeNode))
-            continue;
-        const iterationParameter = mappedTypeNode.getTypeParameter();
-        const iterationParameterName = iterationParameter.getName();
-        if (iterationParameter.getConstraint()?.getText() !== `keyof ${sourceTypeParameterName}`)
-            continue;
-        if (mappedTypeNode.getNameTypeNode()?.getText() !==
-            `${iterationParameterName} extends ${excludedKeysParameterName} ? never : ${iterationParameterName}`) {
-            continue;
-        }
-        if (mappedTypeNode.getTypeNode()?.getText() !== `${sourceTypeParameterName}[${iterationParameterName}]`)
-            continue;
-        return { wrappedType, omittedProps };
-    }
-    return undefined;
-}
-function getTypeReferenceTargetNode(typeNode) {
-    if (Node.isTypeReference(typeNode))
-        return typeNode.getTypeName();
-    if (Node.isExpressionWithTypeArguments(typeNode))
-        return typeNode.getExpression();
-    return undefined;
-}
-function getTypeReferenceArguments(typeNode) {
-    if (Node.isTypeReference(typeNode) || Node.isExpressionWithTypeArguments(typeNode)) {
-        return typeNode.getTypeArguments();
-    }
-    return [];
-}
-function extractPropsFromTypeNode(typeNode, slotNames, seen = new Set(), excludedProps = new Set(), allowImportedOmitWorkspaceFallback = false, suppressNeverChildrenSlot = false) {
-    if (seen.has(typeNode))
-        return { props: [], hasChildren: false };
-    seen.add(typeNode);
-    if (Node.isParenthesizedTypeNode(typeNode) || Node.isTypeOperatorTypeNode(typeNode)) {
-        return extractPropsFromTypeNode(typeNode.getTypeNode(), slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
-    }
-    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
-        const propsByName = new Map();
-        let hasChildren = false;
-        for (const childTypeNode of typeNode.getTypeNodes()) {
-            const extracted = extractPropsFromTypeNode(childTypeNode, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
-            hasChildren ||= extracted.hasChildren;
-            for (const prop of extracted.props) {
-                propsByName.set(prop.name, prop);
-            }
-        }
-        return { props: [...propsByName.values()], hasChildren };
-    }
-    if (Node.isTypeLiteral(typeNode)) {
-        return filterExcludedSyntaxProps(extractPropsFromTypeSymbols(typeNode.getType(), slotNames, suppressNeverChildrenSlot), excludedProps);
-    }
-    if (Node.isInterfaceDeclaration(typeNode)) {
-        return extractPropsFromInterfaceDeclaration(typeNode, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
-    }
-    const typeReferenceTarget = getTypeReferenceTargetNode(typeNode);
-    if (typeReferenceTarget) {
-        const typeName = getTypeReferenceName(typeNode);
-        if (!typeName)
-            return { props: [], hasChildren: false };
-        const typeArguments = getTypeReferenceArguments(typeNode);
-        if (typeName === 'PropsWithChildren') {
-            const wrappedType = typeArguments[0];
-            if (!wrappedType)
-                return { props: [], hasChildren: true };
-            const extracted = extractPropsFromTypeNode(wrappedType, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
-            return { props: extracted.props, hasChildren: true };
-        }
-        if (isExpandableDomAttributeWrapperName(typeName) || typeName === 'Pick') {
-            return typeName === 'Pick'
-                ? {
-                    props: extractPickedPropsFromTypeNode(typeNode, slotNames, excludedProps),
-                    hasChildren: false,
-                }
-                : { props: [], hasChildren: false };
-        }
-        if (typeName === 'Omit' ||
-            typeName === 'Partial' ||
-            typeName === 'Readonly' ||
-            typeName === 'Required' ||
-            typeName === 'NonNullable') {
-            const wrappedType = typeArguments[0];
-            if (!wrappedType)
-                return { props: [], hasChildren: false };
-            const nextExcludedProps = new Set(excludedProps);
-            if (typeName === 'Omit') {
-                const omittedProps = typeArguments[1];
-                if (omittedProps) {
-                    for (const value of getStringLiteralTypeValues(omittedProps)) {
-                        nextExcludedProps.add(value);
-                    }
-                }
-            }
-            return extractPropsFromTypeNode(wrappedType, slotNames, seen, nextExcludedProps, allowImportedOmitWorkspaceFallback || typeName === 'Omit', suppressNeverChildrenSlot);
-        }
-        const mappedOmitArgs = allowImportedOmitWorkspaceFallback ? getMappedOmitEquivalentArgs(typeNode) : undefined;
-        if (mappedOmitArgs) {
-            const nextExcludedProps = new Set(excludedProps);
-            for (const value of getStringLiteralTypeValues(mappedOmitArgs.omittedProps)) {
-                nextExcludedProps.add(value);
-            }
-            return extractPropsFromTypeNode(mappedOmitArgs.wrappedType, slotNames, seen, nextExcludedProps, true, suppressNeverChildrenSlot);
-        }
-        const wrappedTypeNode = unwrapRepoLocalTransparentPolymorphicWrapper(typeNode, allowImportedOmitWorkspaceFallback) ??
-            (!allowImportedOmitWorkspaceFallback ? unwrapRepoLocalTransparentPolymorphicWrapper(typeNode, true) : undefined);
-        if (wrappedTypeNode) {
-            return extractPropsFromTypeNode(wrappedTypeNode, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, true);
-        }
-        if (TRANSPARENT_POLYMORPHIC_TYPE_NAMES.has(typeName)) {
-            return { props: [], hasChildren: false };
-        }
-        for (const declaration of getTypeTargetDeclarations(typeReferenceTarget, allowImportedOmitWorkspaceFallback)) {
-            if (!declaration)
-                continue;
-            if (Node.isInterfaceDeclaration(declaration)) {
-                return extractPropsFromInterfaceDeclaration(declaration, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
-            }
-            if (Node.isTypeAliasDeclaration(declaration)) {
-                const aliasedTypeNode = declaration.getTypeNode();
-                if (!aliasedTypeNode)
-                    continue;
-                return extractPropsFromTypeNode(aliasedTypeNode, slotNames, seen, excludedProps, allowImportedOmitWorkspaceFallback, suppressNeverChildrenSlot);
-            }
-        }
-    }
-    return { props: [], hasChildren: false };
-}
-function collectRenderPropSlotNames(type) {
-    const names = new Set();
-    for (const property of type.getProperties()) {
-        if (getRenderPropType(property))
-            names.add(property.getName());
-    }
-    return names;
-}
-function getRenderPropType(property) {
-    if (!property.getName().startsWith('render'))
-        return undefined;
-    const declaration = property.getValueDeclaration() ?? property.getDeclarations()[0];
-    if (!declaration)
-        return undefined;
-    const propType = property.getTypeAtLocation(declaration);
-    return isRenderPropType(propType) ? propType : undefined;
-}
-function recordBindingPatternDefaults(nameNode, defaults) {
-    if (!Node.isObjectBindingPattern(nameNode))
-        return;
-    for (const element of nameNode.getElements()) {
-        const initializer = element.getInitializer();
-        if (!initializer)
-            continue;
-        const propertyNameNode = element.getPropertyNameNode();
-        const propName = propertyNameNode?.getText().replace(/^['"]|['"]$/g, '') ?? element.getNameNode().getText();
-        const value = initializer.getText().replace(/^['"]|['"]$/g, '');
-        defaults.set(propName, value);
-    }
-}
-function extractDefaultValues(func) {
-    const defaults = new Map();
-    const params = func.getParameters();
-    if (params.length === 0)
-        return defaults;
-    const firstParam = params[0];
-    const nameNode = firstParam.getNameNode();
-    if (Node.isObjectBindingPattern(nameNode)) {
-        recordBindingPatternDefaults(nameNode, defaults);
-        return defaults;
-    }
-    if (!Node.isIdentifier(nameNode))
-        return defaults;
-    const body = func.getBody();
-    if (!body || !Node.isBlock(body))
-        return defaults;
-    for (const statement of body.getStatements()) {
-        if (!Node.isVariableStatement(statement))
-            continue;
-        for (const declaration of statement.getDeclarationList().getDeclarations()) {
-            const declarationName = declaration.getNameNode();
-            const initializer = declaration.getInitializer();
-            if (!Node.isObjectBindingPattern(declarationName))
-                continue;
-            if (!initializer || !Node.isIdentifier(initializer) || initializer.getText() !== nameNode.getText())
-                continue;
-            recordBindingPatternDefaults(declarationName, defaults);
-            return defaults;
-        }
-    }
-    return defaults;
-}
-function isImplementationOnlyAliasProp(func, propName) {
-    if (!propName.startsWith('_'))
-        return false;
-    const allowedJsxAttributes = new Set([
-        'id',
-        'htmlFor',
-        'aria-activedescendant',
-        'aria-controls',
-        'aria-describedby',
-        'aria-labelledby',
-        'aria-owns',
-    ]);
-    let sawRuntimeUsage = false;
-    for (const node of func.getDescendants()) {
-        if (!Node.isIdentifier(node) || node.getText() !== propName)
-            continue;
-        const bindingElement = node.getFirstAncestor((ancestor) => Node.isBindingElement(ancestor));
-        if (bindingElement?.getNameNode() === node) {
-            continue;
-        }
-        const jsxAttribute = node.getFirstAncestor((ancestor) => Node.isJsxAttribute(ancestor));
-        if (jsxAttribute) {
-            const attributeName = jsxAttribute.getNameNode().getText();
-            if (allowedJsxAttributes.has(attributeName)) {
-                sawRuntimeUsage = true;
-                continue;
-            }
-            return false;
-        }
-        const propertyAssignment = node.getFirstAncestor((ancestor) => Node.isPropertyAssignment(ancestor));
-        if (propertyAssignment) {
-            const propertyName = propertyAssignment.getName();
-            if (propertyName === propName) {
-                sawRuntimeUsage = true;
-                continue;
-            }
-            return false;
-        }
-        return false;
-    }
-    return sawRuntimeUsage;
-}
-function filterImplementationOnlyAliasProps(props, func) {
-    const publicPropNames = new Set(props.filter((prop) => !prop.name.startsWith('_')).map((prop) => prop.name));
-    return props.filter((prop) => {
-        if (/^__scope[A-Z]/.test(prop.name)) {
-            return false;
-        }
-        if (prop.name.startsWith('_') && publicPropNames.has(prop.name.slice(1))) {
-            return false;
-        }
-        return !isImplementationOnlyAliasProp(func, prop.name);
-    });
-}
-function getDeclarationIdentity(node) {
-    if (Node.isIdentifier(node)) {
-        const parent = node.getParent();
-        if ((Node.isVariableDeclaration(parent) || Node.isBindingElement(parent) || Node.isParameterDeclaration(parent)) &&
-            parent.getNameNode() === node) {
-            return parent;
-        }
-    }
-    return getNodeDefinitions(node)[0]?.getDeclarationNode() ?? node;
-}
-function getComponentIdentity(func) {
-    return `${func.getSourceFile().getFilePath()}:${func.getStart()}`;
-}
-function resolveForwardedComponentIdentity(tagNameNode) {
-    if (!Node.isIdentifier(tagNameNode))
-        return undefined;
-    for (const declaration of getValueTargetDeclarations(tagNameNode)) {
-        const func = resolveFunctionNode(declaration);
-        if (func)
-            return getComponentIdentity(func);
-    }
-    return undefined;
-}
-/**
- * Declarations that are rebound somewhere in the body, so their initializer no
- * longer describes the value that reaches JSX.
- */
-function collectReboundDeclarations(body) {
-    const rebound = new Set();
-    const recordTarget = (target) => {
-        if (Node.isIdentifier(target)) {
-            rebound.add(getDeclarationIdentity(target));
-            return;
-        }
-        if ((Node.isPropertyAccessExpression(target) || Node.isElementAccessExpression(target)) &&
-            Node.isIdentifier(target.getExpression())) {
-            rebound.add(getDeclarationIdentity(target.getExpression()));
-        }
-    };
-    for (const assignment of body?.getDescendantsOfKind(SyntaxKind.BinaryExpression) ?? []) {
-        // Covers `=` and every compound form (`+=`, `??=`, `>>>=`, ...).
-        const operator = assignment.getOperatorToken().getKind();
-        if (operator < SyntaxKind.FirstAssignment || operator > SyntaxKind.LastAssignment)
-            continue;
-        recordTarget(assignment.getLeft());
-    }
-    // Only `++`/`--` rebind the operand. Reading a prop through `!`, `-`, `+`, or
-    // `~` leaves the alias intact, so those operators must not invalidate it.
-    for (const update of body?.getDescendantsOfKind(SyntaxKind.PrefixUnaryExpression) ?? []) {
-        const operator = update.getOperatorToken();
-        if (operator !== SyntaxKind.PlusPlusToken && operator !== SyntaxKind.MinusMinusToken)
-            continue;
-        recordTarget(update.getOperand());
-    }
-    for (const update of body?.getDescendantsOfKind(SyntaxKind.PostfixUnaryExpression) ?? []) {
-        recordTarget(update.getOperand());
-    }
-    return rebound;
-}
-/** Trace only statically resolvable, component-local prop dataflow into JSX. */
-function collectPropDataflow(func, param, availablePropNames) {
-    const valueAliases = new Map();
-    const objectAliases = new Map();
-    const fullPropsShape = new Map([...availablePropNames].map((name) => [name, name]));
-    const belongsToComponentFunction = (node) => node.getFirstAncestor((ancestor) => Node.isFunctionDeclaration(ancestor) || Node.isArrowFunction(ancestor) || Node.isFunctionExpression(ancestor)) === func;
-    const resolveValue = (expression) => {
-        if (!expression)
-            return undefined;
-        if (Node.isParenthesizedExpression(expression))
-            return resolveValue(expression.getExpression());
-        if (Node.isIdentifier(expression))
-            return valueAliases.get(getDeclarationIdentity(expression));
-        if (Node.isPropertyAccessExpression(expression)) {
-            const object = expression.getExpression();
-            return Node.isIdentifier(object)
-                ? objectAliases.get(getDeclarationIdentity(object))?.get(expression.getName())
-                : undefined;
-        }
-        if (Node.isElementAccessExpression(expression)) {
-            const argument = expression.getArgumentExpression();
-            if (!argument || (!Node.isStringLiteral(argument) && !Node.isNoSubstitutionTemplateLiteral(argument))) {
-                return undefined;
-            }
-            const object = expression.getExpression();
-            return Node.isIdentifier(object)
-                ? objectAliases.get(getDeclarationIdentity(object))?.get(argument.getLiteralText())
-                : undefined;
-        }
-        return undefined;
-    };
-    const resolveObject = (expression) => {
-        if (!expression)
-            return undefined;
-        if (Node.isParenthesizedExpression(expression))
-            return resolveObject(expression.getExpression());
-        if (Node.isIdentifier(expression))
-            return objectAliases.get(getDeclarationIdentity(expression));
-        if (!Node.isObjectLiteralExpression(expression))
-            return undefined;
-        const shape = new Map();
-        for (const property of expression.getProperties()) {
-            if (Node.isSpreadAssignment(property)) {
-                const spreadShape = resolveObject(property.getExpression());
-                for (const [targetProp, sourceProp] of spreadShape ?? [])
-                    shape.set(targetProp, sourceProp);
-            }
-            else if (Node.isShorthandPropertyAssignment(property)) {
-                const sourceProp = resolveValue(property.getNameNode());
-                if (sourceProp)
-                    shape.set(property.getName(), sourceProp);
-            }
-            else if (Node.isPropertyAssignment(property)) {
-                const propertyNameNode = property.getNameNode();
-                if (!Node.isIdentifier(propertyNameNode) && !Node.isStringLiteral(propertyNameNode))
-                    continue;
-                const sourceProp = resolveValue(property.getInitializer());
-                if (sourceProp)
-                    shape.set(property.getName(), sourceProp);
-            }
-        }
-        return shape;
-    };
-    const addBindings = (pattern, sourceShape) => {
-        const omittedProps = new Set(pattern
-            .getElements()
-            .filter((element) => !element.getDotDotDotToken())
-            .map((element) => element.getPropertyNameNode()?.getText() ?? element.getNameNode().getText()));
-        for (const element of pattern.getElements()) {
-            const localName = element.getNameNode();
-            if (!Node.isIdentifier(localName))
-                continue;
-            if (element.getDotDotDotToken()) {
-                objectAliases.set(getDeclarationIdentity(localName), new Map([...sourceShape].filter(([targetProp]) => !omittedProps.has(targetProp))));
-                continue;
-            }
-            const targetProp = element.getPropertyNameNode()?.getText() ?? localName.getText();
-            const sourceProp = sourceShape.get(targetProp);
-            if (sourceProp)
-                valueAliases.set(getDeclarationIdentity(localName), sourceProp);
-        }
-    };
-    const paramNameNode = param.getNameNode();
-    if (Node.isIdentifier(paramNameNode))
-        objectAliases.set(getDeclarationIdentity(paramNameNode), fullPropsShape);
-    else if (Node.isObjectBindingPattern(paramNameNode))
-        addBindings(paramNameNode, fullPropsShape);
-    const body = func.getBody();
-    const reboundDeclarations = collectReboundDeclarations(body);
-    for (const declaration of reboundDeclarations) {
-        valueAliases.delete(declaration);
-        objectAliases.delete(declaration);
-    }
-    for (const declaration of body?.getDescendantsOfKind(SyntaxKind.VariableDeclaration) ?? []) {
-        if (!belongsToComponentFunction(declaration))
-            continue;
-        const initializer = declaration.getInitializer();
-        const declarationName = declaration.getNameNode();
-        if (Node.isIdentifier(declarationName)) {
-            const aliasDeclaration = getDeclarationIdentity(declarationName);
-            if (reboundDeclarations.has(aliasDeclaration))
-                continue;
-            const sourceProp = resolveValue(initializer);
-            if (sourceProp)
-                valueAliases.set(aliasDeclaration, sourceProp);
-            const sourceShape = resolveObject(initializer);
-            if (sourceShape)
-                objectAliases.set(aliasDeclaration, new Map(sourceShape));
-        }
-        else if (Node.isObjectBindingPattern(declarationName)) {
-            const sourceShape = resolveObject(initializer);
-            if (sourceShape) {
-                const hasInvalidatedBinding = declarationName
-                    .getElements()
-                    .some((element) => reboundDeclarations.has(getDeclarationIdentity(element.getNameNode())));
-                if (!hasInvalidatedBinding)
-                    addBindings(declarationName, sourceShape);
-            }
-        }
-    }
-    const intrinsicDomProps = new Set();
-    const componentEdges = [];
-    const recordForwarding = (tagNameNode, targetProp, sourceProp) => {
-        const tagName = tagNameNode.getText();
-        if (isIntrinsicJsxElement(tagName)) {
-            if (targetProp === sourceProp)
-                intrinsicDomProps.add(sourceProp);
-            return;
-        }
-        const targetComponentIdentity = resolveForwardedComponentIdentity(tagNameNode);
-        if (targetComponentIdentity)
-            componentEdges.push({ sourceProp, targetComponentIdentity, targetProp });
-    };
-    for (const attribute of func.getDescendantsOfKind(SyntaxKind.JsxAttribute)) {
-        if (!belongsToComponentFunction(attribute))
-            continue;
-        const tagNameNode = getJsxTagNameNode(attribute);
-        if (!tagNameNode)
-            continue;
-        const initializer = attribute.getInitializer();
-        if (!initializer || !Node.isJsxExpression(initializer))
-            continue;
-        const sourceProp = resolveValue(initializer.getExpression());
-        if (sourceProp)
-            recordForwarding(tagNameNode, attribute.getNameNode().getText(), sourceProp);
-    }
-    for (const spread of func.getDescendantsOfKind(SyntaxKind.JsxSpreadAttribute)) {
-        if (!belongsToComponentFunction(spread))
-            continue;
-        const tagNameNode = getJsxTagNameNode(spread);
-        if (!tagNameNode)
-            continue;
-        const shape = resolveObject(spread.getExpression());
-        for (const [targetProp, sourceProp] of shape ?? [])
-            recordForwarding(tagNameNode, targetProp, sourceProp);
-    }
-    return { intrinsicDomProps, componentEdges };
-}
-function extractDestructuredBindingFallbackProps(func, param, existingPropNames, slotNames) {
-    const nameNode = param.getNameNode();
-    const bindingPatterns = [];
-    if (Node.isObjectBindingPattern(nameNode)) {
-        bindingPatterns.push(nameNode);
-    }
-    else if (Node.isIdentifier(nameNode)) {
-        const body = func.getBody();
-        const paramName = nameNode.getText();
-        if (body) {
-            for (const declaration of body.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
-                const declarationName = declaration.getNameNode();
-                const initializer = declaration.getInitializer();
-                if (!Node.isObjectBindingPattern(declarationName))
-                    continue;
-                if (!initializer || !Node.isIdentifier(initializer) || initializer.getText() !== paramName)
-                    continue;
-                bindingPatterns.push(declarationName);
-            }
-        }
-    }
-    else {
-        return [];
-    }
-    const propsByName = new Map();
-    const paramType = param.getType();
-    for (const bindingPattern of bindingPatterns) {
-        for (const element of bindingPattern.getElements()) {
-            if (element.getDotDotDotToken())
-                continue;
-            const propName = element.getPropertyNameNode()?.getText() ?? element.getNameNode().getText();
-            if (propName === 'children' || existingPropNames.has(propName) || slotNames.has(propName))
-                continue;
-            if (propsByName.has(propName))
-                continue;
-            const property = paramType.getProperty(propName);
-            const declaration = property?.getValueDeclaration() ?? property?.getDeclarations()[0];
-            const propertyType = property && declaration ? property.getTypeAtLocation(declaration).getText(declaration) : 'any';
-            propsByName.set(propName, {
-                name: propName,
-                type: propertyType === 'unknown' ? 'any' : propertyType,
-                required: property ? !property.isOptional() : false,
-                ...getSourceLineMetadata(declaration),
-            });
-        }
-    }
-    return [...propsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-function extractSlots(type, hasChildren) {
-    const slots = [];
-    if (hasChildren) {
-        slots.push({ name: 'children', isDefault: true });
-    }
-    for (const property of type.getProperties()) {
-        const name = property.getName();
-        if (name === 'children')
-            continue;
-        if (!getRenderPropType(property))
-            continue;
-        const slotName = name.replace(/^render/, '');
-        slots.push({
-            name: slotName.charAt(0).toLowerCase() + slotName.slice(1),
-            isDefault: false,
-        });
-    }
-    return slots.sort((a, b) => a.name.localeCompare(b.name));
-}
-function isExpandableDomAttributeWrapperName(typeName) {
-    return EXPANDABLE_DOM_ATTRIBUTE_TYPE_NAMES.has(typeName);
-}
-function getStringLiteralTypeValues(typeNode) {
-    if (Node.isLiteralTypeNode(typeNode)) {
-        const literal = typeNode.getLiteral();
-        if (Node.isStringLiteral(literal)) {
-            return [literal.getLiteralText()];
-        }
-    }
-    if (!Node.isUnionTypeNode(typeNode))
-        return [];
-    return typeNode.getTypeNodes().flatMap((unionTypeNode) => getStringLiteralTypeValues(unionTypeNode));
-}
-function shouldMergeDomSyntaxExtraction(typeNode) {
-    return collectExpandableDomAttributeWrapperContexts(typeNode).length > 0 || containsSupportedDomPickType(typeNode);
-}
-function containsImportedOmitWrappedCustomProps(typeNode, seen = new Set(), originSourceFile = typeNode.getSourceFile(), sawOmit = false) {
-    if (seen.has(typeNode))
-        return false;
-    seen.add(typeNode);
-    if (Node.isParenthesizedTypeNode(typeNode) || Node.isTypeOperatorTypeNode(typeNode)) {
-        return containsImportedOmitWrappedCustomProps(typeNode.getTypeNode(), seen, originSourceFile, sawOmit);
-    }
-    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
-        return typeNode
-            .getTypeNodes()
-            .some((child) => containsImportedOmitWrappedCustomProps(child, seen, originSourceFile, sawOmit));
-    }
-    if (Node.isTypeReference(typeNode) || Node.isExpressionWithTypeArguments(typeNode)) {
-        const typeName = getTypeReferenceName(typeNode);
-        if (!typeName)
-            return false;
-        if (typeName === 'PropsWithChildren') {
-            const wrappedType = typeNode.getTypeArguments()[0];
-            return wrappedType ? containsImportedOmitWrappedCustomProps(wrappedType, seen, originSourceFile, sawOmit) : false;
-        }
-        if (typeName === 'Omit') {
-            const wrappedType = typeNode.getTypeArguments()[0];
-            return wrappedType ? containsImportedOmitWrappedCustomProps(wrappedType, seen, originSourceFile, true) : false;
-        }
-        if (typeName === 'Partial' || typeName === 'Readonly' || typeName === 'Required' || typeName === 'NonNullable') {
-            const wrappedType = typeNode.getTypeArguments()[0];
-            return wrappedType ? containsImportedOmitWrappedCustomProps(wrappedType, seen, originSourceFile, sawOmit) : false;
-        }
-        const targetNode = Node.isTypeReference(typeNode) ? typeNode.getTypeName() : typeNode.getExpression();
-        for (const declaration of getTypeTargetDeclarations(targetNode, sawOmit)) {
-            if (!declaration)
-                continue;
-            const declarationSourceFile = declaration.getSourceFile();
-            const isImportedDeclaration = declarationSourceFile.getFilePath() !== originSourceFile.getFilePath();
-            if (sawOmit && isImportedDeclaration) {
-                const declarationTypeNode = Node.isTypeAliasDeclaration(declaration) ? declaration.getTypeNode() : declaration;
-                if (!declarationTypeNode || !isPureExpandableDomAttributeWrapperType(declarationTypeNode)) {
-                    return true;
-                }
-            }
-            if (Node.isInterfaceDeclaration(declaration)) {
-                if (declaration
-                    .getHeritageClauses()
-                    .some((clause) => clause
-                    .getTypeNodes()
-                    .some((heritageTypeNode) => containsImportedOmitWrappedCustomProps(heritageTypeNode, seen, originSourceFile, sawOmit)))) {
-                    return true;
-                }
-            }
-            if (Node.isTypeAliasDeclaration(declaration)) {
-                const aliasedTypeNode = declaration.getTypeNode();
-                if (aliasedTypeNode &&
-                    containsImportedOmitWrappedCustomProps(aliasedTypeNode, seen, originSourceFile, sawOmit)) {
-                    return true;
-                }
-            }
-        }
-    }
-    return false;
-}
-function containsPickType(typeNode, seen, mode) {
-    if (seen.has(typeNode))
-        return false;
-    seen.add(typeNode);
-    if (Node.isParenthesizedTypeNode(typeNode) || Node.isTypeOperatorTypeNode(typeNode)) {
-        return containsPickType(typeNode.getTypeNode(), seen, mode);
-    }
-    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
-        return typeNode.getTypeNodes().some((child) => containsPickType(child, seen, mode));
-    }
-    const typeReferenceTarget = getTypeReferenceTargetNode(typeNode);
-    if (!typeReferenceTarget)
-        return false;
-    const typeName = getTypeReferenceName(typeNode);
-    if (!typeName)
-        return false;
-    const typeArguments = getTypeReferenceArguments(typeNode);
-    if (typeName === 'Pick') {
-        if (mode === 'any')
-            return true;
-        const sourceTypeNode = typeArguments[0];
-        return sourceTypeNode
-            ? collectExpandableDomAttributeWrapperContexts(sourceTypeNode).length > 0 ||
-                containsPickType(sourceTypeNode, seen, mode)
-            : false;
-    }
-    const wrappedTypeNames = mode === 'any'
-        ? ['PropsWithChildren', 'Omit', 'Partial', 'Readonly', 'Required', 'NonNullable']
-        : ['Omit', 'Partial', 'Readonly', 'Required', 'NonNullable'];
-    if (wrappedTypeNames.includes(typeName)) {
-        const wrappedType = typeArguments[0];
-        return wrappedType ? containsPickType(wrappedType, seen, mode) : false;
-    }
-    for (const declaration of getTypeTargetDeclarations(typeReferenceTarget, mode === 'any')) {
-        if (!declaration)
-            continue;
-        if (Node.isInterfaceDeclaration(declaration)) {
-            if (declaration
-                .getHeritageClauses()
-                .some((clause) => clause.getTypeNodes().some((heritageTypeNode) => containsPickType(heritageTypeNode, seen, mode)))) {
-                return true;
-            }
-        }
-        if (Node.isTypeAliasDeclaration(declaration)) {
-            const aliasedTypeNode = declaration.getTypeNode();
-            if (aliasedTypeNode && containsPickType(aliasedTypeNode, seen, mode)) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function containsSupportedDomPickType(typeNode, seen = new Set()) {
-    return containsPickType(typeNode, seen, 'supported');
-}
-function containsAnyPickType(typeNode, seen = new Set()) {
-    return containsPickType(typeNode, seen, 'any');
-}
-function collectExpandableDomAttributeWrapperContexts(typeNode, seen = new Set(), excludedProps = new Set()) {
-    if (seen.has(typeNode))
-        return [];
-    seen.add(typeNode);
-    if (Node.isParenthesizedTypeNode(typeNode)) {
-        return collectExpandableDomAttributeWrapperContexts(typeNode.getTypeNode(), seen, excludedProps);
-    }
-    if (Node.isTypeOperatorTypeNode(typeNode)) {
-        return collectExpandableDomAttributeWrapperContexts(typeNode.getTypeNode(), seen, excludedProps);
-    }
-    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
-        return typeNode
-            .getTypeNodes()
-            .flatMap((child) => collectExpandableDomAttributeWrapperContexts(child, seen, excludedProps));
-    }
-    const typeReferenceTarget = getTypeReferenceTargetNode(typeNode);
-    if (typeReferenceTarget) {
-        const typeName = getTypeReferenceName(typeNode);
-        if (!typeName)
-            return [];
-        const typeArguments = getTypeReferenceArguments(typeNode);
-        if (isExpandableDomAttributeWrapperName(typeName)) {
-            return [{ name: typeName, excludedProps: new Set(excludedProps) }];
-        }
-        if (typeName === 'Omit') {
-            const [wrappedType, omittedProps] = typeArguments;
-            if (!wrappedType)
-                return [];
-            const nextExcludedProps = new Set(excludedProps);
-            if (omittedProps) {
-                for (const value of getStringLiteralTypeValues(omittedProps)) {
-                    nextExcludedProps.add(value);
-                }
-            }
-            return collectExpandableDomAttributeWrapperContexts(wrappedType, seen, nextExcludedProps);
-        }
-        if (typeName === 'Partial' || typeName === 'Readonly' || typeName === 'Required' || typeName === 'NonNullable') {
-            const wrappedType = typeArguments[0];
-            if (!wrappedType)
-                return [];
-            return collectExpandableDomAttributeWrapperContexts(wrappedType, seen, excludedProps);
-        }
-        for (const definition of getNodeDefinitions(typeReferenceTarget)) {
-            const declaration = definition.getDeclarationNode();
-            if (!declaration)
-                continue;
-            if (Node.isInterfaceDeclaration(declaration)) {
-                return declaration
-                    .getHeritageClauses()
-                    .flatMap((clause) => clause
-                    .getTypeNodes()
-                    .flatMap((heritageTypeNode) => collectExpandableDomAttributeWrapperContexts(heritageTypeNode, seen, excludedProps)));
-            }
-            if (Node.isTypeAliasDeclaration(declaration)) {
-                const aliasedTypeNode = declaration.getTypeNode();
-                if (!aliasedTypeNode)
-                    return [];
-                return collectExpandableDomAttributeWrapperContexts(aliasedTypeNode, seen, excludedProps);
-            }
-        }
-    }
-    return [];
-}
-function isPureExpandableDomAttributeWrapperType(typeNode) {
-    return isPureExpandableDomAttributeWrapperTypeNode(typeNode);
-}
-function isPureExpandableDomAttributeWrapperTypeNode(typeNode, seen = new Set()) {
-    if (seen.has(typeNode))
-        return false;
-    seen.add(typeNode);
-    if (Node.isParenthesizedTypeNode(typeNode)) {
-        return isPureExpandableDomAttributeWrapperTypeNode(typeNode.getTypeNode(), seen);
-    }
-    if (Node.isTypeOperatorTypeNode(typeNode)) {
-        return isPureExpandableDomAttributeWrapperTypeNode(typeNode.getTypeNode(), seen);
-    }
-    if (Node.isIntersectionTypeNode(typeNode) || Node.isUnionTypeNode(typeNode)) {
-        const childTypes = typeNode.getTypeNodes();
-        return (childTypes.length > 0 && childTypes.every((child) => isPureExpandableDomAttributeWrapperTypeNode(child, seen)));
-    }
-    const typeReferenceTarget = getTypeReferenceTargetNode(typeNode);
-    if (typeReferenceTarget) {
-        const typeName = getTypeReferenceName(typeNode);
-        if (!typeName)
-            return false;
-        const typeArguments = getTypeReferenceArguments(typeNode);
-        if (isExpandableDomAttributeWrapperName(typeName)) {
-            return true;
-        }
-        if (typeName === 'Omit' ||
-            typeName === 'Partial' ||
-            typeName === 'Readonly' ||
-            typeName === 'Required' ||
-            typeName === 'NonNullable') {
-            const wrappedType = typeArguments[0];
-            return wrappedType ? isPureExpandableDomAttributeWrapperTypeNode(wrappedType, seen) : false;
-        }
-        if (typeName === 'Pick')
-            return false;
-        for (const definition of getNodeDefinitions(typeReferenceTarget)) {
-            const declaration = definition.getDeclarationNode();
-            if (!declaration)
-                continue;
-            if (Node.isInterfaceDeclaration(declaration)) {
-                if (declaration.getMembers().length > 0)
-                    return false;
-                const heritageClauses = declaration.getHeritageClauses();
-                return (heritageClauses.length > 0 &&
-                    heritageClauses.every((clause) => clause
-                        .getTypeNodes()
-                        .every((heritageTypeNode) => isPureExpandableDomAttributeWrapperTypeNode(heritageTypeNode, seen))));
-            }
-            if (Node.isTypeAliasDeclaration(declaration)) {
-                const aliasedTypeNode = declaration.getTypeNode();
-                if (!aliasedTypeNode)
-                    return false;
-                return isPureExpandableDomAttributeWrapperTypeNode(aliasedTypeNode, seen);
-            }
-        }
-    }
-    return false;
-}
-function getSyntheticDomAttributeProps(typeNode) {
-    if (!typeNode)
-        return [];
-    const contexts = collectExpandableDomAttributeWrapperContexts(typeNode);
-    if (contexts.length === 0)
-        return [];
-    const propsByName = new Map();
-    for (const context of contexts) {
-        for (const prop of getDomAttributeSurface(context.name)) {
-            if (context.excludedProps.has(prop.name))
-                continue;
-            if (propsByName.has(prop.name))
-                continue;
-            propsByName.set(prop.name, prop);
-        }
-    }
-    return [...propsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-function getDomAttributeSurface(name, seen = new Set()) {
-    if (seen.has(name))
-        return [];
-    seen.add(name);
-    const propsByName = new Map();
-    for (const parentName of DOM_ATTRIBUTE_WRAPPER_PARENTS[name] ?? []) {
-        for (const prop of getDomAttributeSurface(parentName, seen)) {
-            propsByName.set(prop.name, prop);
-        }
-    }
-    for (const prop of DOM_ATTRIBUTE_PROP_SURFACES[name]) {
-        propsByName.set(prop.name, prop);
-    }
-    // Every prop on these surfaces is a DOM attribute by construction, so the
-    // provenance is known here without tracing the implementation. Copy each prop
-    // so that later provenance propagation cannot mutate the shared surface table.
-    return [...propsByName.values()].map((prop) => ({
-        ...prop,
-        domAttribute: true,
-    }));
-}
-function hasSyntheticDomChildren(typeNode) {
-    if (!typeNode)
-        return false;
-    return collectExpandableDomAttributeWrapperContexts(typeNode).some((context) => DOM_ATTRIBUTE_WRAPPERS_WITH_SYNTHETIC_CHILDREN.has(context.name));
-}
-function collectRestBindingNames(nameNode) {
-    const names = new Set();
-    if (!Node.isObjectBindingPattern(nameNode))
-        return names;
-    for (const element of nameNode.getElements()) {
-        if (!element.getDotDotDotToken())
-            continue;
-        const restNameNode = element.getNameNode();
-        if (Node.isIdentifier(restNameNode))
-            names.add(restNameNode.getText());
-    }
-    return names;
-}
-function isComponentSpreadAttribute(attribute, bindingNames) {
-    if (!Node.isJsxSpreadAttribute(attribute))
-        return false;
-    const expression = attribute.getExpression();
-    if (!Node.isIdentifier(expression) || !bindingNames.has(expression.getText()))
-        return false;
-    const tagName = getJsxTagNameNode(attribute)?.getText();
-    return tagName ? /^[A-Z]/.test(tagName) : false;
-}
-function inferPrimitiveDomPropsFromImplementation(funcNode, propsParam) {
-    const candidatePropNames = new Set();
-    const propsParamNameNode = propsParam.getNameNode();
-    if (Node.isIdentifier(propsParamNameNode)) {
-        candidatePropNames.add(propsParam.getName());
-    }
-    for (const restName of collectRestBindingNames(propsParamNameNode))
-        candidatePropNames.add(restName);
-    for (const variableDeclaration of funcNode.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
-        const initializer = variableDeclaration.getInitializer();
-        if (!initializer || !Node.isIdentifier(initializer) || !candidatePropNames.has(initializer.getText())) {
-            continue;
-        }
-        const nameNode = variableDeclaration.getNameNode();
-        if (!Node.isObjectBindingPattern(nameNode))
-            continue;
-        for (const restName of collectRestBindingNames(nameNode))
-            candidatePropNames.add(restName);
-    }
-    if (candidatePropNames.size === 0)
-        return [];
-    const inferredSurfaces = new Set();
-    const jsxElements = [
-        ...funcNode.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
-        ...funcNode.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
-    ];
-    for (const jsxElement of jsxElements) {
-        const tagNameNode = jsxElement.getTagNameNode();
-        const domSurface = JSX_PRIMITIVE_DOM_ATTRIBUTE_SURFACES[tagNameNode.getText()] ?? getBoundedImportedJsxDomSurface(tagNameNode);
-        if (!domSurface)
-            continue;
-        const hasForwardedPropsSpread = jsxElement
-            .getAttributes()
-            .some((attribute) => Node.isJsxSpreadAttribute(attribute) &&
-            Node.isIdentifier(attribute.getExpression()) &&
-            candidatePropNames.has(attribute.getExpression().getText()));
-        if (hasForwardedPropsSpread) {
-            inferredSurfaces.add(domSurface);
-        }
-    }
-    const propsByName = new Map();
-    for (const surface of inferredSurfaces) {
-        for (const prop of getDomAttributeSurface(surface)) {
-            propsByName.set(prop.name, prop);
-        }
-    }
-    return [...propsByName.values()].sort((a, b) => a.name.localeCompare(b.name));
-}
-function extractPickedPropsFromTypeNode(typeNode, slotNames, excludedProps = new Set()) {
-    if (!Node.isTypeReference(typeNode) && !Node.isExpressionWithTypeArguments(typeNode)) {
-        return [];
-    }
-    const [sourceTypeNode, pickedKeysNode] = typeNode.getTypeArguments();
-    if (!sourceTypeNode || !pickedKeysNode)
-        return [];
-    const sourcePropsByName = new Map();
-    for (const prop of getSyntheticDomAttributeProps(sourceTypeNode)) {
-        sourcePropsByName.set(prop.name, prop);
-    }
-    for (const prop of extractPropsFromTypeNode(sourceTypeNode, slotNames, undefined, excludedProps).props) {
-        if (!sourcePropsByName.has(prop.name)) {
-            sourcePropsByName.set(prop.name, prop);
-        }
-    }
-    const pickedKeys = getStringLiteralTypeValues(pickedKeysNode);
-    const props = [];
-    for (const name of pickedKeys) {
-        if (slotNames.has(name))
-            continue;
-        if (excludedProps.has(name))
-            continue;
-        const pickedProp = sourcePropsByName.get(name);
-        if (pickedProp) {
-            props.push(pickedProp);
-        }
-    }
-    return props.sort((a, b) => a.name.localeCompare(b.name));
-}
-function normalizePropsTypeNode(typeNode) {
-    if (!Node.isTypeReference(typeNode)) {
-        return { typeNode, hasWrappedChildren: false, suppressProps: false };
-    }
-    const typeName = getTypeReferenceName(typeNode);
-    if (!typeName) {
-        return { typeNode, hasWrappedChildren: false, suppressProps: false };
-    }
-    if (PROP_WRAPPER_TYPE_NAMES.has(typeName)) {
-        const firstTypeArg = typeNode.getTypeArguments()[0];
-        if (!firstTypeArg) {
-            return { typeNode, hasWrappedChildren: false, suppressProps: false };
-        }
-        return normalizePropsTypeNode(firstTypeArg);
-    }
-    if (CHILD_WRAPPER_TYPE_NAMES.has(typeName)) {
-        const firstTypeArg = typeNode.getTypeArguments()[0];
-        if (!firstTypeArg) {
-            return { typeNode, hasWrappedChildren: true, suppressProps: false };
-        }
-        if (isPureExpandableDomAttributeWrapperType(firstTypeArg)) {
-            return {
-                typeNode: firstTypeArg,
-                hasWrappedChildren: true,
-                suppressProps: true,
-            };
-        }
-        const normalized = normalizePropsTypeNode(firstTypeArg);
-        return {
-            ...normalized,
-            hasWrappedChildren: true,
-        };
-    }
-    return { typeNode, hasWrappedChildren: false, suppressProps: false };
-}
-function resolveForwardRefGenericPropsTypeNode(param) {
-    const parent = param.getParent();
-    if (!Node.isArrowFunction(parent) && !Node.isFunctionExpression(parent)) {
-        return undefined;
-    }
-    const callExpression = parent.getParent();
-    if (!Node.isCallExpression(callExpression)) {
-        return undefined;
-    }
-    const expressionText = callExpression.getExpression().getText();
-    if (!/(^|\.)forwardRef$/.test(expressionText)) {
-        return undefined;
-    }
-    const [, propsTypeNode] = callExpression.getTypeArguments();
-    return propsTypeNode;
-}
-const FC_TYPE_NAMES = new Set(['FC', 'FunctionComponent', 'VFC', 'VoidFunctionComponent']);
-function resolveFCGenericPropsTypeNode(param) {
-    const funcNode = param.getParent();
-    if (!Node.isArrowFunction(funcNode) && !Node.isFunctionExpression(funcNode)) {
-        return undefined;
-    }
-    const varDecl = funcNode.getParent();
-    if (!Node.isVariableDeclaration(varDecl)) {
-        return undefined;
-    }
-    const typeNode = varDecl.getTypeNode();
-    if (!typeNode || !Node.isTypeReference(typeNode)) {
-        return undefined;
-    }
-    const typeName = typeNode.getTypeName().getText().split('.').pop();
-    if (!typeName || !FC_TYPE_NAMES.has(typeName)) {
-        return undefined;
-    }
-    const typeArgs = typeNode.getTypeArguments();
-    return typeArgs[0];
-}
-function resolvePropsType(param) {
-    const typeNode = param.getTypeNode();
-    const fcGenericPropsTypeNode = resolveFCGenericPropsTypeNode(param);
-    const fallbackTypeNode = resolveForwardRefGenericPropsTypeNode(param) ?? fcGenericPropsTypeNode;
-    const effectiveTypeNode = typeNode ?? fallbackTypeNode;
-    if (!effectiveTypeNode) {
-        return {
-            type: param.getType(),
-            typeNode: param.getTypeNode() ?? param,
-            hasWrappedChildren: false,
-            suppressProps: false,
-        };
-    }
-    const normalized = normalizePropsTypeNode(effectiveTypeNode);
-    return {
-        type: normalized.typeNode.getType(),
-        typeNode: normalized.typeNode,
-        hasWrappedChildren: normalized.hasWrappedChildren || fcGenericPropsTypeNode !== undefined,
-        suppressProps: normalized.suppressProps,
-    };
-}
-function hasImplementationChildrenHint(funcNode, param) {
-    const nameNode = param.getNameNode();
-    const body = funcNode.getBody();
-    if (!body)
-        return false;
-    if (Node.isObjectBindingPattern(nameNode)) {
-        for (const element of nameNode.getElements()) {
-            if (element.getNameNode().getText() === 'children') {
-                return true;
-            }
-        }
-        const restBindingNames = collectRestBindingNames(nameNode);
-        if (restBindingNames.size === 0)
-            return false;
-        return body
-            .getDescendantsOfKind(SyntaxKind.JsxSpreadAttribute)
-            .some((attr) => isComponentSpreadAttribute(attr, restBindingNames));
-    }
-    if (!Node.isIdentifier(nameNode))
-        return false;
-    const paramName = nameNode.getText();
-    if (body
-        .getDescendantsOfKind(SyntaxKind.PropertyAccessExpression)
-        .some((expr) => expr.getExpression().getText() === paramName && expr.getName() === 'children')) {
-        return true;
-    }
-    return body
-        .getDescendantsOfKind(SyntaxKind.JsxSpreadAttribute)
-        .some((attr) => isComponentSpreadAttribute(attr, new Set([paramName])));
-}
-export async function extractReactComponents(filePaths) {
-    const { components, warnings, exclusions, project } = extractTsxComponents(filePaths, /\.[jt]sx$/, (sourceFile, exclusions) => {
-        if (isStencilFile(sourceFile))
-            return [];
-        const fileExports = [...sourceFile.getExportedDeclarations().keys()];
-        const isNext = isNextJsComponent(sourceFile.getFilePath(), fileExports);
-        return extractFromSourceFile(sourceFile, isNext, exclusions);
-    });
-    const propsToComponent = new Map();
-    const componentNames = new Set();
-    for (const c of components) {
-        componentNames.add(c.name);
-        if (c._propsTypeName)
-            propsToComponent.set(c._propsTypeName, c.name);
-    }
-    for (const c of components) {
-        for (const slot of c.slots) {
-            const found = new Set();
-            if (slot._rawTypeText) {
-                for (const n of extractAllowedComponentsFromTypeText(slot._rawTypeText, {
-                    propsToComponent,
-                    componentNames,
-                })) {
-                    found.add(n);
-                }
-            }
-            if (slot._rawJsdoc) {
-                for (const n of extractAllowedComponentsFromJsdoc(slot._rawJsdoc, componentNames)) {
-                    found.add(n);
-                }
-            }
-            delete slot._rawTypeText;
-            delete slot._rawJsdoc;
-            if (found.size > 0) {
-                slot.allowedComponents = [...found].sort();
-            }
-        }
-    }
-    // Structural evidence (usage, not a declared slot contract) — see
-    // structural-slot-evidence.ts. Only fills slots the typed-slot pass above
-    // found nothing for; a declared contract always takes precedence. File-wide
-    // signals (type-predicate functions, `.type === Component` identity checks)
-    // are computed once per file and shared across every component in it, since
-    // they aren't tied to one specific slot.
-    const structuralByFile = new Map();
-    const structuralNamesForFile = (filePath) => {
-        const cached = structuralByFile.get(filePath);
-        if (cached)
-            return cached;
-        const sourceFile = project?.getSourceFile(filePath);
-        if (!sourceFile)
-            return [];
-        const ctx = { propsToComponent, componentNames };
-        const found = new Set([
-            ...collectTypePredicateComponentReferences(sourceFile, ctx),
-            ...collectRuntimeTypeCheckComponentReferences(sourceFile, componentNames),
-        ]);
-        const names = [...found].sort();
-        structuralByFile.set(filePath, names);
-        return names;
-    };
-    for (const c of components) {
-        const fromFile = structuralNamesForFile(c.source);
-        const fromRender = c._funcNode ? collectRenderedComponentReferences(c._funcNode, componentNames, c.name) : [];
-        const propTypesByName = new Map(c.props.map((p) => [p.name, p.type]));
-        const fromArrayMap = c._funcNode
-            ? collectArrayMapRenderComponentReferences(c._funcNode, componentNames, c.name, propTypesByName)
-            : [];
-        const structural = new Set([...fromFile, ...fromRender, ...fromArrayMap]);
-        if (structural.size === 0)
-            continue;
-        // Signal D — array-map render — is the only signal that can imply an
-        // authorable compositional slot the parent didn't declare. When it fires
-        // and the parent has no declared slots at all, synthesise a default
-        // `children` slot so the evidence has somewhere to land. Signals A/B/C
-        // still only decorate existing slots to keep the current provenance
-        // guarantees intact.
-        const synthesisedSlot = fromArrayMap.length > 0 && c.slots.length === 0 ? { name: 'children', isDefault: true } : undefined;
-        if (synthesisedSlot) {
-            c.slots.push(synthesisedSlot);
-        }
-        for (const slot of c.slots) {
-            if (slot.allowedComponents && slot.allowedComponents.length > 0)
-                continue;
-            // Synthesised slots carry ONLY Signal D's mapped children — the strict
-            // signal is what earned the slot; unioning in Signal C's render-body
-            // hits would smuggle private structural pieces (icons, headings) into
-            // an authorable slot the caller can't actually compose against.
-            // Declared slots keep the existing union so A/B/C still enrich them.
-            slot.structuralAllowedComponents = slot === synthesisedSlot ? [...fromArrayMap].sort() : [...structural].sort();
-        }
-    }
-    for (const c of components) {
-        delete c._funcNode;
-    }
-    // Propagate DOM provenance only through actual component-to-component JSX
-    // forwarding edges. Shared declarations alone never transfer provenance.
-    const componentsByIdentity = new Map(components
-        .filter((component) => component._componentIdentity)
-        .map((component) => [component._componentIdentity, component]));
-    let changed = true;
-    while (changed) {
-        changed = false;
-        for (const component of components) {
-            for (const edge of component._propForwardingEdges ?? []) {
-                const target = componentsByIdentity.get(edge.targetComponentIdentity);
-                const targetProp = target?.props.find((prop) => prop.name === edge.targetProp);
-                const sourceProp = component.props.find((prop) => prop.name === edge.sourceProp);
-                if (targetProp?.domAttribute && sourceProp && !sourceProp.domAttribute) {
-                    sourceProp.domAttribute = true;
-                    changed = true;
-                }
-            }
-        }
-    }
-    for (const component of components) {
-        delete component._componentIdentity;
-        delete component._propsTypeName;
-        delete component._propForwardingEdges;
-    }
-    return {
-        components: components.sort((a, b) => a.name.localeCompare(b.name)),
-        warnings,
-        exclusions,
-    };
-}
-function extractFromSourceFile(sourceFile, isNext, exclusions) {
-    const components = [];
-    const usesCreateContext = sourceFileUsesCreateContext(sourceFile);
-    for (const { name, declarations } of getRenderableExports(sourceFile, exclusions, {
-        allowVariableDeclaration: true,
-        hookReason: 'React hook names are not renderable components',
-    })) {
-        const funcNode = resolveBestFunctionNode(declarations);
-        if (!funcNode)
-            continue;
-        if (funcNode.getSourceFile().getFilePath() !== sourceFile.getFilePath())
-            continue;
-        const params = funcNode.getParameters();
-        if (params.length === 0) {
-            components.push({
-                name,
-                source: sourceFile.getFilePath(),
-                sourcePath: sourceFile.getFilePath(),
-                framework: isNext ? 'next' : 'react',
-                props: [],
-                slots: [],
-                ...(usesCreateContext && { usesCreateContext: true }),
-            });
-            continue;
-        }
-        const resolvedPropsType = resolvePropsType(params[0]);
-        const firstParamType = resolvedPropsType.type;
-        const firstParamTypeNode = resolvedPropsType.typeNode;
-        const renderPropSlotNames = resolvedPropsType.suppressProps
-            ? new Set()
-            : collectRenderPropSlotNames(firstParamType);
-        const { props, hasChildren } = resolvedPropsType.suppressProps
-            ? { props: [], hasChildren: false }
-            : extractPropsFromType(firstParamType, renderPropSlotNames, firstParamTypeNode);
-        const hasMeaningfulExtractedProps = props.some((prop) => !prop.name.startsWith('__scope'));
-        const defaults = extractDefaultValues(funcNode);
-        const hasImplementationChildren = hasImplementationChildrenHint(funcNode, params[0]);
-        const slots = extractSlots(firstParamType, hasChildren ||
-            resolvedPropsType.hasWrappedChildren ||
-            hasSyntheticDomChildren(resolvedPropsType.typeNode) ||
-            hasImplementationChildren);
-        const syntheticDomProps = resolvedPropsType.suppressProps
-            ? []
-            : getSyntheticDomAttributeProps(resolvedPropsType.typeNode);
-        const implementationPrimitiveDomProps = !resolvedPropsType.suppressProps && !hasMeaningfulExtractedProps && syntheticDomProps.length === 0
-            ? inferPrimitiveDomPropsFromImplementation(funcNode, params[0])
-            : [];
-        const shouldTryBindingFallback = !resolvedPropsType.suppressProps &&
-            (containsImportedOmitWrappedCustomProps(firstParamTypeNode) ||
-                containsAnyPickType(firstParamTypeNode) ||
-                (!hasMeaningfulExtractedProps && Node.isObjectBindingPattern(params[0].getNameNode())));
-        const bindingFallbackProps = shouldTryBindingFallback
-            ? extractDestructuredBindingFallbackProps(funcNode, params[0], new Set(props.map((prop) => prop.name)), renderPropSlotNames)
-            : [];
-        const mergedPropsByName = new Map();
-        for (const prop of props) {
-            mergedPropsByName.set(prop.name, prop);
-        }
-        for (const prop of syntheticDomProps) {
-            if (!mergedPropsByName.has(prop.name)) {
-                mergedPropsByName.set(prop.name, prop);
-            }
-        }
-        for (const prop of implementationPrimitiveDomProps) {
-            if (!mergedPropsByName.has(prop.name)) {
-                mergedPropsByName.set(prop.name, prop);
-            }
-        }
-        for (const prop of bindingFallbackProps) {
-            if (!mergedPropsByName.has(prop.name)) {
-                mergedPropsByName.set(prop.name, prop);
-            }
-        }
-        const resolvedProps = [...mergedPropsByName.values()];
-        const noUsefulTypes = resolvedProps.length === 0 || resolvedProps.every((p) => p.type === 'any');
-        const finalProps = noUsefulTypes ? (extractPropTypes(sourceFile, name) ?? resolvedProps) : resolvedProps;
-        const propsWithDefaults = finalProps.map((p) => {
-            if (!defaults.has(p.name))
-                return p;
-            const defaultValue = defaults.get(p.name);
-            return {
-                ...p,
-                required: false,
-                defaultValue,
-            };
-        });
-        const propDataflow = collectPropDataflow(funcNode, params[0], new Set(propsWithDefaults.map((prop) => prop.name)));
-        const filteredProps = filterImplementationOnlyAliasProps(propsWithDefaults, funcNode).map((prop) => propDataflow.intrinsicDomProps.has(prop.name) ? { ...prop, domAttribute: true } : prop);
-        const existingSlotNames = new Set(slots.map((s) => s.name));
-        const expandedSlots = [];
-        const propsAfterSlotExpansion = filteredProps.filter((prop) => {
-            if (existingSlotNames.has(prop.name))
-                return true;
-            const isElementSlot = isReactElementGenericSlotType(prop.type);
-            if (shouldBeSlot(prop.name, prop.type) || isElementSlot) {
-                expandedSlots.push({
-                    name: prop.name,
-                    isDefault: false,
-                    ...(isElementSlot ? { _rawTypeText: prop.type } : {}),
-                });
-                return false;
-            }
-            return true;
-        });
-        const finalSlots = [...slots, ...expandedSlots];
-        const propsTypeName = firstParamTypeNode?.getText?.().trim();
-        const propsTypeNameCapture = propsTypeName && /^[A-Za-z_$][\w$]*$/.test(propsTypeName) ? propsTypeName : undefined;
-        components.push({
-            name,
-            source: sourceFile.getFilePath(),
-            sourcePath: sourceFile.getFilePath(),
-            framework: isNext ? 'next' : 'react',
-            props: propsAfterSlotExpansion,
-            slots: finalSlots,
-            ...(usesCreateContext && { usesCreateContext: true }),
-            _componentIdentity: getComponentIdentity(funcNode),
-            _funcNode: funcNode,
-            ...(propsTypeNameCapture ? { _propsTypeName: propsTypeNameCapture } : {}),
-            ...(propDataflow.componentEdges.length > 0 ? { _propForwardingEdges: propDataflow.componentEdges } : {}),
-        });
-    }
-    return components;
-}
-const PROP_TYPES_MAP = {
-    string: 'string',
-    number: 'number',
-    bool: 'boolean',
-    func: 'function',
-    node: 'ReactNode',
-    element: 'ReactElement',
-    any: 'any',
-    array: 'any[]',
-    object: 'object',
-    symbol: 'symbol',
-};
-function extractPropTypes(sourceFile, componentName) {
-    const props = [];
-    for (const statement of sourceFile.getStatements()) {
-        if (!Node.isExpressionStatement(statement))
-            continue;
-        const expr = statement.getExpression();
-        if (!Node.isBinaryExpression(expr))
-            continue;
-        const left = expr.getLeft().getText();
-        if (left !== `${componentName}.propTypes`)
-            continue;
-        const right = expr.getRight();
-        if (!Node.isObjectLiteralExpression(right))
-            continue;
-        for (const property of right.getProperties()) {
-            if (!Node.isPropertyAssignment(property))
-                continue;
-            const propName = property.getName();
-            const initText = property.getInitializer()?.getText() ?? '';
-            let type = 'any';
-            let required = false;
-            let allowedValues;
-            if (initText.includes('.isRequired')) {
-                required = true;
-            }
-            const oneOfMatch = initText.match(/PropTypes\.oneOf\(\[([^\]]+)\]\)/);
-            if (oneOfMatch) {
-                allowedValues = oneOfMatch[1]
-                    .split(',')
-                    .map((v) => v.trim().replace(/^['"]|['"]$/g, ''))
-                    .filter(Boolean)
-                    .sort();
-            }
-            for (const [ptKey, tsType] of Object.entries(PROP_TYPES_MAP)) {
-                if (initText.includes(`PropTypes.${ptKey}`)) {
-                    type = tsType;
-                    break;
-                }
-            }
-            props.push({
-                name: propName,
-                type,
-                required,
-                ...(allowedValues && { allowedValues }),
-                sourceStartLine: property.getStartLineNumber(),
-                sourceEndLine: property.getEndLineNumber(),
-            });
-        }
-        return props.sort((a, b) => a.name.localeCompare(b.name));
-    }
-    return undefined;
-}
-function resolveFunctionNode(decl) {
-    if (Node.isFunctionDeclaration(decl))
-        return decl;
-    if (Node.isArrowFunction(decl))
-        return decl;
-    if (Node.isFunctionExpression(decl))
-        return decl;
-    if (Node.isVariableDeclaration(decl)) {
-        const init = decl.getInitializer();
-        if (init && Node.isArrowFunction(init))
-            return init;
-        if (init && Node.isFunctionExpression(init))
-            return init;
-        if (init && Node.isCallExpression(init))
-            return resolveFunctionFromCallExpression(init, new Set());
-    }
-    return undefined;
-}
-function resolveBestFunctionNode(declarations) {
-    const candidates = declarations
-        .map((decl) => resolveFunctionNode(decl))
-        .filter((candidate) => candidate !== undefined);
-    const implementation = candidates.find((candidate) => !Node.isFunctionDeclaration(candidate) || candidate.getBody() !== undefined);
-    return implementation ?? candidates[0];
-}
-function resolveForwardRefFunction(callExpr) {
-    if (!Node.isCallExpression(callExpr))
-        return undefined;
-    const expressionText = callExpr.getExpression().getText();
-    if (!/(^|\.)forwardRef$/.test(expressionText))
-        return undefined;
-    const firstArg = callExpr.getArguments()[0];
-    if (!firstArg)
-        return undefined;
-    if (Node.isArrowFunction(firstArg))
-        return firstArg;
-    if (Node.isFunctionExpression(firstArg))
-        return firstArg;
-    if (Node.isIdentifier(firstArg)) {
-        const declarations = getNodeDefinitions(firstArg).flatMap((definition) => {
-            const declarationNode = definition.getDeclarationNode();
-            return declarationNode ? [declarationNode] : [];
-        });
-        for (const declaration of declarations) {
-            const resolved = resolveFunctionNode(declaration);
-            if (resolved)
-                return resolved;
-        }
-    }
-    return undefined;
-}
-function resolveFunctionFromCallExpression(callExpr, seen) {
-    return resolveForwardRefFunction(callExpr) ?? resolveReturnedFunctionFromFactoryCall(callExpr, seen);
-}
-function resolveReturnedFunctionFromFactoryCall(callExpr, seen) {
-    const expression = callExpr.getExpression();
-    if (!Node.isIdentifier(expression))
-        return undefined;
-    for (const definition of getNodeDefinitions(expression)) {
-        const declaration = definition.getDeclarationNode();
-        if (!declaration)
-            continue;
-        const resolved = resolveReturnedFunctionFromDeclaration(declaration, seen);
-        if (resolved)
-            return resolved;
-    }
-    return undefined;
-}
-function resolveReturnedFunctionFromDeclaration(node, seen) {
-    if (seen.has(node))
-        return undefined;
-    seen.add(node);
-    if (Node.isVariableDeclaration(node)) {
-        const initializer = node.getInitializer();
-        if (!initializer)
-            return undefined;
-        if (Node.isArrowFunction(initializer) || Node.isFunctionExpression(initializer)) {
-            return resolveReturnedFunctionFromCallable(initializer, seen);
-        }
-        if (Node.isCallExpression(initializer)) {
-            return resolveFunctionFromCallExpression(initializer, seen);
-        }
-        return undefined;
-    }
-    if (Node.isFunctionDeclaration(node) || Node.isFunctionExpression(node) || Node.isArrowFunction(node)) {
-        return resolveReturnedFunctionFromCallable(node, seen);
-    }
-    return undefined;
-}
-function resolveReturnedFunctionFromCallable(fn, seen) {
-    const body = fn.getBody();
-    if (!body)
-        return undefined;
-    if (!Node.isBlock(body)) {
-        return resolveReturnedFunctionFromExpression(body, seen);
-    }
-    for (const statement of body.getStatements()) {
-        if (!Node.isReturnStatement(statement))
-            continue;
-        const expression = statement.getExpression();
-        if (!expression)
-            continue;
-        const resolved = resolveReturnedFunctionFromExpression(expression, seen);
-        if (resolved)
-            return resolved;
-    }
-    return undefined;
-}
-function resolveReturnedFunctionFromExpression(node, seen) {
-    if (Node.isArrowFunction(node) || Node.isFunctionExpression(node))
-        return node;
-    if (Node.isParenthesizedExpression(node)) {
-        return resolveReturnedFunctionFromExpression(node.getExpression(), seen);
-    }
-    if (Node.isCallExpression(node)) {
-        return resolveFunctionFromCallExpression(node, seen);
-    }
-    if (Node.isIdentifier(node)) {
-        for (const definition of getNodeDefinitions(node)) {
-            const declaration = definition.getDeclarationNode();
-            if (!declaration)
-                continue;
-            const resolved = resolveReturnedFunctionFromDeclaration(declaration, seen);
-            if (resolved)
-                return resolved;
-        }
-    }
-    return undefined;
-}