sveld 0.35.1 → 0.36.0

package/lib/ComponentParser.d.ts

@@ -1,822 +0,0 @@
-import type { Property } from "estree";
-import type { Node } from "estree-walker";
-import type { SveldDiagnostic } from "./diagnostics";
-/** Returns `value`, or `undefined` when it's `undefined` or the empty string. */
-export declare function assignValue(value?: "" | string): string | undefined;
-/** Structured JSDoc tag (e.g. `{ name: "since", body: "1.2.0" }`). */
-export interface JsDocPassthroughTag {
-    name: string;
-    body: string;
-}
-/**
- * From `@deprecated` JSDoc: a message string, or `true` when the tag has no message.
- */
-export type DeprecatedValue = string | true;
-export interface LegacyAstRoot {
-    module?: Node;
-    html?: Node;
-    instance?: Node;
-}
-export interface SourcePosition {
-    /** 1-based source line number */
-    line: number;
-    /** 0-based source column number */
-    column: number;
-}
-export interface SourceRange {
-    start: SourcePosition;
-    end: SourcePosition;
-}
-export interface RunesPropTypeMetadata {
-    optional: boolean;
-    source?: SourceRange;
-    type: string;
-}
-export interface RunesPropsDeclarationMetadata {
-    canonicalType?: string;
-    props: Map<string, RunesPropTypeMetadata>;
-    referencedImportedTypes: Set<string>;
-    referencedLocalTypes: Set<string>;
-}
-export type ModernRunesTypeNode = {
-    type?: string;
-    id?: {
-        name?: string;
-    };
-    start?: number;
-    end?: number;
-    body?: {
-        body?: ModernRunesTypeMember[];
-    };
-    typeAnnotation?: ModernRunesTypeNode;
-    typeName?: unknown;
-    types?: ModernRunesTypeNode[];
-    members?: ModernRunesTypeMember[];
-    /** Declaration-side `<T, U = Default>` (interfaces/type aliases). */
-    typeParameters?: {
-        params?: Array<{
-            name?: string;
-        }>;
-    };
-    /** Reference-side `<string, number>` concrete arguments (`TSTypeReference`). */
-    typeArguments?: {
-        params?: ModernRunesTypeNode[];
-    };
-};
-export type ModernRunesTypeMember = {
-    type?: string;
-    computed?: boolean;
-    optional?: boolean;
-    start?: number;
-    end?: number;
-    key?: Property["key"];
-    typeAnnotation?: {
-        start?: number;
-        end?: number;
-        typeAnnotation?: ModernRunesTypeNode;
-    };
-};
-export interface TypeImportBinding {
-    importedName?: string;
-    localName: string;
-    source: string;
-    specifierType: "default" | "named" | "namespace";
-}
-export interface LocalTypeDeclaration {
-    code: string;
-    node: ModernRunesTypeNode;
-    start: number;
-}
-export interface ParsedComponentTypeScriptMetadata {
-    canonicalPropsType?: string;
-    canonicalPropNames: string[];
-    localTypeDeclarations: string[];
-    typeImportStatements: string[];
-    /**
-     * Whether `canonicalPropsType` mentions one of the component's own
-     * `<script generics="...">` parameters (e.g. `Props<T>`). The semantic
-     * resolver has no binding for `T`, so `resolveTypes` must leave this
-     * component's props as their AST-derived text rather than expand them.
-     */
-    referencesComponentGenerics?: boolean;
-}
-export declare const PARSED_COMPONENT_TYPE_SCRIPT_METADATA: unique symbol;
-export declare function getParsedComponentTypeScriptMetadata(component: {
-    [PARSED_COMPONENT_TYPE_SCRIPT_METADATA]?: ParsedComponentTypeScriptMetadata;
-}): ParsedComponentTypeScriptMetadata | undefined;
-/** One prop returned by the TypeScript checker during `resolveTypes`. */
-export interface ResolvedComponentProp {
-    name: string;
-    type: string;
-    isRequired: boolean;
-    description?: string;
-}
-/** Append checker-resolved props. Names the AST walker already found are left alone. */
-export declare function applyResolvedProps(component: ParsedComponent, resolved: ResolvedComponentProp[]): void;
-export type SyntaxMode = "legacy" | "runes";
-export type ScriptLanguage = "js" | "ts";
-export type ScopeBindingKind = "prop" | "local";
-export type ScopeBinding = {
-    kind: ScopeBindingKind;
-    publicPropName?: string;
-};
-export type LexicalScope = Map<string, ScopeBinding>;
-export type ComponentPropTypeSource = "typescript" | "jsdoc" | "default" | "inferred" | "unknown";
-export type ComponentPropDefaultValueKind = "literal" | "array" | "object" | "expression" | "function" | "unknown";
-export interface ComponentPropDefaultValue {
-    raw: string;
-    kind: ComponentPropDefaultValueKind;
-    value?: unknown;
-}
-export interface ProcessedInitializer {
-    value?: string;
-    type?: string;
-    isFunction: boolean;
-    defaultValue?: ComponentPropDefaultValue;
-    /** JSDoc from identifier default when the prop has none. */
-    resolvedType?: string;
-    resolvedDescription?: string;
-    resolvedParams?: ComponentPropParam[];
-    resolvedReturnType?: string;
-}
-type ModernScriptAttribute = {
-    name?: string;
-    value?: Array<{
-        data?: string;
-        raw?: string;
-    }> | boolean;
-    start?: number;
-    end?: number;
-};
-export type ModernScriptNode = {
-    attributes?: ModernScriptAttribute[];
-};
-/**
- * Diagnostic information for component parsing.
- *
- * Used to provide context about the component being parsed for error
- * messages and logging.
- */
-interface ComponentParserDiagnostics {
-    /** The module/component name (e.g., "Button", "App") */
-    moduleName: string;
-    /** The file path to the component (e.g., "./Button.svelte") */
-    filePath: string;
-}
-export type ComponentPropBinding = "readonly" | "writable";
-/**
- * Parameter information for function props.
- *
- * Extracted from JSDoc `@param` tags to provide detailed function signatures.
- */
-export interface ComponentPropParam {
-    /** The parameter name */
-    name: string;
-    /** The parameter type (e.g., "string", "number", "CustomType") */
-    type: string;
-    /** Optional description from JSDoc */
-    description?: string;
-    /** Whether the parameter is optional */
-    optional?: boolean;
-}
-/**
- * Component prop definition extracted from Svelte component.
- *
- * Represents a single prop that can be passed to the component, including
- * its type, default value, description, and metadata about whether it's
- * required, reactive, or a function.
- */
-export interface ComponentProp {
-    /** The prop name as declared in the component */
-    name: string;
-    /** The declaration kind: "let" (required), "const" (optional with default), or "function" */
-    kind: "let" | "const" | "function";
-    /** Whether this prop is declared as `const` (has a default value) */
-    constant: boolean;
-    /** The TypeScript type of the prop (e.g., "string", "number | string") */
-    type?: string;
-    /** Conservative provenance for the prop type */
-    typeSource?: ComponentPropTypeSource;
-    /** Local variable name, emitted when it differs from the public prop name */
-    localName?: string;
-    /** The default value as a string representation of the source code */
-    value?: string;
-    /** Structured default value metadata for docs UIs */
-    defaultValue?: ComponentPropDefaultValue;
-    /** Description extracted from JSDoc comments */
-    description?: string;
-    /** Function parameters (for function props) extracted from `@param` tags */
-    params?: ComponentPropParam[];
-    /** Return type (for function props) extracted from `@returns` tag */
-    returnType?: string;
-    /** Whether this prop is a function (arrow function or function expression) */
-    isFunction: boolean;
-    /** Whether this prop is a function declaration (not an expression) */
-    isFunctionDeclaration: boolean;
-    /** Whether this prop is required (no default value, declared with `let`) */
-    isRequired: boolean;
-    /** Whether this prop is reactive (can change and trigger reactivity) */
-    reactive: boolean;
-    /** Explicit author-documented binding direction from `@bindable` JSDoc */
-    binding?: ComponentPropBinding;
-    /** True when the prop is explicitly declared with Svelte 5 `$bindable()` */
-    bindable?: true;
-    /** From `@deprecated` JSDoc. */
-    deprecated?: DeprecatedValue;
-    /** Structured `@since` / `@example` tags, in source order. */
-    tags?: JsDocPassthroughTag[];
-    /** Source range for the prop declaration, when available */
-    source?: SourceRange;
-}
-/**
- * Component slot definition.
- *
- * Represents a slot that can be used to pass content into the component.
- * Includes information about slot props, fallback content, and descriptions.
- */
-export interface ComponentSlot {
-    /** The slot name (null or undefined for default slot) */
-    name?: string | null;
-    /** Whether this is the default slot */
-    default: boolean;
-    /** Fallback content to display when slot is not provided */
-    fallback?: string;
-    /** TypeScript type definition for slot props (e.g., "{ title: string }") */
-    slot_props?: string;
-    /** Description extracted from JSDoc `@slot` or `@snippet` tags */
-    description?: string;
-    /** From `@deprecated` JSDoc. */
-    deprecated?: DeprecatedValue;
-    /**
-     * JSDoc tags that appeared after the prose description and before `@slot` / `@snippet`
-     * (e.g. `@example`), in source order.
-     */
-    tags?: JsDocPassthroughTag[];
-    /** Source range for the slot/snippet declaration or documentation tag, when available */
-    source?: SourceRange;
-}
-/**
- * Slot prop value definition.
- *
- * Used internally to track slot prop types and whether they should be
- * replaced with prop type references.
- */
-export interface SlotPropValue {
-    /** The prop type value or reference */
-    value?: string;
-    /** Whether this value should be replaced with a prop type reference */
-    replace: boolean;
-}
-export type SlotProps = Record<string, SlotPropValue>;
-/**
- * Internal representation of {@link ComponentSlot} used while parsing.
- *
- * `slot_props` is either raw TS type text (from a JSDoc `@slot`/`@snippet` tag,
- * used as-is) or a structured {@link SlotProps} map (from template parsing,
- * formatted into TS type text once at the end of the parse). Keeping it
- * structured until then avoids a JSON.stringify/JSON.parse round-trip per slot.
- */
-export type InternalComponentSlot = Omit<ComponentSlot, "slot_props"> & {
-    slot_props?: string | SlotProps;
-};
-/**
- * Event that is forwarded from a child component or element.
- *
- * Forwarded events are those that use `on:eventname` syntax without
- * a handler, passing the event through to the parent.
- */
-export interface ForwardedEvent {
-    /** Always "forwarded" for forwarded events */
-    type: "forwarded";
-    /** The event name (e.g., "click", "change") */
-    name: string;
-    /** The element or component that forwards this event */
-    element: ComponentInlineElement | ComponentElement;
-    /** Description extracted from JSDoc `@event` tags */
-    description?: string;
-    /** From `@deprecated` JSDoc. */
-    deprecated?: DeprecatedValue;
-    /** The detail type if explicitly specified in `@event` tag */
-    detail?: string;
-    /** Structured `@since` / `@example` tags, in source order. */
-    tags?: JsDocPassthroughTag[];
-    /** Source range for the forwarded event declaration or documentation tag, when available */
-    source?: SourceRange;
-}
-/**
- * Event that is dispatched by the component.
- *
- * Dispatched events are those created with `createEventDispatcher()` and
- * dispatched via `dispatch("eventname", detail)`, or dispatched from a custom
- * element via `$host().dispatchEvent(new CustomEvent("eventname", { detail }))`.
- */
-export interface DispatchedEvent {
-    /** Always "dispatched" for dispatched events */
-    type: "dispatched";
-    /** The event name (e.g., "click", "change") */
-    name: string;
-    /** The detail type (e.g., "{ value: string }", "null", "CustomEvent<...>") */
-    detail?: string;
-    /** Description extracted from JSDoc `@event` tags */
-    description?: string;
-    /** From `@deprecated` JSDoc. */
-    deprecated?: DeprecatedValue;
-    /** Structured `@since` / `@example` tags, in source order. */
-    tags?: JsDocPassthroughTag[];
-    /** Source range for the dispatched event call or documentation tag, when available */
-    source?: SourceRange;
-}
-export type ComponentEvent = ForwardedEvent | DispatchedEvent;
-/**
- * Serialized version of {@link ForwardedEvent} for JSON output.
- *
- * This interface maintains backward compatibility by serializing the `element`
- * property as a string instead of an object. The element name is extracted
- * from the {@link ComponentInlineElement} or {@link ComponentElement} object.
- *
- * @example
- * ```ts
- * // ForwardedEvent with element object:
- * { type: "forwarded", name: "click", element: { type: "Element", name: "button" } }
- *
- * // SerializedForwardedEvent for JSON:
- * { type: "forwarded", name: "click", element: "button" }
- * ```
- */
-export interface SerializedForwardedEvent {
-    /** Always "forwarded" for forwarded events */
-    type: "forwarded";
-    /** The event name (e.g., "click", "change") */
-    name: string;
-    /**
-     * Serialized as string for JSON backward compatibility.
-     * In the internal API, this is an object, but for JSON output it's a string.
-     */
-    element: string;
-    /** Description extracted from JSDoc `@event` tags */
-    description?: string;
-    /** From `@deprecated` JSDoc. */
-    deprecated?: DeprecatedValue;
-    /** The detail type if explicitly specified in `@event` tag */
-    detail?: string;
-    /** Structured `@since` / `@example` tags, in source order. */
-    tags?: JsDocPassthroughTag[];
-    /** Source range for the forwarded event declaration or documentation tag, when available */
-    source?: SourceRange;
-}
-export type SerializedComponentEvent = SerializedForwardedEvent | DispatchedEvent;
-/**
- * Type definition extracted from JSDoc `@typedef` tags.
- *
- * Represents custom types defined in component comments that can be
- * referenced by props, events, and other type annotations.
- */
-export interface TypeDef {
-    /** The type string representation (e.g., "{ x: number; y: number }") */
-    type: string;
-    /** The type name (e.g., "Point", "User") */
-    name: string;
-    /** Description extracted from JSDoc comments */
-    description?: string;
-    /** The full TypeScript type definition string (e.g., "type Point = { x: number; y: number }") */
-    ts: string;
-}
-export type ComponentGenerics = [name: string, type: string] | null;
-/**
- * Represents an inline Svelte component element.
- *
- * Used to identify which component forwards an event or accepts rest props.
- */
-export interface ComponentInlineElement {
-    /** Always "InlineComponent" for component elements */
-    type: "InlineComponent";
-    /** The component name (e.g., "Button", "Modal") */
-    name: string;
-}
-export interface ComponentElement {
-    type: "Element";
-    name: string;
-    /**
-     * For `svelte:element`, stores the hardcoded element tag if `this` is a literal string.
-     *
-     * When `svelte:element` is used with a static tag (e.g., `svelte:element this="div"`),
-     * this property contains the tag name. If the tag is dynamic, this property is undefined.
-     *
-     * @example
-     * ```svelte
-     * <!-- Static tag -->
-     * <svelte:element this="div" bind:this={elementRef} />
-     * // thisValue: "div"
-     *
-     * <!-- Dynamic tag -->
-     * <svelte:element this={tagName} bind:this={elementRef} />
-     * // thisValue: undefined
-     * ```
-     */
-    thisValue?: string;
-    /** Inline or block description from the `@restProps` JSDoc tag */
-    description?: string;
-}
-export type RestProps = undefined | ComponentInlineElement | ComponentElement;
-/**
- * Interface extension information from JSDoc `@extends` tag.
- *
- * Allows components to extend external TypeScript interfaces for
- * better type safety and code reuse.
- */
-export interface Extends {
-    /** The interface name to extend (e.g., "ButtonProps") */
-    interface: string;
-    /** The import path for the interface (e.g., "./types" or "carbon-components-svelte") */
-    import: string;
-}
-export interface ComponentPropBindings {
-    elements: string[];
-}
-/**
- * Property definition for a component context.
- *
- * Represents a single property in a context object created with `setContext`.
- */
-export interface ComponentContextProp {
-    /** The property name */
-    name: string;
-    /** The property type (inferred from JSDoc or variable types) */
-    type: string;
-    /** Description extracted from JSDoc comments on the variable */
-    description?: string;
-    /** Whether the property is optional */
-    optional: boolean;
-}
-/**
- * Component context definition.
- *
- * Represents a context created with `setContext(key, value)` that can be
- * accessed by child components via `getContext(key)`.
- */
-export interface ComponentContext {
-    /** The context key (e.g., "modal", "tabs") */
-    key: string;
-    /** The generated TypeScript type name (e.g., "ModalContext", "TabsContext") */
-    typeName: string;
-    /** Description extracted from JSDoc comments */
-    description?: string;
-    /** Properties available in this context */
-    properties: ComponentContextProp[];
-}
-/**
- * Complete parsed component metadata.
- *
- * This is the main return type from {@link ComponentParser.parseSvelteComponent}.
- * Contains all extracted information about a Svelte component including props,
- * slots, events, types, and more.
- *
- * @example
- * ```ts
- * const parser = new ComponentParser();
- * const parsed = parser.parseSvelteComponent(source, {
- *   moduleName: "Button",
- *   filePath: "./Button.svelte"
- * });
- *
- * // Access component metadata:
- * parsed.props        // Array of component props
- * parsed.slots        // Array of component slots
- * parsed.events       // Array of component events
- * parsed.typedefs     // Array of custom type definitions
- * parsed.contexts     // Array of context definitions
- * ```
- */
-export interface ParsedComponent {
-    /** Source range for the component source that was parsed */
-    source?: SourceRange;
-    /** Whether the component uses legacy or runes syntax according to compiler metadata */
-    syntaxMode: SyntaxMode;
-    /** Language used by the instance or module script when it can be determined */
-    scriptLanguage?: ScriptLanguage;
-    /** Component props that can be passed to the component */
-    props: ComponentProp[];
-    /** Exports from `<script context="module">` block */
-    moduleExports: ComponentProp[];
-    /** Slots available in the component template */
-    slots: ComponentSlot[];
-    /** Events that the component can dispatch or forward (serialized for JSON/API output) */
-    events: SerializedComponentEvent[];
-    /** Custom type definitions from JSDoc `@typedef` tags */
-    typedefs: TypeDef[];
-    /** Generic type parameters (e.g., `[name: "T", type: "string"]`) or null */
-    generics: null | ComponentGenerics;
-    /** Rest props configuration (which elements/components accept rest props) */
-    rest_props: RestProps;
-    /** Interface extension from JSDoc `@extends` tag */
-    extends?: Extends;
-    /** Component-level description from `@component` HTML comment */
-    componentComment?: string;
-    /** Source range for the `@component` HTML comment, when available */
-    componentCommentSource?: SourceRange;
-    /** Contexts created with `setContext` in the component */
-    contexts?: ComponentContext[];
-    /** Custom-element tag name from `<svelte:options customElement="x-foo" />` (or the object form's `tag`), when present */
-    customElementTag?: string;
-    /**
-     * Type guesses from this parse (unknown props, `any` contexts, orphan `@event` tags).
-     * Set on every {@link ComponentParser.parseSvelteComponent} call.
-     */
-    diagnostics?: SveldDiagnostic[];
-    /** Internal writer-only TypeScript metadata. Not serialized to JSON. */
-    [PARSED_COMPONENT_TYPE_SCRIPT_METADATA]?: ParsedComponentTypeScriptMetadata;
-}
-export default class ComponentParser {
-    /**
-     * All per-parse mutable state (props, slots, events, scopes, source, etc.).
-     * See {@link ParserContext} for field-by-field documentation. Replaced
-     * wholesale by `cleanup()` between parses.
-     */
-    private ctx;
-    private static mapToArray;
-    private static getStaticAttributeValue;
-    resolveScriptLanguage(parsed: {
-        instance?: ModernScriptNode;
-        module?: ModernScriptNode;
-    }): ScriptLanguage | undefined;
-    /**
-     * Reads the `generics` attribute off the instance script (Svelte only allows
-     * it there, and only alongside `lang="ts"`). Returns the raw value for later
-     * precedence resolution against `@generics`/`@template` JSDoc tags, or
-     * `undefined` if absent. Records a `syntax-skipped` diagnostic and returns
-     * `undefined` if the attribute is present without `lang="ts"`, since sveld
-     * can't safely guess how to parse it as plain JavaScript.
-     */
-    resolveScriptGenericsAttribute(parsed: {
-        instance?: ModernScriptNode;
-    }): {
-        value: string;
-        source?: SourceRange;
-    } | undefined;
-    private static assignValue;
-    private resolvePublicPropName;
-    trackPropLocalName(propName: string, localName?: string): void;
-    private getPropByLocalOrPublic;
-    getPropTypeByLocalOrPublic(name: string): string | undefined;
-    getExplicitPropType(name: string): string | undefined;
-    getPropertyName(node: Property["key"]): string | undefined;
-    /**
-     * Checks if a MemberExpression represents a well-known numeric constant.
-     *
-     * Identifies constants from the Number and Math objects that should be
-     * typed as `number` rather than their literal values.
-     *
-     * @param memberExpr - The AST node to check
-     * @returns True if the expression is a recognized numeric constant
-     *
-     * @example
-     * ```ts
-     * // Recognized constants:
-     * Number.POSITIVE_INFINITY  // true
-     * Number.MAX_VALUE          // true
-     * Math.PI                   // true
-     * Math.E                    // true
-     *
-     * // Not recognized:
-     * Custom.CONSTANT           // false
-     * Number.UNKNOWN            // false
-     * ```
-     */
-    isNumericConstant(memberExpr: unknown): boolean;
-    resolveTypeSource({ hasTypeScriptType, hasJSDocType, inferredType, finalType, }: {
-        hasTypeScriptType?: boolean;
-        hasJSDocType?: boolean;
-        inferredType?: string;
-        finalType?: string;
-    }): ComponentPropTypeSource;
-    /**
-     * Look up JSDoc on a local variable declaration by name.
-     */
-    resolveLocalVarJSDoc(name: string): {
-        type?: string;
-        params?: ComponentPropParam[];
-        returnType?: string;
-        description?: string;
-        binding?: ComponentPropBinding;
-        deprecated?: DeprecatedValue;
-        tags?: JsDocPassthroughTag[];
-    } | undefined;
-    /**
-     * Adds or merges a module export to the moduleExports map.
-     *
-     * Similar to {@link addProp}, but for exported values from the module script.
-     * If an export with the same name already exists, the new data is merged
-     * with the existing export.
-     *
-     * @param prop_name - The name of the exported value
-     * @param data - The export data to add or merge
-     *
-     * @example
-     * ```ts
-     * // For: export const API_URL = "https://api.example.com"
-     * addModuleExport("API_URL", {
-     *   name: "API_URL",
-     *   kind: "const",
-     *   type: "string",
-     *   value: '"https://api.example.com"'
-     * })
-     * ```
-     */
-    private addModuleExport;
-    /**
-     * Normalizes type strings by aliasing common patterns.
-     *
-     * Converts `*` to `any` (common JSDoc wildcard) and trims whitespace
-     * from type annotations.
-     *
-     * @param type - The type string to normalize
-     * @returns The normalized type string
-     *
-     * @example
-     * ```ts
-     * aliasType("*")        // Returns: "any"
-     * aliasType(" string ") // Returns: "string"
-     * aliasType("number")   // Returns: "number"
-     * ```
-     */
-    aliasType(type: string): string;
-    /**
-     * Builds a cache of variable type information from JSDoc comments.
-     *
-     * Scans the source code for variable declarations and extracts type information
-     * from preceding JSDoc comments. This cache is used to infer types for context
-     * properties and other variable references.
-     *
-     * @example
-     * ```ts
-     * // Source code:
-     * /**
-     *  * @type {string}
-     *  * The user's name
-     *  *\/
-     * const userName = "John";
-     *
-     * // Cache entry:
-     * // { "userName": { type: "string", description: "The user's name" } }
-     * ```
-     */
-    private buildVariableInfoCache;
-    /**
-     * Cache for compiled regex patterns for variable name matching.
-     *
-     * Stores three regex patterns (const, let, function) per variable name
-     * to avoid recreating them on each lookup. Improves performance when
-     * searching for the same variable multiple times.
-     */
-    private static readonly VAR_NAME_REGEX_CACHE;
-    /**
-     * Gets or creates cached regex patterns for matching variable declarations.
-     *
-     * Creates three regex patterns for matching const, let, and function declarations
-     * of a specific variable name. The patterns are cached to avoid recreating them
-     * for the same variable name.
-     *
-     * @param varName - The variable name to create regex patterns for
-     * @returns A tuple of three RegExp objects for const, let, and function patterns
-     *
-     * @example
-     * ```ts
-     * getVarNameRegexes("count")
-     * // Returns:
-     * // [
-     * //   /\bconst\s+count\s*=/,
-     * //   /\blet\s+count\s*=/,
-     * //   /\bfunction\s+count\s*\(/
-     * // ]
-     * ```
-     */
-    private static getVarNameRegexes;
-    /**
-     * Finds the type and description for a variable by searching for its JSDoc comment.
-     *
-     * First checks the cache built by {@link buildVariableInfoCache}. If not found,
-     * searches the source code directly for the variable declaration and its
-     * preceding JSDoc comment.
-     *
-     * @param varName - The variable name to look up
-     * @returns The type and description if found, null otherwise
-     *
-     * @example
-     * ```ts
-     * // Source:
-     * /**
-     *  * @type {number}
-     *  * The count value
-     *  *\/
-     * const count = 0;
-     *
-     * findVariableTypeAndDescription("count")
-     * // Returns: { type: "number", description: "The count value" }
-     * ```
-     */
-    findVariableTypeAndDescription(varName: string): {
-        type: string;
-        description?: string;
-    } | null;
-    /**
-     * Cleans up all parser state, resetting the instance for reuse.
-     *
-     * Clears all maps, caches, and resets all state variables to their initial
-     * values. Should be called before parsing a new component or when the
-     * parser instance needs to be reset.
-     *
-     * @example
-     * ```ts
-     * parser.parseSvelteComponent(source1, diagnostics1);
-     * parser.cleanup(); // Reset state
-     * parser.parseSvelteComponent(source2, diagnostics2); // Fresh parse
-     * ```
-     */
-    accumulateGeneric(name: string, constraint: string): void;
-    cleanup(): void;
-    /**
-     * Pre-compiled regex for matching script blocks in Svelte components.
-     *
-     * Matches `<script>` tags and their content, capturing the opening tag,
-     * script content, and closing tag. Global and case-insensitive flags
-     * allow matching multiple script blocks.
-     *
-     * @example
-     * ```ts
-     * // Matches:
-     * // "<script>const x = 1;</script>"
-     * // "<script lang='ts'>...</script>"
-     * ```
-     */
-    private static readonly SCRIPT_BLOCK_REGEX;
-    /**
-     * Pre-compiled regex for matching TypeScript directive comments.
-     *
-     * Matches TypeScript directive comments like ts-ignore, ts-expect-error,
-     * etc. Used to remove these directives from script blocks before JSDoc parsing.
-     *
-     * @example
-     * ```ts
-     * // Matches:
-     * // "// ts-ignore"
-     * // "// ts-expect-error: reason"
-     * // "// ts-nocheck"
-     * ```
-     */
-    private static readonly TS_DIRECTIVE_REGEX;
-    /**
-     * Strips TypeScript directive comments from script blocks only.
-     *
-     * Removes TypeScript directive comments (e.g., ts-ignore, ts-expect-error directives)
-     * from within `<script>` blocks to prevent them from interfering with JSDoc parsing.
-     * Directives outside script blocks are left untouched.
-     *
-     * @param source - The Svelte component source code
-     * @returns The source code with TypeScript directives removed from script blocks
-     *
-     * @example
-     * ```ts
-     * // Input (with TypeScript directive):
-     * <script>
-     *   const x: string = 123; // directive removed
-     * </script>
-     *
-     * // Output (directive stripped):
-     * <script>
-     *   const x: string = 123;
-     * </script>
-     * ```
-     */
-    private static stripTypeScriptDirectivesFromScripts;
-    /**
-     * Parses a Svelte component and extracts all component metadata.
-     *
-     * This is the main entry point that orchestrates the entire parsing process:
-     * 1. Cleans up previous state
-     * 2. Strips TypeScript directives that might interfere with JSDoc
-     * 3. Compiles the component to get the AST
-     * 4. Collects reactive variables
-     * 5. Builds variable type cache
-     * 6. Parses custom types from JSDoc comments
-     * 7. Walks the AST to extract props, slots, events, bindings, and contexts
-     * 8. Post-processes events to distinguish dispatched vs forwarded
-     * 9. Processes props with bindings and slots with prop references
-     * 10. Returns the complete parsed component structure
-     *
-     * @param source - The Svelte component source code
-     * @param diagnostics - Diagnostic information (module name and file path)
-     * @returns A ParsedComponent object containing all extracted metadata
-     *
-     * @example
-     * ```ts
-     * const parser = new ComponentParser();
-     * const result = parser.parseSvelteComponent(source, {
-     *   moduleName: "Button",
-     *   filePath: "./Button.svelte"
-     * });
-     * // Returns: { props: [...], slots: [...], events: [...], ... }
-     * ```
-     */
-    parseSvelteComponent(source: string, diagnostics: ComponentParserDiagnostics): ParsedComponent;
-}
-export {};