@zxyycom/vibe-check 0.0.1 → 0.0.3

package/types/package-checks/function-metrics/analyzer/extensions/lizardnd.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_ext/lizardnd.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the Check-private TypeScript port. Python's
+ * import-time FileInfoBuilder/FunctionInfo monkey patches are represented by
+ * typed private members on those host classes in analysis-context.ts and analysis-model.ts.
+ */
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { ExtensionArgumentRegistrar, LizardExtension as LizardExtensionProtocol } from "./protocol.ts";
+export declare const DEFAULT_ND_THRESHOLD = 7;
+/** Source lizardnd.py processor and its FUNCTION_INFO/set_args lifecycle. */
+export declare class LizardExtension implements LizardExtensionProtocol {
+    static readonly FUNCTION_INFO: {
+        max_nesting_depth: {
+            caption: string;
+            average_caption: string;
+        };
+    };
+    static set_args(parser: ExtensionArgumentRegistrar): void;
+    __call__(tokens: TokenStream, reader: AnalyzerReader, lDepth?: number): Generator<string>;
+}
+/** Source lizardnd.py's FileInfoBuilder patch target, supplied by analysis-context.ts. */
+export type NDFileInfoAddition = Pick<FileInfoBuilder, "add_nd_condition" | "reset_nd_complexity" | "add_hidden_bracket_condition" | "get_hidden_bracket" | "loop_bracket_status" | "get_loop_status" | "set_in_condition" | "get_in_condition" | "increment_condition_depth" | "decrement_condition_depth" | "get_condition_depth" | "reset_condition_tracking" | "set_logical_operator_added" | "get_logical_operator_added" | "set_prev_was_else" | "get_prev_was_else" | "clear_prev_was_else">;
+/** Source check_loop_brackets; TypeScript returns no value like Python. */
+export declare function check_loop_brackets(context: FileInfoBuilder, lDepth: number, hiddenBrackets: number): void;

package/types/package-checks/function-metrics/analyzer/extensions/protocol.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Sources: lizard_ext/extension_base.py and lizard_ext/lizard*.py extension
+ * contracts.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the analyzer-internal extension protocol; this is
+ * not exported through the product API as a plugin surface.
+ */
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import type { FileInformation } from "../analysis-model.ts";
+/** Metadata an extension contributes to FunctionInfo/report schemas. */
+export interface FunctionInfoDefinition {
+    readonly caption?: string;
+    readonly average_caption?: string;
+}
+/** The source-aligned FUNCTION_INFO mapping owned by one extension. */
+export type FunctionInfoDefinitions = Readonly<Record<string, FunctionInfoDefinition>>;
+/** Python `argparse.add_argument` keyword options used by translated bodies. */
+export interface ExtensionArgumentKeywordOptions {
+    readonly default?: number;
+    readonly dest?: string;
+    readonly help?: string;
+    /** The source `type=int` conversion contract. */
+    readonly type?: "int";
+}
+/** The minimal internal parser seam consumed by source set_args hooks. */
+export interface ExtensionArgumentRegistrar {
+    add_argument(...arguments_: readonly (string | ExtensionArgumentKeywordOptions)[]): void;
+}
+/** A source-aligned extension token processor. */
+export type ExtensionCall = (tokens: TokenStream, reader: AnalyzerReader) => TokenStream;
+/** A source-aligned extension cross-file processor. */
+export type ExtensionCrossFileProcess = {
+    bivarianceHack(fileInfos: Iterable<FileInformation> | undefined): Iterable<FileInformation> | undefined;
+}["bivarianceHack"];
+/** Preserve the distinction between an absent hook and a present hook returning undefined. */
+export type ExtensionCrossFileProcessOutcome = {
+    readonly hookPresent: false;
+} | {
+    readonly hookPresent: true;
+    readonly result: Iterable<FileInformation> | undefined;
+};
+/** A source-aligned extension result printer. */
+export type ExtensionPrintResult = () => void;
+/** A source-aligned extension argument registrar. */
+export type ExtensionSetArgs = (parser: ExtensionArgumentRegistrar) => void;
+/**
+ * The internal protocol shared by translated Lizard extension bodies.  Hooks
+ * are optional here because Python permits class-level static hooks that are
+ * resolved from an instantiated extension.
+ */
+export interface LizardExtension {
+    __call__?: ExtensionCall;
+    readonly ordering_index?: number;
+    readonly FUNCTION_INFO?: FunctionInfoDefinitions;
+    readonly silent_all_others?: boolean;
+    cross_file_process?: ExtensionCrossFileProcess;
+    print_result?: ExtensionPrintResult;
+    set_args?: ExtensionSetArgs;
+}
+/** Python resolves extension class attributes and static methods through instances. */
+export interface LizardExtensionClassMetadata {
+    readonly ordering_index?: number | undefined;
+    readonly FUNCTION_INFO?: FunctionInfoDefinitions | undefined;
+    readonly silent_all_others?: boolean | undefined;
+}
+/** A directly registered class is an opaque descriptor, not a constructor to invoke at load time. */
+export type LizardExtensionConstructor = LizardExtensionClassMetadata & {
+    readonly prototype: LizardExtension;
+};
+/** One non-string value retained verbatim by source-aligned registration. */
+export type RegisteredLizardExtension = LizardExtension | LizardExtensionConstructor;
+/** Any processor object on which upstream performs hasattr-style lifecycle lookup. */
+export type LizardExtensionDescriptor = object;
+/** Accepted internal extension registration inputs. */
+export type ExtensionInput = string | RegisteredLizardExtension;
+/** Ordinary hook names resolved through Python's instance attribute lookup. */
+export type ExtensionHookName = "cross_file_process" | "print_result" | "set_args";
+/** Resolve metadata with the same descriptor precedence used by extension hooks. */
+export declare function extensionMetadata(extension: LizardExtensionDescriptor): LizardExtensionClassMetadata;
+/** Resolve a cross-file hook through ordinary Python instance attribute lookup. */
+export declare function resolveExtensionHook(extension: LizardExtensionDescriptor, hookName: "cross_file_process"): ExtensionCrossFileProcess | undefined;
+/** Resolve a result hook through ordinary Python instance attribute lookup. */
+export declare function resolveExtensionHook(extension: LizardExtensionDescriptor, hookName: "print_result"): ExtensionPrintResult | undefined;
+/** Resolve an argument hook through ordinary Python instance attribute lookup. */
+export declare function resolveExtensionHook(extension: LizardExtensionDescriptor, hookName: "set_args"): ExtensionSetArgs | undefined;
+/** Resolve Python's special __call__ lookup from the extension type, ignoring its own dictionary. */
+export declare function resolveExtensionCall(extension: LizardExtensionDescriptor): ExtensionCall | undefined;
+/** Invoke a token hook and reject an extension that supplies neither source hook form. */
+export declare function invokeExtensionCall(extension: LizardExtensionDescriptor, tokens: TokenStream, reader: AnalyzerReader): TokenStream;
+/** Invoke an optional cross-file hook with source instance/static resolution. */
+export declare function invokeExtensionCrossFileProcess(extension: LizardExtensionDescriptor, fileInfos: Iterable<FileInformation> | undefined): Iterable<FileInformation> | undefined;
+/** Invoke a cross-file hook without collapsing a present undefined result into absence. */
+export declare function invokeExtensionCrossFileProcessOutcome(extension: LizardExtensionDescriptor, fileInfos: Iterable<FileInformation> | undefined): ExtensionCrossFileProcessOutcome;
+/** Invoke an optional result hook with source instance/static resolution. */
+export declare function invokeExtensionPrintResult(extension: LizardExtensionDescriptor): void;
+/** Invoke an optional argument hook with source instance/static resolution. */
+export declare function invokeExtensionSetArgs(extension: LizardExtensionDescriptor, parser: ExtensionArgumentRegistrar): void;

package/types/package-checks/function-metrics/analyzer/extensions/registry.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Sources: lizard.py:get_extensions and lizard_ext/lizard*.py module names.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: Apache-2.0 AND MIT
+ * Modified: translated to an analyzer-internal registration table. Deferred
+ * bodies fail explicitly rather than pretending to process source.
+ */
+import type { AnalyzerProcessor } from "../contracts.ts";
+import type { ExtensionInput, RegisteredLizardExtension } from "./protocol.ts";
+export type ExtensionBodyStatus = "deferred-extension-body" | "translated";
+/** One known upstream extension module whose body has not yet been translated. */
+export interface ExtensionRegistration {
+    readonly name: string;
+    readonly sourcePath: string;
+    readonly status: ExtensionBodyStatus;
+}
+/** Explicitly fail named loads until their source body is translated. */
+export declare class DeferredExtensionBodyError extends Error {
+    readonly extensionName: string;
+    readonly sourcePath: string;
+    constructor(registration: ExtensionRegistration);
+}
+/** All 19 upstream Lizard extension bodies in the current translation scope. */
+export declare const EXTENSION_REGISTRATIONS: readonly ExtensionRegistration[];
+/**
+ * Source-aligned get_extensions semantics: start with the five default
+ * processors, then resolve and insert each supplied extension by ordering_index.
+ */
+export declare function getExtensions(extensionInputs?: readonly ExtensionInput[]): AnalyzerProcessor[];
+/** Source `get_extensions` spelling for translated analyzer-internal callers. */
+export declare function get_extensions(extensionNames?: readonly ExtensionInput[]): AnalyzerProcessor[];
+/** Resolve an object/class directly, or report a known named body as deferred. */
+export declare function loadExtension(extensionInput: ExtensionInput): RegisteredLizardExtension;

package/types/package-checks/function-metrics/analyzer/pipeline.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Sources: lizard.py processor order, FileAnalyzer, map_files_to_analyzer,
+ * analyze_files, and extension lifecycle hooks.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: Apache-2.0
+ * Modified: in-memory execution pipeline isolated from state and reporting.
+ */
+import type { ExtensionArgumentRegistrar } from "./extensions/protocol.ts";
+import type { AnalyzerProcessor, AnalyzerReader, ReaderConstructor, TokenProcessor, TokenStream } from "./contracts.ts";
+import type { FileInformation } from "./analysis-model.ts";
+export declare function preprocessing(tokens: TokenStream, reader: AnalyzerReader): TokenStream;
+/** Upstream comment directive and generated-code handling. */
+export declare function commentCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string>;
+/** Upstream non-comment source-line counting. */
+export declare function lineCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string>;
+/** Upstream file and current-function token counting. */
+export declare function tokenCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string>;
+/** Upstream cyclomatic-condition counting. */
+export declare function conditionCounter(tokens: TokenStream, reader: AnalyzerReader): Generator<string>;
+/** The ordered default processor list from lizard.py:get_extensions. */
+export declare const DEFAULT_TOKEN_PROCESSORS: readonly TokenProcessor[];
+/**
+ * Drives the in-memory half of upstream FileAnalyzer.  Reader registry and
+ * filesystem decoding stay at the product integration boundary, so callers
+ * supply the concrete reader explicitly.
+ */
+export declare class FileAnalyzer {
+    readonly processors: readonly AnalyzerProcessor[];
+    constructor(processors?: readonly AnalyzerProcessor[]);
+    analyzeSourceCode<Reader extends AnalyzerReader>(filename: string, sourceCode: string, Reader: ReaderConstructor<Reader>): FileInformation;
+    /** Source `analyze_source_code` spelling retained for translated extension/core callers. */
+    analyze_source_code<Reader extends AnalyzerReader>(filename: string, sourceCode: string, Reader: ReaderConstructor<Reader>): FileInformation;
+}
+/** The source-aligned default analyzer has only the five core processors. */
+export declare const DEFAULT_FILE_ANALYZER: FileAnalyzer;
+/**
+ * One already-admitted source unit at the in-memory boundary. File discovery,
+ * decoding and reader selection stay outside this source-aligned core.
+ */
+export interface InMemoryAnalyzerFile {
+    readonly filename: string;
+    readonly sourceCode: string;
+    readonly reader: ReaderConstructor;
+}
+/**
+ * Source-aligned `map_files_to_analyzer` after the explicitly excluded file
+ * opening/multiprocessing entry surface has supplied in-memory source units.
+ */
+export declare function mapFilesToAnalyzer(files: Iterable<InMemoryAnalyzerFile>, analyzer: FileAnalyzer, workingThreads: number): Iterable<FileInformation>;
+/** Source `map_files_to_analyzer` spelling for the retained in-memory lifecycle. */
+export declare function map_files_to_analyzer(files: Iterable<InMemoryAnalyzerFile>, analyzer: FileAnalyzer, workingThreads: number): Iterable<FileInformation>;
+/**
+ * Source-aligned `analyze_files` lifecycle. `exts` intentionally uses Python
+ * truthiness: an omitted or empty list receives the five default processors.
+ */
+export declare function analyzeFiles(files: Iterable<InMemoryAnalyzerFile>, threads?: number, exts?: readonly AnalyzerProcessor[]): Iterable<FileInformation> | undefined;
+/** Source `analyze_files` spelling for translated internal callers. */
+export declare function analyze_files(files: Iterable<InMemoryAnalyzerFile>, threads?: number, exts?: readonly AnalyzerProcessor[]): Iterable<FileInformation> | undefined;
+/**
+ * Apply source registration-order cross-file passes. A present hook replaces
+ * the stream even when it returns undefined; only an absent hook is skipped.
+ */
+export declare function applyCrossFileProcessors(fileInfos: Iterable<FileInformation>, processors: readonly AnalyzerProcessor[]): Iterable<FileInformation> | undefined;
+/** Forward the internal parser seam to extensions in source registration order. */
+export declare function registerExtensionArguments(processors: readonly AnalyzerProcessor[], parser: ExtensionArgumentRegistrar): void;
+export declare function analyzeSourceCode<Reader extends AnalyzerReader>(filename: string, sourceCode: string, Reader: ReaderConstructor<Reader>, processors?: readonly AnalyzerProcessor[]): FileInformation;

package/types/package-checks/function-metrics/analyzer/port-facade.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Check-private Lizard-domain entry for suffix capability and supplied-source
+ * analysis. Product input admission, I/O, cancellation, and metric mapping
+ * remain outside the source-aligned port.
+ */
+/** A supplied in-memory source accepted by the Lizard-domain façade. */
+export interface LizardSourceInput {
+    readonly filename: string;
+    readonly sourceCode: string;
+}
+/** The Lizard function fields needed by the private Product adapter. */
+export interface LizardFunctionInfo {
+    readonly complex_tags: readonly LizardComplexityTag[];
+    readonly cyclomatic_complexity: number;
+    readonly end_line: number;
+    readonly filename: string;
+    readonly name: string;
+    readonly nloc: number;
+    readonly parameter_count: number;
+    readonly max_nesting_depth: number;
+    readonly start_line: number;
+}
+/** One source-ordered `[token, line]` contributor from lizardcomplextags.py. */
+export type LizardComplexityTag = readonly [token: string, line: number];
+/** In-memory Lizard analysis for one supplied source file. */
+export interface LizardSourceAnalysis {
+    readonly function_list: readonly LizardFunctionInfo[];
+}
+/** Returns the fixed source-order suffix capability of the translated Lizard readers. */
+export declare function lizardSourceExtensions(): readonly string[];
+/** Whether the translated Lizard registry can analyze this supplied filename. */
+export declare function isLizardSourceSupported(filename: string): boolean;
+/**
+ * Analyzes one caller-supplied source with the matching translated reader.
+ * Unsupported suffixes remain outside the Lizard analysis result instead of
+ * being coerced into an empty analysis.
+ */
+export declare function analyzeLizardSource(input: LizardSourceInput): LizardSourceAnalysis | undefined;

package/types/package-checks/function-metrics/analyzer/reader-registry.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/__init__.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to an analyzer-internal ordered reader registry. Product
+ * admission and fallback policy remain outside this module.
+ */
+import type { ReaderConstructor } from "./contracts.ts";
+/** A translated Lizard reader constructor with its source suffix matcher. */
+export interface RegisteredReader extends ReaderConstructor {
+    readonly ext: readonly string[];
+    matchFilename(filename: string): boolean;
+}
+/** Source-order equivalent of lizard_languages.languages(). */
+export declare function languages(): readonly RegisteredReader[];
+/** Source-order suffix lookup. Unknown suffixes deliberately remain unsupported here. */
+export declare function get_reader_for(filename: string): RegisteredReader | undefined;

package/types/package-checks/function-metrics/analyzer/readers/csharp.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/csharp.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining the source CLikeStates
+ * overrides for class declarations and expression-bodied members.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CLikeReader } from "../shared/clike.ts";
+import type { TokenFactory } from "../shared/code-reader.ts";
+/** C# reader with source-derived condition categories and parallel states. */
+export declare class CSharpReader extends CLikeReader {
+    static ext: readonly string[];
+    static languageNames: readonly string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string, _addition?: string, tokenFactory?: TokenFactory): Generator<string>;
+}

package/types/package-checks/function-metrics/analyzer/readers/erlang.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Sources: lizard_languages/erlang.py (MIT) and Pygments 2.18.0
+ * pygments/lexers/erlang.py (BSD-2-Clause).
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT AND BSD-2-Clause
+ * Modified: translated to the product-owned TypeScript analyzer with a
+ * reader-local Pygments-compatible lexer and no Python/Pygments runtime.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CodeReader } from "../shared/code-reader.ts";
+export declare class ErlangReader extends CodeReader {
+    static ext: string[];
+    static languageNames: string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string): Generator<string>;
+    get_comment_from_token(token: string): string | undefined;
+}

package/types/package-checks/function-metrics/analyzer/readers/fortran.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/fortran.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { TokenStream } from "../contracts.ts";
+import { CodeReader, type TokenFactory } from "../shared/code-reader.ts";
+/** Source mixin retained as a constructable class despite TypeScript's single inheritance. */
+export declare class FortranCommentsMixin {
+    static get_comment_from_token(token: string): string | undefined;
+    static getCommentFromToken(token: string): string | undefined;
+}
+export declare class FortranReader extends CodeReader {
+    static ext: string[];
+    static languageNames: string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    static readonly _blocks: readonly ["PROGRAM", "MODULE", "SUBMODULE", "SUBROUTINE", "FUNCTION", "TYPE", "INTERFACE", "BLOCK", "IF", "DO", "FORALL", "WHERE", "SELECT", "ASSOCIATE"];
+    macro_disabled: boolean;
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string, addition?: string, tokenFactory?: TokenFactory): Generator<string>;
+    preprocess(tokens: TokenStream): Generator<string>;
+    get_comment_from_token(token: string): string | undefined;
+}

package/types/package-checks/function-metrics/analyzer/readers/gdscript.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/gdscript.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript for the product-owned analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { PythonReader } from "./python.ts";
+export declare class GDScriptReader extends PythonReader {
+    static ext: readonly string[];
+    static languageNames: readonly string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    constructor(context: FileInfoBuilder);
+}

package/types/package-checks/function-metrics/analyzer/readers/go.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/go.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { AnalyzerReader, TokenStream } from "../contracts.ts";
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CodeReader, type TokenFactory } from "../shared/code-reader.ts";
+export declare class GoReader extends CodeReader {
+    static ext: string[];
+    static languageNames: string[];
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string, addition?: string, tokenFactory?: TokenFactory): Generator<string>;
+    get_comment_from_token(token: string): string | undefined;
+    __call__(tokens: TokenStream, reader: AnalyzerReader): Generator<string>;
+}

package/types/package-checks/function-metrics/analyzer/readers/java-body-states.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/java_body_states.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining Java method- and
+ * class-body nesting states.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { JavaStates } from "./java.ts";
+/**
+ * Binds source body-state subclasses after JavaStates exists, avoiding an ESM
+ * initialization cycle while retaining the source module's class boundaries.
+ */
+export declare function createJavaBodyStates(JavaStatesBase: typeof JavaStates, javaBraceCount: Readonly<Record<string, number>>): {
+    readonly JavaClassBodyStates: new (className: string | undefined, isRecord: boolean, context: FileInfoBuilder) => JavaStates;
+    readonly JavaFunctionBodyStates: new (context: FileInfoBuilder, exitWithBraceDepth?: boolean) => JavaStates;
+};

package/types/package-checks/function-metrics/analyzer/readers/java.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/java.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining Java's source-derived
+ * C-like state overrides, record handling and nested class lifecycle.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CLikeReader, CLikeStates } from "../shared/clike.ts";
+export declare const JAVA_BRACE_COUNT: Readonly<Record<string, number>>;
+/** Java reader with source-specific declaration and nested-class states. */
+export declare class JavaReader extends CLikeReader {
+    static ext: readonly string[];
+    static languageNames: readonly string[];
+    constructor(context: FileInfoBuilder);
+}
+/** Direct translation of lizard_languages.java.JavaStates. */
+export declare class JavaStates extends CLikeStates {
+    protected class_name: string | undefined;
+    protected is_record: boolean;
+    protected in_record_constructor: boolean;
+    protected in_method_body: boolean;
+    protected handling_dot_class: boolean;
+    protected handling_method_ref: boolean;
+    protected _java_after_unqualified_annotation: boolean;
+    protected _new_generic_depth: number;
+    protected _consume_java_expression_tokens(token: string): boolean;
+    protected _state_old_c_params(token: string): void;
+    protected _state_imp(token: string): void;
+    try_new_function(name: string): void;
+    protected _try_start_a_class(token: string, afterUnqualifiedAnnotation?: boolean): boolean;
+    _state_global(token: string): void;
+    protected readonly _state_decorator: (_token: string) => void;
+    protected readonly _state_annotation_arguments: (token: string) => void;
+    protected readonly _state_post_decorator: (token: string) => void;
+    private readonly _state_class_declaration;
+    private readonly _state_record_parameters;
+    private readonly _state_record_compact_constructor;
+    private readonly _state_record_constructor_body;
+    protected readonly _state_new: (_token: string) => void;
+    protected readonly _state_new_parameters: (token: string) => void;
+    private readonly ignoreJavaToken;
+}

package/types/package-checks/function-metrics/analyzer/readers/javascript.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/javascript.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { TypeScriptReader } from "./typescript.ts";
+export declare class JavaScriptReader extends TypeScriptReader {
+    static ext: string[];
+    static languageNames: string[];
+    constructor(context: FileInfoBuilder);
+}

package/types/package-checks/function-metrics/analyzer/readers/kotlin.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/kotlin.py and lizard_languages/swift.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { TokenStream } from "../contracts.ts";
+import { CodeReader, type TokenFactory } from "../shared/code-reader.ts";
+export declare class KotlinReader extends CodeReader {
+    static ext: string[];
+    static languageNames: string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    private readonly replaceLabel;
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string, addition?: string, tokenFactory?: TokenFactory): Generator<string>;
+    preprocess(tokens: TokenStream): Generator<string>;
+    get_comment_from_token(token: string): string | undefined;
+}

package/types/package-checks/function-metrics/analyzer/readers/lua.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/lua.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript for the product-owned analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { RubylikeReader } from "../shared/rubylike.ts";
+export declare class LuaReader extends RubylikeReader {
+    static ext: readonly string[];
+    static languageNames: readonly string[];
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string): Generator<string>;
+    get_comment_from_token(token: string): string | undefined;
+}

package/types/package-checks/function-metrics/analyzer/readers/objc.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/objc.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript while retaining Objective-C's CLikeStates
+ * declaration override, selector lifecycle and typedef suppression.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CLikeReader } from "../shared/clike.ts";
+/** Objective-C reader with source-compatible C-like and selector state fan-out. */
+export declare class ObjCReader extends CLikeReader {
+    static ext: readonly string[];
+    static languageNames: readonly string[];
+    constructor(context: FileInfoBuilder);
+    fake_and_useless(): void;
+    useless_and_fake(): void;
+}

package/types/package-checks/function-metrics/analyzer/readers/perl.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/perl.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to TypeScript for the product-owned analyzer.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import type { TokenStream } from "../contracts.ts";
+import { CodeReader } from "../shared/code-reader.ts";
+/** Source mixin retained even though PerlReader composes ScriptLanguageMixIn instead. */
+export declare class PerlCommentsMixin {
+    static get_comment_from_token(token: string): string | undefined;
+    static getCommentFromToken(token: string): string | undefined;
+}
+export declare class PerlReader extends CodeReader {
+    static ext: readonly string[];
+    static languageNames: readonly string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    constructor(context: FileInfoBuilder);
+    _state(token: string): boolean | void;
+    preprocess(tokens: TokenStream): Generator<string>;
+    static generateTokens(sourceCode: string): Generator<string>;
+    get_comment_from_token(token: string): string | undefined;
+}

package/types/package-checks/function-metrics/analyzer/readers/php-states.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/php_states.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer while
+ * retaining the source PHP function/class/match state machine.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CodeStateMachine } from "../shared/code-reader.ts";
+export declare class PHPLanguageStates extends CodeStateMachine {
+    private function_name;
+    private short_function_name;
+    private class_name;
+    private trait_name;
+    private in_class;
+    private in_trait;
+    private bracket_level;
+    private brace_level;
+    private started_function;
+    private last_tokens;
+    private is_function_declaration;
+    private readonly assignments;
+    private in_match;
+    private match_case_count;
+    constructor(context: FileInfoBuilder);
+    _state_global(token: string): void;
+    private readonly _state_use;
+    private readonly _trait_declaration;
+    private readonly _class_declaration;
+    private readonly _function_name;
+    private readonly _function_args;
+    private readonly _function_args_continue;
+    private readonly _function_return_type_or_body;
+    private readonly _function_body_or_return_type;
+    private readonly _function_body;
+    private readonly _condition_expected;
+    private readonly _condition_continue;
+    private readonly _match_expression;
+    private readonly _match_expression_continue;
+}

package/types/package-checks/function-metrics/analyzer/readers/php.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Derived from terryyin/lizard 1.24.0.
+ * Source: lizard_languages/php.py.
+ * Upstream revision: 308b1c3efd8c1c69bcc3eb82deeaec64fd3662ec.
+ * SPDX-License-Identifier: MIT
+ * Modified: translated to the product-owned TypeScript analyzer while
+ * retaining the source reader's PHP block tokenizer and state transitions.
+ */
+import type { FileInfoBuilder } from "../analysis-context.ts";
+import { CodeReader, type TokenFactory } from "../shared/code-reader.ts";
+/** PHP reader with the source module's code-block-only tokenizer boundary. */
+export declare class PHPReader extends CodeReader {
+    static ext: string[];
+    static languageNames: string[];
+    static controlFlowKeywords: Set<string>;
+    static logicalOperators: Set<string>;
+    static caseKeywords: Set<string>;
+    static ternaryOperators: Set<string>;
+    constructor(context: FileInfoBuilder);
+    static generateTokens(sourceCode: string, addition?: string, tokenFactory?: TokenFactory): Generator<string>;
+    get_comment_from_token(token: string): string | undefined;
+}