diagnostics.ts

Diagnostic collection for source analysis.

Structured error/warning collection during TypeScript and Svelte analysis.

Error Handling Contract

The pipeline accumulates failures into the diagnostics array and keeps going — analysis continues, declarations/members reach the output with partial: true when extraction failed mid-flight, and the caller decides how to react. Producers include type resolution failures, individual member/prop extraction failures, svelte2tsx transform failures, source-map construction failures, import lex / resolver failures, and duplicate declarations.

A few conditions still throw from the public entry points. These are configuration and environment errors, not per-file failures: invalid or contradictory options (see the @throws on createSourceOptions and discoverSourceFiles), a missing or unloadable tsconfig.json (including an unresolved extends, see loadTsconfig), Svelte <5, and failed strict 'exports' discovery. onDuplicates: 'throw' also throws, by request. Wrap the top-level call to handle these.

Usage Pattern

const {modules, diagnostics} = await analyze({sourceFiles, sourceOptions}); if (hasErrors(diagnostics)) { for (const err of errorsOf(diagnostics)) { console.error(formatDiagnostic(err)); } } for (const warning of warningsOf(diagnostics)) { console.warn(formatDiagnostic(warning)); }

Schema-Validated Plain Data

AnalyzeResultJson.diagnostics is Array<Diagnostic> — no wrapper object, no methods, no private fields. Round-trip-safe through JSON.stringify / parseDiagnostics and symmetric with AnalyzeResultJson.modules (also schema-validated). The full envelope is itself a fuz_schema schema (AnalyzeResultJson in analyze-core.ts) with both fields defaulting to [], so the whole {modules, diagnostics} shape round-trips through JSON.stringify(result, compactReplacer) / parseAnalyzeResult even when one or both arrays are empty (the wire form becomes {} and parsing restores the defaults). Use the free helpers hasErrors, errorsOf, byKind for queries; mutate the array with native Array.push.

File Path Contract

Diagnostic.file is always project-root-relative — no leading slash, no ./ prefix. analyze / analyzeFromFiles and the session (setFile/setFiles at ingest, query at analysis) normalize paths from all sources (extraction, discovery, dependency resolution) before returning. Consumers that need an absolute path can rejoin with projectRoot — a file outside the root takes the ../ form, so the rejoin holds for it too.

It names a *file*, not a module: ModuleJson.path is relative to sourceRoot, so file is not a lookup key into modules.

view source

Declarations
#

58 declarations

AliasLostDiagnostic
#

diagnostics.ts view source

value + type

AliasLostDiagnostic import {AliasLostDiagnostic} from 'svelte-docinfo/diagnostics.js';

An exported type alias loses its name at use sites.

The alias's right-hand side (an indexed access or conditional — z.infer<typeof S>, valibot's InferOutput) resolves to a pre-existing interned type that TypeScript never retroactively stamps an alias symbol on, so unannotated positions document the expansion instead of the name. Fires only where nothing self-heals: a loss the alias registry recovers (typeInfo emits {kind: 'reference', name} at use sites) is suppressed, as are literal-only unions (z.enum outputs) and brand-like intersections (.brand()) — readable degradations with no author-side fix worth demanding. @nodocs on the declaration suppresses. The author-side escape for a flagged alias is a nominal symbol, e.g. interface Foo extends z.infer<typeof S> {} where applicable, whose members are the inferred properties (the interface's computed heritage).

Always warning, query-time category (recomputed each query()).

inheritance

extends: s.SchemaStrictObjectOutput< typeof AliasLostDiagnosticEntries >

kind

type "alias_lost"

aliasName

Name of the alias whose right-hand side resolves to a nameless type.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

AliasLostDiagnosticInput
#

diagnostics.ts view source

AliasLostDiagnosticInput import type {AliasLostDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input AliasLostDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof AliasLostDiagnosticEntries >

kind

type "alias_lost"

aliasName

Name of the alias whose right-hand side resolves to a nameless type.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

byKind
#

diagnostics.ts view source

also exported from index.ts

<K extends DiagnosticKind>(diagnostics: Diagnostic[], kind: K): (Extract<TypeExtractionDiagnostic, { kind: K; }> | Extract<SignatureAnalysisDiagnostic, { ...; }> | ... 21 more ... | Extract<...>)[] import {byKind} from 'svelte-docinfo/diagnostics.js';

Get diagnostics of a specific kind, narrowed to the matching variant.

diagnostics

type Diagnostic[]

kind

type K

returns

((Extract<TypeExtractionDiagnostic, { kind: K; }>) | (Extract<SignatureAnalysisDiagnostic, { kind: K; }>) | (Extract<ClassMemberDiagnostic, { kind: K; }>) | (Extract<SveltePropDiagnostic, { kind: K; }>) | (Extract<ModuleSkippedDiagnostic, { kind: K; }>) | (Extract<ModuleUnreadableDiagnostic, { kind: K; }>) | (Extract<ImportParseDiagnostic, { kind: K; }>) | (Extract<DuplicateCommentDiagnostic, { kind: K; }>) | (Extract<ComponentCommentMismatchDiagnostic, { kind: K; }>) | (Extract<MisplacedTagDiagnostic, { kind: K; }>) | (Extract<ImplementationDocHiddenDiagnostic, { kind: K; }>) | (Extract<UnknownParamDiagnostic, { kind: K; }>) | (Extract<UnknownCsspropDiagnostic, { kind: K; }>) | (Extract<MalformedTagDiagnostic, { kind: K; }>) | (Extract<DuplicateTagDiagnostic, { kind: K; }>) | (Extract<CsspropDefaultMismatchDiagnostic, { kind: K; }>) | (Extract<SourceMapFailedDiagnostic, { kind: K; }>) | (Extract<DuplicateDeclarationDiagnostic, { kind: K; }>) | (Extract<TransformFailedDiagnostic, { kind: K; }>) | (Extract<ResolverFailedDiagnostic, { kind: K; }>) | (Extract<AliasLostDiagnostic, { kind: K; }>) | (Extract<CommonjsUnsupportedDiagnostic, { kind: K; }>) | (Extract<CssParseFailedDiagnostic, { kind: K; }>) | (Extract<CssLangUnsupportedDiagnostic, { kind: K; }>))[]

generics

byKind<K extends DiagnosticKind>
K
constraint DiagnosticKind

ClassMemberDiagnostic
#

diagnostics.ts view source

value + type

ClassMemberDiagnostic import {ClassMemberDiagnostic} from 'svelte-docinfo/diagnostics.js';

Class member analysis failed.

inheritance

extends: s.SchemaStrictObjectOutput< typeof ClassMemberDiagnosticEntries >

kind

type "class_member_failed"

className

Name of the class.

type string

memberName

Name of the member that failed.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ClassMemberDiagnosticInput
#

diagnostics.ts view source

ClassMemberDiagnosticInput import type {ClassMemberDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input ClassMemberDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof ClassMemberDiagnosticEntries >

kind

type "class_member_failed"

className

Name of the class.

type string

memberName

Name of the member that failed.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

CommonjsUnsupportedDiagnostic
#

diagnostics.ts view source

value + type

CommonjsUnsupportedDiagnostic import {CommonjsUnsupportedDiagnostic} from 'svelte-docinfo/diagnostics.js';

A JS module exports through CommonJS (module.exports = …, exports.x = …), which isn't modeled.

The module still emits, with no declarations; line/column point at the first export assignment. Fires only when the checker gives the file no module symbol (no ES syntax under bundler/esnext) and a top-level statement assigns to module.exports or exports. A file with ES syntax is an ES module, its assignments ordinary code; under node16/nodenext or moduleDetection: 'force' the checker binds the CommonJS exports itself, and its named exports (exports.x, module.exports = {a, b}) document, with no warning; a module.exports = of a non-object documents nothing. A script with no exports either way (require calls alone), or one whose own top-level declaration binds exports or module, doesn't fire.

Always warning, query-time category (recomputed each query()).

inheritance

extends: s.SchemaStrictObjectOutput< typeof CommonjsUnsupportedDiagnosticEntries >

kind

type "commonjs_unsupported"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

CommonjsUnsupportedDiagnosticInput
#

diagnostics.ts view source

CommonjsUnsupportedDiagnosticInput import type {CommonjsUnsupportedDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input CommonjsUnsupportedDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof CommonjsUnsupportedDiagnosticEntries >

kind

type "commonjs_unsupported"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ComponentCommentMismatchDiagnostic
#

diagnostics.ts view source

value + type

ComponentCommentMismatchDiagnostic import {ComponentCommentMismatchDiagnostic} from 'svelte-docinfo/diagnostics.js';

svelte2tsx, and so editor hover, documents a component with a different HTML comment than the analyzer does.

The analyzer reads the first HTML comment with a line starting @component; svelte2tsx takes the last one containing @component anywhere, so a second component comment or a mid-prose mention (a backticked @component in a module comment) takes its slot. line is the comment svelte2tsx picks; reword its @component to agree. Not emitted when in-script JSDoc supplies the component's doc.

inheritance

extends: s.SchemaStrictObjectOutput< typeof ComponentCommentMismatchDiagnosticEntries >

kind

type "component_comment_mismatch"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ComponentCommentMismatchDiagnosticInput
#

diagnostics.ts view source

ComponentCommentMismatchDiagnosticInput import type {ComponentCommentMismatchDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input ComponentCommentMismatchDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof ComponentCommentMismatchDiagnosticEntries >

kind

type "component_comment_mismatch"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

CssLangUnsupportedDiagnostic
#

diagnostics.ts view source

value + type

CssLangUnsupportedDiagnostic import {CssLangUnsupportedDiagnostic} from 'svelte-docinfo/diagnostics.js';

A component's <style> names a preprocessor language (lang="scss", type="text/postcss"), which isn't read: its styling API (ComponentDeclarationJson.cssCustomProperties) is left empty. Only lang="css" and type="text/css" read as CSS. line/column point at the style tag.

Always warning, query-time category (reported each query() from the reading cached at transform).

inheritance

extends: s.SchemaStrictObjectOutput< typeof CssLangUnsupportedDiagnosticEntries >

kind

type "css_lang_unsupported"

lang

The style tag's lang (or type) value, as written (scss, text/postcss).

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

CssLangUnsupportedDiagnosticInput
#

diagnostics.ts view source

CssLangUnsupportedDiagnosticInput import type {CssLangUnsupportedDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input CssLangUnsupportedDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof CssLangUnsupportedDiagnosticEntries >

kind

type "css_lang_unsupported"

lang

The style tag's lang (or type) value, as written (scss, text/postcss).

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

CssParseFailedDiagnostic
#

diagnostics.ts view source

value + type

CssParseFailedDiagnostic import {CssParseFailedDiagnostic} from 'svelte-docinfo/diagnostics.js';

Svelte's parser rejected a component that has a <style>, so its styling API (ComponentDeclarationJson.cssCustomProperties) isn't read.

Usually malformed CSS; also any template error under a Svelte that predates loose parsing (5.13). The component still emits, without cssCustomProperties. line/column are the parser's, in the original .svelte source.

Always warning, query-time category (reported each query() from the reading cached at transform).

inheritance

extends: s.SchemaStrictObjectOutput< typeof CssParseFailedDiagnosticEntries >

kind

type "css_parse_failed"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

CssParseFailedDiagnosticInput
#

diagnostics.ts view source

CssParseFailedDiagnosticInput import type {CssParseFailedDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input CssParseFailedDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof CssParseFailedDiagnosticEntries >

kind

type "css_parse_failed"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

CsspropDefaultMismatchDiagnostic
#

diagnostics.ts view source

value + type

CsspropDefaultMismatchDiagnostic import {CsspropDefaultMismatchDiagnostic} from 'svelte-docinfo/diagnostics.js';

A component's @cssprop tag documents a default ([--a=1px]) that differs from the fallback its style gives the property (ComponentCssPropertyJson.fallback: the first var() read's fallback, or an @property rule's initial-value), compared as text with whitespace runs collapsed.

Usually a stale tag after the style changed, or a documented value written in a form the style doesn't use (red against #f00): nothing evaluates CSS, so an equivalent spelling warns too. The entry keeps both, default and fallback, and line is the read's (the entry's sourceLine). Not emitted when the style wasn't read.

Always warning, query-time category.

inheritance

extends: s.SchemaStrictObjectOutput< typeof CsspropDefaultMismatchDiagnosticEntries >

kind

type "cssprop_default_mismatch"

propertyName

The custom property the @cssprop tag names, -- included.

type string

componentName

Name of the component.

type string

default

The tag's bracketed default, verbatim.

type string

fallback

The style's fallback for the property, verbatim (ComponentCssPropertyJson.fallback).

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

CsspropDefaultMismatchDiagnosticInput
#

diagnostics.ts view source

CsspropDefaultMismatchDiagnosticInput import type {CsspropDefaultMismatchDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input CsspropDefaultMismatchDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof CsspropDefaultMismatchDiagnosticEntries >

kind

type "cssprop_default_mismatch"

propertyName

The custom property the @cssprop tag names, -- included.

type string

componentName

Name of the component.

type string

default

The tag's bracketed default, verbatim.

type string

fallback

The style's fallback for the property, verbatim (ComponentCssPropertyJson.fallback).

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

Diagnostic
#

diagnostics.ts view source

value + type

also exported from index.ts

Diagnostic

type TypeExtractionDiagnostic | SignatureAnalysisDiagnostic | ClassMemberDiagnostic | SveltePropDiagnostic | ModuleSkippedDiagnostic | ModuleUnreadableDiagnostic | ImportParseDiagnostic | DuplicateCommentDiagnostic | ComponentCommentMismatchDiagnostic | MisplacedTagDiagnostic | ImplementationDocHiddenDiagnostic | UnknownParamDiagnostic | UnknownCsspropDiagnostic | MalformedTagDiagnostic | DuplicateTagDiagnostic | CsspropDefaultMismatchDiagnostic | SourceMapFailedDiagnostic | DuplicateDeclarationDiagnostic | TransformFailedDiagnostic | ResolverFailedDiagnostic | AliasLostDiagnostic | CommonjsUnsupportedDiagnostic | CssParseFailedDiagnostic | CssLangUnsupportedDiagnostic

import {Diagnostic} from 'svelte-docinfo/diagnostics.js';

Discriminated union of all diagnostic variants. Ingest-time kinds: transform_failed, source_map_failed, import_parse_failed, and resolver_failed; discovery-time: module_unreadable; every other kind is query-time.

DiagnosticKind
#

diagnostics.ts view source

value + type

also exported from index.ts

"type_extraction_failed" | "signature_analysis_failed" | "class_member_failed" | "svelte_prop_failed" | "module_skipped" | "module_unreadable" | "import_parse_failed" | ... 16 more ... | "css_lang_unsupported"

type "type_extraction_failed" | "signature_analysis_failed" | "class_member_failed" | "svelte_prop_failed" | "module_skipped" | "module_unreadable" | "import_parse_failed" | "duplicate_comment" | "component_comment_mismatch" | "misplaced_tag" | "implementation_doc_hidden" | "unknown_param" | "unknown_cssprop" | "malformed_tag" | "duplicate_tag" | "cssprop_default_mismatch" | "source_map_failed" | "duplicate_declaration" | "transform_failed" | "resolver_failed" | "alias_lost" | "commonjs_unsupported" | "css_parse_failed" | "css_lang_unsupported"

import {DiagnosticKind} from 'svelte-docinfo/diagnostics.js';

Discriminant for Diagnostic variant types.

Severity is a stable per-kind property: transform_failed and module_unreadable are always error, every other kind always warning.

DiagnosticSeverity
#

diagnostics.ts view source

value + type

also exported from index.ts

"error" | "warning"

type "error" | "warning"

import {DiagnosticSeverity} from 'svelte-docinfo/diagnostics.js';

Diagnostic severity levels.

  • 'error' — analysis failed, declaration may be incomplete or missing data
  • 'warning' — partial success, something seems off but analysis continued

DuplicateCommentDiagnostic
#

diagnostics.ts view source

value + type

DuplicateCommentDiagnostic import {DuplicateCommentDiagnostic} from 'svelte-docinfo/diagnostics.js';

Duplicate comment sources detected (e.g., both HTML and JSDoc @module, or both HTML @component and JSDoc for component docComment).

inheritance

extends: s.SchemaStrictObjectOutput< typeof DuplicateCommentDiagnosticEntries >

kind

type "duplicate_comment"

commentType

Which comment type is duplicated.

type "module_comment" | "doc_comment"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

DuplicateCommentDiagnosticInput
#

diagnostics.ts view source

DuplicateCommentDiagnosticInput import type {DuplicateCommentDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input DuplicateCommentDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof DuplicateCommentDiagnosticEntries >

kind

type "duplicate_comment"

commentType

Which comment type is duplicated.

type "module_comment" | "doc_comment"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

DuplicateDeclarationDiagnostic
#

diagnostics.ts view source

value + type

DuplicateDeclarationDiagnostic import {DuplicateDeclarationDiagnostic} from 'svelte-docinfo/diagnostics.js';

A declaration name appears in more than one module.

Opt-in: emitted only when onDuplicates is set, for packages that keep a flat export namespace (see OnDuplicates). Emitted at warning severity so the analysis result remains usable; onDuplicates: 'throw' makes it fatal. The default slot (name === 'default') is excluded — every module owns its own.

inheritance

extends: s.SchemaStrictObjectOutput< typeof DuplicateDeclarationDiagnosticEntries >

kind

type "duplicate_declaration"

declarationName

The duplicated declaration name.

type string

modules

Module paths where the name was defined (>= 2).

ModuleJson.path values — relative to sourceRoot, so a different base than the record's file (project-root-relative, like every diagnostic). The two disagree textually whenever sourceRoot is non-empty; each names what it says it names, a module vs. a file.

type string[]

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

DuplicateDeclarationDiagnosticInput
#

diagnostics.ts view source

DuplicateDeclarationDiagnosticInput import type {DuplicateDeclarationDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input DuplicateDeclarationDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof DuplicateDeclarationDiagnosticEntries >

kind

type "duplicate_declaration"

declarationName

The duplicated declaration name.

type string

modules

Module paths where the name was defined (>= 2).

ModuleJson.path values — relative to sourceRoot, so a different base than the record's file (project-root-relative, like every diagnostic). The two disagree textually whenever sourceRoot is non-empty; each names what it says it names, a module vs. a file.

type string[]

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

DuplicateTagDiagnostic
#

diagnostics.ts view source

value + type

DuplicateTagDiagnostic import {DuplicateTagDiagnostic} from 'svelte-docinfo/diagnostics.js';

A JSDoc tag repeats a key an earlier tag of the same name in the comment already set, so it documents nothing.

Today only @cssprop (@cssproperty): a second tag naming the same custom property. Emitted on a Svelte component's doc comment, at the later tag's line; the first tag wins. On any other declaration the tags warn misplaced_tag instead.

Always warning, query-time category.

inheritance

extends: s.SchemaStrictObjectOutput< typeof DuplicateTagDiagnosticEntries >

kind

type "duplicate_tag"

tagName

The tag name without the @ prefix; a synonym reports its canonical name.

type "cssprop"

declarationName

Name of the declaration whose doc comment carries the tags.

type string

key

The repeated key: the custom property's name for @cssprop, -- included.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

DuplicateTagDiagnosticInput
#

diagnostics.ts view source

DuplicateTagDiagnosticInput import type {DuplicateTagDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input DuplicateTagDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof DuplicateTagDiagnosticEntries >

kind

type "duplicate_tag"

tagName

The tag name without the @ prefix; a synonym reports its canonical name.

type "cssprop"

declarationName

Name of the declaration whose doc comment carries the tags.

type string

key

The repeated key: the custom property's name for @cssprop, -- included.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

errorsOf
#

formatDiagnostic
#

diagnostics.ts view source

also exported from index.ts

(diagnostic: Diagnostic): string import {formatDiagnostic} from 'svelte-docinfo/diagnostics.js';

Format a diagnostic for display.

Assumes diagnostic.file is project-root-relative (the contract enforced by analyze / analyzeFromFiles). The displayed path is prefixed with ./.

diagnostic

the diagnostic to format

returns

string

formatted string like './file.ts:10:5: error: message'

examples

for (const d of errorsOf(diagnostics)) { console.error(formatDiagnostic(d)); }

hasErrors
#

diagnostics.ts view source

also exported from index.ts

(diagnostics: Diagnostic[]): boolean import {hasErrors} from 'svelte-docinfo/diagnostics.js';

Check if any error-severity diagnostics were collected.

diagnostics

type Diagnostic[]

returns

boolean

hasWarnings
#

diagnostics.ts view source

also exported from index.ts

(diagnostics: Diagnostic[]): boolean import {hasWarnings} from 'svelte-docinfo/diagnostics.js';

Check if any warning-severity diagnostics were collected.

diagnostics

type Diagnostic[]

returns

boolean

ImplementationDocHiddenDiagnostic
#

diagnostics.ts view source

value + type

ImplementationDocHiddenDiagnostic import {ImplementationDocHiddenDiagnostic} from 'svelte-docinfo/diagnostics.js';

An overloaded function, method, or constructor documents its implementation, whose JSDoc is hidden.

Only overload signatures are public, so TypeScript's hover ignores the implementation's JSDoc, and so does the output: its prose and tags drop, an implementation @nodocs hides nothing, and the symbol's docs come from its first overload. Fires for a TS implementation (the bodied declaration after its overloads) and for a JS implementation's JSDoc blocks that host no @overload tag, when they carry doc content; a block of types alone (@param {string} a) doesn't fire. line/column point at the implementation. Move the docs to the first overload.

Always warning, query-time category (recomputed each query()).

inheritance

extends: s.SchemaStrictObjectOutput< typeof ImplementationDocHiddenDiagnosticEntries >

kind

type "implementation_doc_hidden"

functionName

Name of the overloaded function, method, or constructor.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ImplementationDocHiddenDiagnosticInput
#

diagnostics.ts view source

ImplementationDocHiddenDiagnosticInput import type {ImplementationDocHiddenDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input ImplementationDocHiddenDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof ImplementationDocHiddenDiagnosticEntries >

kind

type "implementation_doc_hidden"

functionName

Name of the overloaded function, method, or constructor.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ImportParseDiagnostic
#

diagnostics.ts view source

value + type

ImportParseDiagnostic import {ImportParseDiagnostic} from 'svelte-docinfo/diagnostics.js';

Import scanning threw during dependency resolution.

Not expected in practice: the parse in lexImports tolerates malformed source rather than rejecting it, so this guards an unexpected throw.

inheritance

extends: s.SchemaStrictObjectOutput< typeof ImportParseDiagnosticEntries >

kind

type "import_parse_failed"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ImportParseDiagnosticInput
#

diagnostics.ts view source

ImportParseDiagnosticInput import type {ImportParseDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input ImportParseDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof ImportParseDiagnosticEntries >

kind

type "import_parse_failed"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

MalformedTagDiagnostic
#

diagnostics.ts view source

value + type

MalformedTagDiagnostic import {MalformedTagDiagnostic} from 'svelte-docinfo/diagnostics.js';

A JSDoc tag whose text doesn't parse as the tag's form, so it documents nothing.

Today only @cssprop (@cssproperty): its text names no custom property (@cssprop card_width - …, a name without --; @cssprop --a: …; an unclosed {…} or […]; an empty tag). Emitted on a Svelte component's doc comment, at the tag's line; on any other declaration the tag warns misplaced_tag instead, whether or not it parses. The tag is dropped.

Always warning, query-time category.

inheritance

extends: s.SchemaStrictObjectOutput< typeof MalformedTagDiagnosticEntries >

kind

type "malformed_tag"

tagName

The tag name without the @ prefix; a synonym reports its canonical name.

type "cssprop"

declarationName

Name of the declaration whose doc comment carries the tag.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

MalformedTagDiagnosticInput
#

diagnostics.ts view source

MalformedTagDiagnosticInput import type {MalformedTagDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input MalformedTagDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof MalformedTagDiagnosticEntries >

kind

type "malformed_tag"

tagName

The tag name without the @ prefix; a synonym reports its canonical name.

type "cssprop"

declarationName

Name of the declaration whose doc comment carries the tag.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

MisplacedTagDiagnostic
#

diagnostics.ts view source

value + type

MisplacedTagDiagnostic import {MisplacedTagDiagnostic} from 'svelte-docinfo/diagnostics.js';

A JSDoc tag found somewhere it has no effect.

Two contexts emit this:

  • Non-primary overload signature — symbol-scope tags (@example, @deprecated, @internal, @since, @see, @throws, @mutates, @default, @nodocs) describe the function as a whole, not individual signatures. The primary signature's JSDoc feeds the parent declaration's symbol-level extraction; tags on non-primary overload signatures are silently dropped from output. This diagnostic surfaces them so authors can move them to the primary signature. @default and @nodocs are included even though overloads never carry a defaultValue or per-overload exclusion: their presence on a non-primary signature is always a misplacement.
  • Module comment — tags that only describe a declaration (@param, @returns, @mutates, @throws, @default, @nodocs, @cssprop) have no module-level meaning, so a @module comment's are dropped, one warning per tag name per comment. @nodocs applies to declarations and export statements; to omit a module from analysis, use exclude patterns instead. @param and @returns occur only here.
  • Non-component declaration — @cssprop (or @cssproperty, reported as 'cssprop') documents a Svelte component's CSS custom properties, so on any other exported declaration (a function, a <script module> export) it's dropped, one warning per declaration. Members, props, and parameters drop it silently.

inheritance

extends: s.SchemaStrictObjectOutput< typeof MisplacedTagDiagnosticEntries >

kind

type "misplaced_tag"

tagName

The tag name without the @ prefix (e.g., 'example', 'deprecated'). A synonym reports its canonical name: @return as 'returns', @defaultValue as 'default'.

type "since" | "throws" | "mutates" | "default" | "example" | "deprecated" | "internal" | "see" | "nodocs" | "param" | "returns" | "cssprop"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

functionName?

Name of the enclosing symbol: the function or method whose overload carries the misplaced tag, or the declaration carrying a @cssprop. Absent for module-comment misplacements (no enclosing symbol).

type string

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

MisplacedTagDiagnosticInput
#

diagnostics.ts view source

MisplacedTagDiagnosticInput import type {MisplacedTagDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input MisplacedTagDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof MisplacedTagDiagnosticEntries >

kind

type "misplaced_tag"

tagName

The tag name without the @ prefix (e.g., 'example', 'deprecated'). A synonym reports its canonical name: @return as 'returns', @defaultValue as 'default'.

type "since" | "throws" | "mutates" | "default" | "example" | "deprecated" | "internal" | "see" | "nodocs" | "param" | "returns" | "cssprop"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

functionName?

Name of the enclosing symbol: the function or method whose overload carries the misplaced tag, or the declaration carrying a @cssprop. Absent for module-comment misplacements (no enclosing symbol).

type string

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ModuleSkippedDiagnostic
#

diagnostics.ts view source

value + type

ModuleSkippedDiagnostic import {ModuleSkippedDiagnostic} from 'svelte-docinfo/diagnostics.js';

Module was skipped during the analysis pass.

Always warning severity — the rest of the analysis still runs and the module's absence in modules reflects the skip. Reasons:

  • not_in_program — the file wasn't in the ts.Program (race between session ingest and query, or virtual file missing for a .svelte)
  • no_analyzer — file extension didn't match any analyzer
  • requires_program — Svelte file reached the non-Svelte dispatcher (caller should use the session API instead of analyzeModule directly)

Discovery-time file-read failures are a separate kind: module_unreadable.

inheritance

extends: s.SchemaStrictObjectOutput< typeof ModuleSkippedDiagnosticEntries >

kind

type "module_skipped"

reason

Reason the module was skipped.

type "not_in_program" | "no_analyzer" | "requires_program"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ModuleSkippedDiagnosticInput
#

diagnostics.ts view source

ModuleSkippedDiagnosticInput import type {ModuleSkippedDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input ModuleSkippedDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof ModuleSkippedDiagnosticEntries >

kind

type "module_skipped"

reason

Reason the module was skipped.

type "not_in_program" | "no_analyzer" | "requires_program"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ModuleUnreadableDiagnostic
#

diagnostics.ts view source

value + type

ModuleUnreadableDiagnostic import {ModuleUnreadableDiagnostic} from 'svelte-docinfo/diagnostics.js';

File discovered via package.json exports exists but couldn't be read.

Always error severity — discovery-time, emitted by discoverFromExports when readFile fails (permission denied, FS error). Distinct from module_skipped so severity is a stable per-kind property and downstream consumers can route discovery failures separately from analysis-pass skips.

inheritance

extends: s.SchemaStrictObjectOutput< typeof ModuleUnreadableDiagnosticEntries >

kind

type "module_unreadable"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ModuleUnreadableDiagnosticInput
#

diagnostics.ts view source

ModuleUnreadableDiagnosticInput import type {ModuleUnreadableDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input ModuleUnreadableDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof ModuleUnreadableDiagnosticEntries >

kind

type "module_unreadable"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

parseDiagnostics
#

diagnostics.ts view source

also exported from index.ts

(value: unknown): Diagnostic[] import {parseDiagnostics} from 'svelte-docinfo/diagnostics.js';

Validate an array of diagnostics.

The stable way to validate diagnostics stored or sent on their own, independent of the schema library behind Diagnostic. For a whole analysis result use parseAnalyzeResult.

The result is value itself when it matches: no diagnostic has a default to fill in, so nothing is copied.

value

an array of diagnostics, typically from JSON.parse

type unknown

returns

Diagnostic[]

the validated diagnostics

throws

  • Error - when `value` doesn't match the schema; the message lists the reported issues, one per line, as `path: message` (`0.severity: expected …, received "warn"`), the value that failed in place of its type when it's a string, number, or boolean (an unknown key's never), the dot path omitted for an issue at the root, and ends with a line saying there may be more when it holds a hundred. The class is the schema library's (fuz_schema's `SchemaError`, the structured list on `issues`), so catch it as a plain `Error` unless you depend on fuz_schema

ResolverFailedDiagnostic
#

diagnostics.ts view source

value + type

ResolverFailedDiagnostic import {ResolverFailedDiagnostic} from 'svelte-docinfo/diagnostics.js';

Import resolver threw while resolving a specifier.

Distinguishes a buggy resolver from a legitimately unresolvable specifier: resolvers that return null for unknown specifiers stay silent (the normal "external package" case); resolvers that *throw* surface here so consumers can fix the resolver. Recoverable — the session treats the throw as null and continues, so analysis still runs but with a missing dependency edge. Durable on the entry until a later setFiles that adds paths resolves the specifier, which retires the diagnostic and adds the edge.

Emitted at ingest time by the session's resolve phase.

inheritance

extends: s.SchemaStrictObjectOutput< typeof ResolverFailedDiagnosticEntries >

kind

type "resolver_failed"

specifier

The import specifier the resolver failed on.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

ResolverFailedDiagnosticInput
#

diagnostics.ts view source

ResolverFailedDiagnosticInput import type {ResolverFailedDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input ResolverFailedDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof ResolverFailedDiagnosticEntries >

kind

type "resolver_failed"

specifier

The import specifier the resolver failed on.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

SignatureAnalysisDiagnostic
#

diagnostics.ts view source

value + type

SignatureAnalysisDiagnostic import {SignatureAnalysisDiagnostic} from 'svelte-docinfo/diagnostics.js';

Function/method signature analysis failed.

inheritance

extends: s.SchemaStrictObjectOutput< typeof SignatureAnalysisDiagnosticEntries >

kind

type "signature_analysis_failed"

functionName

Name of the function or method.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

SignatureAnalysisDiagnosticInput
#

diagnostics.ts view source

SignatureAnalysisDiagnosticInput import type {SignatureAnalysisDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input SignatureAnalysisDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof SignatureAnalysisDiagnosticEntries >

kind

type "signature_analysis_failed"

functionName

Name of the function or method.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

SourceMapFailedDiagnostic
#

diagnostics.ts view source

value + type

SourceMapFailedDiagnostic import {SourceMapFailedDiagnostic} from 'svelte-docinfo/diagnostics.js';

Source map parsing failed for a Svelte virtual file.

Analysis continues without position mapping: query-time diagnostics drop line/column rather than point into svelte2tsx-generated TS — those emitted against the virtual via remapVirtualDiagnosticPositions, svelte_prop_failed at its own emission site — while declaration sourceLines fall back to virtual positions. Rare; usually signals a malformed or incompatible svelte2tsx output.

Emitted at ingest time by transformSvelteSource (in svelte.ts); flows through setFile/setFiles ingest diagnostics rather than the analysis pass.

inheritance

extends: s.SchemaStrictObjectOutput< typeof SourceMapFailedDiagnosticEntries >

kind

type "source_map_failed"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

SourceMapFailedDiagnosticInput
#

diagnostics.ts view source

SourceMapFailedDiagnosticInput import type {SourceMapFailedDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input SourceMapFailedDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof SourceMapFailedDiagnosticEntries >

kind

type "source_map_failed"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

SveltePropDiagnostic
#

diagnostics.ts view source

value + type

SveltePropDiagnostic import {SveltePropDiagnostic} from 'svelte-docinfo/diagnostics.js';

Svelte prop type resolution failed.

Also emitted once per export let prop of a legacy component whose svelte2tsx output has no recognized props type: those props aren't extracted, and each failure carries its export's line.

file is the original .svelte path, so line/column are present only when the prop's declaration lives in the component's own virtual *and* maps back to the original source — an imported props type or a node svelte2tsx synthesized leaves the position absent rather than publishing a virtual line, the rule remapVirtualDiagnosticPositions applies to extractor diagnostics.

inheritance

extends: s.SchemaStrictObjectOutput< typeof SveltePropDiagnosticEntries >

kind

type "svelte_prop_failed"

componentName

Name of the component.

type string

propName

Name of the prop.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

SveltePropDiagnosticInput
#

diagnostics.ts view source

SveltePropDiagnosticInput import type {SveltePropDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input SveltePropDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof SveltePropDiagnosticEntries >

kind

type "svelte_prop_failed"

componentName

Name of the component.

type string

propName

Name of the prop.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

TransformFailedDiagnostic
#

diagnostics.ts view source

value + type

TransformFailedDiagnostic import {TransformFailedDiagnostic} from 'svelte-docinfo/diagnostics.js';

svelte2tsx transform threw for a .svelte file.

Unrecoverable at ingest — the file's owned-entry stays in the session (virtual: undefined, unfilteredDeps: [], transformFailed: true) so query() can synthesize a placeholder ModuleJson (partial: true, empty declarations). The originating error message lives in message; this diagnostic is the authoritative cause-of-failure signal.

inheritance

extends: s.SchemaStrictObjectOutput< typeof TransformFailedDiagnosticEntries >

kind

type "transform_failed"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

TransformFailedDiagnosticInput
#

diagnostics.ts view source

TransformFailedDiagnosticInput import type {TransformFailedDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input TransformFailedDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof TransformFailedDiagnosticEntries >

kind

type "transform_failed"

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

TypeExtractionDiagnostic
#

diagnostics.ts view source

value + type

TypeExtractionDiagnostic import {TypeExtractionDiagnostic} from 'svelte-docinfo/diagnostics.js';

Type extraction failed (e.g., complex or recursive types).

inheritance

extends: s.SchemaStrictObjectOutput< typeof TypeExtractionDiagnosticEntries >

kind

type "type_extraction_failed"

symbolName

Name of the symbol whose type couldn't be extracted.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

TypeExtractionDiagnosticInput
#

diagnostics.ts view source

TypeExtractionDiagnosticInput import type {TypeExtractionDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input TypeExtractionDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof TypeExtractionDiagnosticEntries >

kind

type "type_extraction_failed"

symbolName

Name of the symbol whose type couldn't be extracted.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

UnknownCsspropDiagnostic
#

diagnostics.ts view source

value + type

UnknownCsspropDiagnostic import {UnknownCsspropDiagnostic} from 'svelte-docinfo/diagnostics.js';

A component's @cssprop tag names a custom property the component never reads through var(): not in its <style> (nested fallbacks included), nor in the static text of its markup's style attributes, style: directives, or child components' style and --a attributes.

Usually a typo or a stale tag; it may also be a property the component leaves for its children to read. The entry stays in ComponentDeclarationJson.cssCustomProperties, documented: true, at the tag's line, which line also points at. Not emitted when the style wasn't read (css_parse_failed, css_lang_unsupported).

Always warning, query-time category.

inheritance

extends: s.SchemaStrictObjectOutput< typeof UnknownCsspropDiagnosticEntries >

kind

type "unknown_cssprop"

propertyName

The custom property the @cssprop tag names, -- included.

type string

componentName

Name of the component.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

UnknownCsspropDiagnosticInput
#

diagnostics.ts view source

UnknownCsspropDiagnosticInput import type {UnknownCsspropDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input UnknownCsspropDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof UnknownCsspropDiagnosticEntries >

kind

type "unknown_cssprop"

propertyName

The custom property the @cssprop tag names, -- included.

type string

componentName

Name of the component.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

UnknownParamDiagnostic
#

diagnostics.ts view source

value + type

UnknownParamDiagnostic import {UnknownParamDiagnostic} from 'svelte-docinfo/diagnostics.js';

@param tag references a name that doesn't match any actual parameter.

Usually a typo (@param argz for parameter args) or stale doc after a rename. The description is dropped; analysis continues.

inheritance

extends: s.SchemaStrictObjectOutput< typeof UnknownParamDiagnosticEntries >

kind

type "unknown_param"

paramName

The @param key that didn't match a real parameter.

type string

functionName

Name of the function or method.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

UnknownParamDiagnosticInput
#

diagnostics.ts view source

UnknownParamDiagnosticInput import type {UnknownParamDiagnosticInput} from 'svelte-docinfo/diagnostics.js';

The input UnknownParamDiagnostic parses, with any field it defaults optional.

inheritance

extends: s.SchemaStrictObjectInput< typeof UnknownParamDiagnosticEntries >

kind

type "unknown_param"

paramName

The @param key that didn't match a real parameter.

type string

functionName

Name of the function or method.

type string

file

File path relative to project root (no leading slash, no ./ prefix).

Normalized at every public API boundary — session.setFile/setFiles (ingest-time), session.query (query-time, via analyzeCore), and the one-shot wrappers analyze / analyzeFromFiles. Producers inside the pipeline may write absolute or virtual paths (e.g., Foo.svelte.__svelte2tsx__.ts); normalization rewrites them to project-relative form before they reach consumers.

The exception is discovery — discoverSourceFiles / discoverFromExports return their diagnostics unnormalized, since they run before any session exists. Their file is already project-root-relative, but message can embed an absolute path (an fs error names the file it failed on), so a consumer wiring discovery up itself owns the normalizeDiagnosticPaths call — analyzeFromFiles and the Vite plugin both make it before merging.

The absolute form is the one to write. Normalization deliberately leaves an already-relative path alone (relativizing it would resolve against cwd), so a producer writing a ModuleJson.path — relative to sourceRoot, a different base — passes through untouched and publishes the same file under a second name. Absolute is what the pass can actually correct.

type string

message

Human-readable description of the issue.

type string

severity

type "error" | "warning"

line?

Line number (1-based), absent if location unavailable.

type number

column?

Column number (1-based), absent if location unavailable.

type number

warningsOf
#

Depends on
#

Imported by
#