svelte-docinfo 0.13.0 → 0.15.0

package/LICENSE

@@ -1,21 +1,14 @@
-MIT License
+BSD Zero Clause License
 
 Copyright (c) fuz.dev
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Permission to use, copy, modify, and/or distribute this software for
+any purpose with or without fee is hereby granted.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+THE SOFTWARE IS PROVIDED “AS IS” AND THE AUTHOR DISCLAIMS ALL
+WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES
+OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE
+FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY
+DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -18,8 +18,8 @@ in the [npm package](https://www.npmjs.com/package/svelte-docinfo).
 npm i -D svelte-docinfo
 ```
 
-Peer dependencies: `svelte` 5+, `svelte2tsx`, and `typescript` 5.9+ or 6 (npm 7+
-installs them automatically), plus an optional `vite` 6+ for the Vite plugin.
+Peer dependencies: `svelte` 5+, `svelte2tsx`, and `typescript` 5.9+ or 6,
+plus an optional `vite` 6+ for the Vite plugin.
 
 - [Quick start](#quick-start)
 - [Vite plugin](#vite-plugin)
@@ -28,6 +28,7 @@ installs them automatically), plus an optional `vite` 6+ for the Vite plugin.
 - [Features](#features)
 - [Documentation](#documentation)
 - [Credits](#credits)
+- [Contributing](#contributing)
 - [License](#license)
 
 svelte-docinfo is largely inspired by [`sveld`](https://github.com/carbon-design-system/sveld),
@@ -53,23 +54,24 @@ which was more limited, lacking the fancy TS compiler usage, and grew slowly ove
 
 ## Quick start
 
-Given a project with a `tsconfig.json` (at or above the project root) and a couple of files in `src/lib/`:
+Given a project with a `tsconfig.json` (at or above the project root) and two files,
+`src/lib/math.ts`:
 
 ```ts
-// src/lib/math.ts
-
 /**
  * Add two numbers.
  * @param a - first number
  * @param b - second number
  * @returns the sum
  */
-export const add = (a: number, b: number): number => a + b;
+export function add(a: number, b: number): number {
+	return a + b;
+}
 ```
 
-```svelte
-<!-- src/lib/Calculator.svelte -->
+and `src/lib/Calculator.svelte`:
 
+```svelte
 <!--
 	@component
 	Calculator component for demonstrating Svelte analysis.
@@ -96,6 +98,8 @@ Three ways to integrate `svelte-docinfo`:
 
 ```ts
 // vite.config.ts
+import { defineConfig } from 'vite';
+import { sveltekit } from '@sveltejs/kit/vite';
 import svelteDocinfo from 'svelte-docinfo/vite.js';
 
 export default defineConfig({ plugins: [sveltekit(), svelteDocinfo()] });
@@ -117,7 +121,8 @@ import { analyzeFromFiles } from 'svelte-docinfo';
 const { modules } = await analyzeFromFiles({ projectRoot: process.cwd() });
 ```
 
-All three produce the same JSON shape:
+All three produce the same `AnalyzeResultJson` data. The CLI emits it compacted, as shown
+here (the Vite module compacts `modules` only); the API returns it with defaults filled in:
 
 ```json
 {
@@ -186,9 +191,9 @@ All three produce the same JSON shape:
 }
 ```
 
-Defaulted fields are left out of the JSON: empty arrays and `false` flags. To restore them
-and validate the shape, parse it with `parseAnalyzeResult` (`parseModuleJson` for one module,
-`parseDiagnostics` for diagnostics alone):
+The compact form leaves out defaulted fields: empty arrays (like `diagnostics` here) and
+`false` flags. To restore them and validate the shape, parse it with `parseAnalyzeResult`
+(`parseModuleJson` for one module, `parseDiagnostics` for diagnostics alone):
 
 ```ts
 import { parseAnalyzeResult } from 'svelte-docinfo';
@@ -245,19 +250,19 @@ Plugin options:
 | `resolveDependencies` | `true`                                               | Resolve import dependencies. When `false`, `dependencies`/`dependents` stay empty.                                                                                                                                     |
 | `hmrDebounceMs`       | `100`                                                | Dev re-analysis debounce delay in milliseconds.                                                                                                                                                                        |
 | `onDuplicates`        | —                                                    | Opt-in check that names are unique across modules, for packages with a flat export namespace: `'diagnostic'` \| `'warn'` \| `'throw'`. Off by default.                                                                |
-| `tsconfig`            | `'tsconfig.json'`                                    | Path to the tsconfig, relative to `projectRoot`, or `false` to analyze without one (built-in strict options, with `compilerOptions` merged on top). |
+| `tsconfig`            | `'tsconfig.json'`                                    | Path to the tsconfig, relative to `projectRoot` and searched upward from it, or `false` to analyze without one (built-in strict options, with `compilerOptions` merged on top). |
 | `compilerOptions`     | —                                                    | Compiler options merged over the tsconfig's, per key. |
 | `rootFileNames`       | the tsconfig's roots                                 | The program's root files in place of the tsconfig's: a list, or a function over the tsconfig's roots (`declarationFileRoots`, from `svelte-docinfo/typescript-program.js`, keeps the declaration files). Narrowing speeds up cold analysis; an ambient type declared in a dropped root resolves to `any`. |
 
 Source-scope notes (shared with the [CLI](#cli) and `analyzeFromFiles`):
 
-- Explicit `include` patterns **widen the source scope**: each pattern's static base joins `sourceOptions.sourcePaths`, so include-discovered files emit modules (with paths relative to the widened set's common root) and the dev-mode watcher tracks them. A pattern with no base (`'**/*.ts'`, a literal root file) scopes the whole project root as source and logs an info line naming it.
-- An **always-on baseline** applies beneath any `exclude`: `node_modules` and dot-directories below a matched source path are never source. It's matched relative to the matched source path — an explicit dot-directory source path (`sourcePaths: ['.hidden/src']`) still works — and is independent of `exclude` overrides. `dist`/`build`/`coverage` are ordinary names and stay in.
-- The **`src/lib/internal/` convention**: `internal/` directories are excluded by default (the `**/internal/**` default pattern) — internal modules ship in the package for public modules to import but aren't documented. Packages typically pair the directory with an `"./internal/*": null` package.json exports entry blocking consumer imports; exports-based discovery honors null-target keys with Node's best-match resolution semantics, so blocked subpaths are never discovered. Internal modules stay live in dev: the analysis session owns them as watched context files, so editing an internal type re-analyzes the public modules that use it. A public re-export of an internal symbol (`export { x } from './internal/helper.js'`) documents at the re-export site as a full synthesized declaration. Re-include internal modules wholesale with the exclude callback: `exclude: (defaults) => defaults.filter((p) => p !== '**/internal/**')`.
-- Paths and patterns resolve against `projectRoot`: absolute entries inside the root are accepted (stored root-relative), and anything resolving outside the root **throws** at options creation instead of silently emitting nothing — a root-anchored `'/src/lib'` is filesystem-absolute, not shorthand for `'src/lib'`.
+- `include` **widens the source scope**: each pattern's static base joins `sourceOptions.sourcePaths`, so the files it finds emit modules (with paths relative to the widened set's common root) and the dev watcher tracks them. A pattern with no base (`'**/*.ts'`, a literal root file) makes the whole project root source and logs an info line.
+- Beneath any `exclude`, `node_modules` and dot-directories below a source path are never source. The rule is relative to the source path, so an explicit dot-directory source path (`sourcePaths: ['.hidden/src']`) still works. `dist`, `build`, and `coverage` are ordinary names.
+- **`src/lib/internal/`** holds modules that ship for public modules to import but aren't documented, excluded by the default `**/internal/**` pattern. Packages typically block consumer imports with an `"./internal/*": null` exports entry, which exports discovery honors with Node's best-match semantics. Internal modules stay live in dev: editing one re-analyzes the public modules that use it. A public re-export of an internal symbol documents as a full declaration at the re-export site. To document them anyway: `exclude: (defaults) => defaults.filter((p) => p !== '**/internal/**')`.
+- Paths and patterns resolve against `projectRoot`. Absolute entries inside the root are accepted, and anything outside it **throws** at options creation instead of silently emitting nothing. `'/src/lib'` is filesystem-absolute, not shorthand for `'src/lib'`.
 
 The options interface is `VitePluginSvelteDocinfoOptions` from `svelte-docinfo/vite.js` (not re-exported from the main barrel).
-See the [docs site](https://svelte-docinfo.fuz.dev/) and [examples/vite/](examples/vite/README.md) for more.
+See the [Vite plugin docs](https://svelte-docinfo.fuz.dev/docs/vite-plugin) and [examples/vite/](examples/vite/README.md) for more.
 
 > If TypeScript reports `Cannot find module 'virtual:svelte-docinfo'`, ensure the `/// <reference>` line is in your `app.d.ts`.
 
@@ -297,18 +302,20 @@ All CLI options:
 | `--only <pattern>`          | Glob filter applied to module paths in output (repeatable). Full project is still analyzed (re-exports/dependents stay correct); diagnostics aren't filtered                                  |
 | `--no-resolve-dependencies` | Disable dependency resolution                                                                                                                                                                 |
 | `--pretty`                  | Pretty-print JSON output (default: compact)                                                                                                                                                   |
-| `--tsconfig <path>`         | Path to the tsconfig, relative to project root (default: `tsconfig.json`, searched upward from project root) |
+| `--tsconfig <path>`         | Path to the tsconfig, relative to project root and searched upward from it (default: `tsconfig.json`) |
 | `--no-tsconfig`             | Analyze without a tsconfig, using built-in strict compiler options |
 | `-q, --quiet`               | Suppress info messages on stderr (warnings and errors still print)                                                                                                                            |
 | `--on-duplicates <mode>`    | Opt-in check that names are unique across modules, for packages with a flat export namespace: `diagnostic` \| `warn` \| `throw` (default: off)                                                |
 | `-V, --version`             | Show version number                                                                                                                                                                           |
+| `-h, --help`                | Show help                                                                                                                                                                                     |
 
-The [Vite plugin](#vite-plugin)'s source-scope notes apply here too: explicit `--include` patterns widen the source scope (module paths become relative to the widened root, and a pattern with no base scopes the whole project root and logs an info line); `node_modules` and dot-directories below a source dir are always excluded regardless of `--exclude`; absolute paths and patterns inside the project root are accepted, and out-of-root ones fail loudly.
+The [Vite plugin](#vite-plugin)'s source-scope notes apply here too, with `--include`, `--exclude`, and `--source-dir` in place of the options. `--exclude` always replaces the defaults (there's no callback form), so to document `internal/`, re-list the others: `-e '**/*.test.ts' -e '**/*.spec.ts'`.
 
-Exit codes: 0 (success), 1 (analysis errors), 2 (CLI errors or a thrown analysis error, like a
-missing or unloadable `tsconfig.json`).
+Exit codes: 0 (success), 1 (analysis errors), 2 (a usage error, like an unknown flag or a
+missing or invalid option value, or a thrown analysis error, like a missing or unloadable
+`tsconfig.json`).
 
-See [examples/cli/](examples/cli/README.md) for more usage patterns.
+See the [CLI docs](https://svelte-docinfo.fuz.dev/docs/cli) and [examples/cli/](examples/cli/README.md) for more.
 
 ## API
 
@@ -338,7 +345,8 @@ For just the discovery step (without running analysis), use
 
 For long-lived consumers (a Vite plugin reacting to file edits, an LSP-style tool),
 `createAnalysisSession` returns a persistent handle that reuses parsed ASTs across calls
-— see [examples/api/analyze-session.js](examples/api/analyze-session.js).
+— see the [session docs](https://svelte-docinfo.fuz.dev/docs/session) and
+[examples/api/analyze-session.js](examples/api/analyze-session.js).
 
 See [examples/api/](examples/api/README.md) for more patterns
 including custom discovery, diagnostics, sessions, and error handling.
@@ -349,30 +357,28 @@ See the [API docs](https://svelte-docinfo.fuz.dev/docs/api) for the full referen
 
 ## Features
 
-- **Full type resolution**: infers complex types without manual annotations, including generics, imported types, and inferred return types
-- **Structured types**: an optional `typeInfo` tree (`TypeJson`) beside the flat type strings on props, parameters, return types (`returnTypeInfo`, overloads included), members, and variable/type declarations — union and intersection members (alias names kept), reference type arguments, and array/tuple elements, so a union alias documents more than its own name. Absent wherever the flat string already says everything; `typeJsonToTokens`/`typeJsonToText` render it
-- **TSDoc/JSDoc parsing**: the common doc tags (`@param`, `@returns`, `@throws`, `@example`, `@deprecated`, `@internal`, `@see`, `@since`, `@default`) plus `@nodocs`, `@mutates`, and `@module` for file-level comments; divergent spellings parse as synonyms (`@return`, `@defaultValue`). `@internal` marks unstable API (`internalMessage`) but stays documented — `@nodocs` is the exclusion. Dotted `@param obj.prop` tags fill `propertyDescriptions`, and inline `{@link}` survives in extracted text
-- **Alias-lost name recovery**: TypeScript drops the name of an alias over an indexed access or conditional (`type Foo = z.infer<typeof S>`, or valibot's `v.InferOutput<typeof S>`) and expands its structure at every use. `typeInfo` recovers it as `{kind: 'reference', name}`, from the written annotation where there is one and otherwise from a registry of the project's exported aliases (those references also carry `module` for exact linking). Losses nothing recovers surface as `alias_lost` warnings
-- **Merged value+type symbols**: `export const Foo = z.strictObject({...})` + `export type Foo = z.infer<typeof Foo>` documents the type meaning (structure and members), with `mergedValue: true` marking the name as also a runtime value; JSDoc falls back to the const's docs, and `generateImport` emits a value import
-- **Svelte 5 component props**: extracts prop types, descriptions, defaults, and bindability via svelte2tsx, in source order (destructured external props follow, in destructuring order); generic components carry `genericParams`, and JS components (no `lang="ts"`) are supported — props come from the JSDoc `@type` on `$props()` or are inferred from untyped destructuring
-- **External types**: props and members contributed by external packages (e.g. `HTMLButtonAttributes`) are filtered out and named in `externalTypes` — on components, type aliases, interfaces, and classes, including bags reached through local base types. A component prop named in the `$props()` destructuring (`let {type = 'button', ...rest} = $props()`) is documented anyway, since the component handles it
-- **Svelte 5 snippets**: `kind: 'snippet'` for template snippets (with structured parameters), `acceptsChildren` on components
-- **Svelte 5 reactivity runes**: detects `$state`, `$state.raw`, `$derived`, `$derived.by` on variables and class fields (`reactivity` field) — syntactic detection, surfaces wherever the rune pattern appears
-- **Class members**: public + protected fields, methods, constructors, getters/setters, generics; private (`private` and `#field`) excluded
-- **Enums**: regular and const, with member values and per-member JSDoc
-- **Function overloads**: all public overload signatures with per-overload JSDoc
-- **Dependency graphs**: tracks imports between modules and computes dependents
-- **Re-export tracking**: `alsoExportedFrom` arrays on canonical declarations plus the forward view `ModuleJson.reExports` (so barrels are self-describing), `aliasOf` for renames, `starExports` for `export * from './x'`, and `externalReExports`/`externalStarExports` for direct re-exports from packages — with `resolveExportSurface()` to combine them all into a module's full export surface using ES star semantics
-- **Namespace re-exports**: `export * as ns from './x'` synthesized as `kind: 'namespace'`
-- **Source locations**: file and line for every declaration
-- **Build-tool agnostic**: works with any source: file system, build pipeline, or in-memory
-- **Diagnostic collection**: accumulates warnings and errors without halting; `partial: true` flags incomplete declarations
+- **Full type resolution**: generics, imported types, and inferred return types, without manual annotations
+- **Structured types**: an optional `typeInfo` tree (`TypeJson`) beside the flat type strings, with union and intersection members (alias names kept), type arguments, and array/tuple elements. Absent where the flat string says everything; `typeJsonToTokens`/`typeJsonToText` render it
+- **Alias-lost name recovery**: TypeScript drops the name of an alias over an indexed access or conditional (`z.infer<typeof S>`, valibot's `v.InferOutput<typeof S>`) and expands it at every use. `typeInfo` recovers it as `{kind: 'reference', name}`, from the written annotation or from a registry of the project's exported aliases. Losses nothing recovers surface as `alias_lost` warnings
+- **TSDoc/JSDoc**: `@param`, `@returns`, `@throws`, `@example`, `@deprecated`, `@internal`, `@see`, `@since`, `@default`, `@module`, plus the custom `@nodocs` (exclude from docs) and `@mutates`; `@return` and `@defaultValue` parse as synonyms. `@internal` is a marker (`internalMessage`), not an exclusion. Inline `{@link}` survives in the text
+- **Merged value+type symbols**: `const Foo = z.strictObject({...})` + `type Foo = z.infer<typeof Foo>` documents the type, with `mergedValue: true` marking the name as also a runtime value; JSDoc falls back to the const's
+- **Svelte 5 components**: prop types, descriptions, defaults, bindability, and callback signatures via svelte2tsx, plus generics and `acceptsChildren`. JS components take props from the JSDoc `@type` on `$props()` or infer them from the destructuring
+- **External types**: props and members from external packages (`HTMLButtonAttributes`) are filtered out and named in `externalTypes` (on components, type aliases, interfaces, and classes, including bags reached through local base types), unless the `$props()` destructuring names them
+- **Svelte 5 snippets**: `kind: 'snippet'` for snippets exported from `<script module>`, with structured parameters
+- **Runes**: `$state`, `$state.raw`, `$derived`, and `$derived.by` on variables and class fields (`reactivity`), detected syntactically in any file
+- **Classes, enums, and overloads**: public and protected class members (`private` and `#` excluded), regular and const enums with member values, and every public overload signature with its own JSDoc
+- **Re-exports**: `alsoExportedFrom` on canonical declarations and `ModuleJson.reExports` on barrels, `aliasOf` for renames, `starExports`, `kind: 'namespace'` for `export * as ns`, and external re-exports, with `resolveExportSurface()` combining them using ES star semantics
+- **Dependency graphs**: imports between modules and the computed dependents
+- **Source locations**: the source line of every declaration
+- **Build-tool agnostic**: files can come from disk, a build pipeline, or memory
+- **Diagnostics**: warnings and errors accumulate without halting; `partial: true` flags incomplete declarations
 
 Known gaps:
 
-- context tracking (transitive detection of common patterns seems tractable)
-- standalone `namespace Foo {}` declarations and decorators are not yet supported
-- legacy `export let` components document their props (all `bindable`), and a legacy component's default `<slot />` sets `acceptsChildren`, but named slots, slot props, events, and `$$restProps` aren't modeled — Svelte 5 snippets and callback props replace most of them
+- Svelte context (`setContext`/`getContext`) isn't captured yet; investigation is planned, and
+  a [request](https://github.com/fuzdev/svelte-docinfo/discussions) would bump its priority
+- standalone `namespace Foo {}` declarations document as a bare variable with no members, and decorators aren't modeled
+- legacy `export let` components document their props (all `bindable`), and a legacy component's default `<slot />` sets `acceptsChildren` (a runes component's is ignored), but named slots, slot props, events, and `$$restProps` aren't modeled
 - `@nodocs` applies to declarations and export statements only; on a member or component prop it's ignored without a warning
 
 [Issues](https://github.com/fuzdev/svelte-docinfo/issues) for bugs and
@@ -408,4 +414,4 @@ see [package.json](package.json) for full dependencies.
 
 ## License
 
-[MIT](LICENSE)
+[0BSD](LICENSE)

package/dist/analyze-core.d.ts

@@ -43,7 +43,7 @@ import { type SvelteVirtualFile } from './svelte.js';
 import { type SourceFileInfo } from './source.js';
 import { type ModuleSourceOptions } from './source-config.js';
 import type { AliasRegistry } from './typescript-extract-type-json.js';
-import { type IsEmittedFile } from './typescript-extract-shared.js';
+import { type FileExists, type IsEmittedFile } from './typescript-extract-shared.js';
 /**
  * Opt-in check that declaration names are unique across modules.
  *
@@ -65,14 +65,14 @@ import { type IsEmittedFile } from './typescript-extract-shared.js';
 export type OnDuplicates = 'diagnostic' | 'warn' | 'throw';
 declare const AnalyzeResultJsonEntries: v.StrictObjectSchema<{
     readonly modules: v.OptionalSchema<v.ArraySchema<import("./types.js").ModuleJsonSchema, undefined>, () => never[]>;
-    readonly diagnostics: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"kind", [import("./diagnostics.js").TypeExtractionDiagnosticSchema, import("./diagnostics.js").SignatureAnalysisDiagnosticSchema, import("./diagnostics.js").ClassMemberDiagnosticSchema, import("./diagnostics.js").SveltePropDiagnosticSchema, import("./diagnostics.js").ModuleSkippedDiagnosticSchema, import("./diagnostics.js").ModuleUnreadableDiagnosticSchema, import("./diagnostics.js").ImportParseDiagnosticSchema, import("./diagnostics.js").DuplicateCommentDiagnosticSchema, import("./diagnostics.js").MisplacedTagDiagnosticSchema, import("./diagnostics.js").UnknownParamDiagnosticSchema, import("./diagnostics.js").SourceMapFailedDiagnosticSchema, import("./diagnostics.js").DuplicateDeclarationDiagnosticSchema, import("./diagnostics.js").TransformFailedDiagnosticSchema, import("./diagnostics.js").ResolverFailedDiagnosticSchema, import("./diagnostics.js").AliasLostDiagnosticSchema], undefined>, undefined>, () => never[]>;
+    readonly diagnostics: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"kind", [import("./diagnostics.js").TypeExtractionDiagnosticSchema, import("./diagnostics.js").SignatureAnalysisDiagnosticSchema, import("./diagnostics.js").ClassMemberDiagnosticSchema, import("./diagnostics.js").SveltePropDiagnosticSchema, import("./diagnostics.js").ModuleSkippedDiagnosticSchema, import("./diagnostics.js").ModuleUnreadableDiagnosticSchema, import("./diagnostics.js").ImportParseDiagnosticSchema, import("./diagnostics.js").DuplicateCommentDiagnosticSchema, import("./diagnostics.js").ComponentCommentMismatchDiagnosticSchema, import("./diagnostics.js").MisplacedTagDiagnosticSchema, import("./diagnostics.js").UnknownParamDiagnosticSchema, import("./diagnostics.js").SourceMapFailedDiagnosticSchema, import("./diagnostics.js").DuplicateDeclarationDiagnosticSchema, import("./diagnostics.js").TransformFailedDiagnosticSchema, import("./diagnostics.js").ResolverFailedDiagnosticSchema, import("./diagnostics.js").AliasLostDiagnosticSchema], undefined>, undefined>, () => never[]>;
 }, undefined>;
 /** @nodocs */
 export interface AnalyzeResultJsonEntriesInput extends Named<v.InferInput<typeof AnalyzeResultJsonEntries>> {
 }
 declare const AnalyzeResultJsonImpl: v.SchemaWithPipe<readonly [v.CustomSchema<AnalyzeResultJsonEntriesInput, v.ErrorMessage<v.CustomIssue> | undefined>, v.StrictObjectSchema<{
     readonly modules: v.OptionalSchema<v.ArraySchema<import("./types.js").ModuleJsonSchema, undefined>, () => never[]>;
-    readonly diagnostics: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"kind", [import("./diagnostics.js").TypeExtractionDiagnosticSchema, import("./diagnostics.js").SignatureAnalysisDiagnosticSchema, import("./diagnostics.js").ClassMemberDiagnosticSchema, import("./diagnostics.js").SveltePropDiagnosticSchema, import("./diagnostics.js").ModuleSkippedDiagnosticSchema, import("./diagnostics.js").ModuleUnreadableDiagnosticSchema, import("./diagnostics.js").ImportParseDiagnosticSchema, import("./diagnostics.js").DuplicateCommentDiagnosticSchema, import("./diagnostics.js").MisplacedTagDiagnosticSchema, import("./diagnostics.js").UnknownParamDiagnosticSchema, import("./diagnostics.js").SourceMapFailedDiagnosticSchema, import("./diagnostics.js").DuplicateDeclarationDiagnosticSchema, import("./diagnostics.js").TransformFailedDiagnosticSchema, import("./diagnostics.js").ResolverFailedDiagnosticSchema, import("./diagnostics.js").AliasLostDiagnosticSchema], undefined>, undefined>, () => never[]>;
+    readonly diagnostics: v.OptionalSchema<v.ArraySchema<v.VariantSchema<"kind", [import("./diagnostics.js").TypeExtractionDiagnosticSchema, import("./diagnostics.js").SignatureAnalysisDiagnosticSchema, import("./diagnostics.js").ClassMemberDiagnosticSchema, import("./diagnostics.js").SveltePropDiagnosticSchema, import("./diagnostics.js").ModuleSkippedDiagnosticSchema, import("./diagnostics.js").ModuleUnreadableDiagnosticSchema, import("./diagnostics.js").ImportParseDiagnosticSchema, import("./diagnostics.js").DuplicateCommentDiagnosticSchema, import("./diagnostics.js").ComponentCommentMismatchDiagnosticSchema, import("./diagnostics.js").MisplacedTagDiagnosticSchema, import("./diagnostics.js").UnknownParamDiagnosticSchema, import("./diagnostics.js").SourceMapFailedDiagnosticSchema, import("./diagnostics.js").DuplicateDeclarationDiagnosticSchema, import("./diagnostics.js").TransformFailedDiagnosticSchema, import("./diagnostics.js").ResolverFailedDiagnosticSchema, import("./diagnostics.js").AliasLostDiagnosticSchema], undefined>, undefined>, () => never[]>;
 }, undefined>]>;
 /** @nodocs */
 export interface AnalyzeResultJsonSchema extends Named<typeof AnalyzeResultJsonImpl> {
@@ -175,14 +175,16 @@ export interface AnalyzeResultJsonWire {
  * modules themselves get written-name recovery only, while `analyzeCore`
  * passes the registry its pre-pass built (see `buildAliasRegistry`).
  * `isEmittedFile` likewise: `analyzeCore` answers from its emitted set, and a
- * direct caller falls back to `isSource` (see `IsEmittedFile`).
+ * direct caller falls back to `isSource` (see `IsEmittedFile`). `fileExists`
+ * too: `analyzeCore` sees its inputs' in-memory content, and a direct caller
+ * falls back to the disk (see `SvelteFileStatus`).
  *
  * @internal Importable from `svelte-docinfo/analyze-core.js` for tests and
  * power users; not stable API.
  */
 export declare const analyzeModule: (sourceFile: SourceFileInfo & {
     dependents?: ReadonlyArray<string>;
-}, program: ts.Program, options: ModuleSourceOptions, diagnostics: Array<Diagnostic>, log?: AnalysisLog, aliasRegistry?: AliasRegistry, isEmittedFile?: IsEmittedFile) => ModuleJson | undefined;
+}, program: ts.Program, options: ModuleSourceOptions, diagnostics: Array<Diagnostic>, log?: AnalysisLog, aliasRegistry?: AliasRegistry, isEmittedFile?: IsEmittedFile, fileExists?: FileExists) => ModuleJson | undefined;
 /**
  * Inputs to `analyzeCore`. The caller (one-shot wrapper or session.query)
  * is responsible for normalizing `sourceOptions`, obtaining the program,
@@ -213,10 +215,18 @@ export interface AnalyzeCoreInputs {
      *
      * Resolution requires the component's virtual to exist — via the context
      * closure (`analyzeFromFiles` included) or by passing the file as `analyze()`
-     * input. Without it a gated component re-export degrades silently to an
-     * empty `kind: 'variable'` husk.
+     * input. Without it a gated component re-export documents as a `partial`
+     * component with nothing filled.
      */
     contextSvelteFiles?: ReadonlyArray<SourceFileInfo>;
+    /**
+     * Whether a path exists — owned in-memory content or disk. It tells a
+     * `.svelte` file with no svelte2tsx virtual from a mistyped specifier (see
+     * `SvelteFileStatus`). Defaults to the files handed in plus the disk; a
+     * session passes its whole owned set, which also holds files that emit
+     * nothing and aren't offered as context.
+     */
+    fileExists?: FileExists;
     onDuplicates?: OnDuplicates;
     log?: AnalysisLog;
 }

package/dist/analyze-core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"analyze-core.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/analyze-core.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"analyze-core.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/analyze-core.ts"],"names":[],"mappings":"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"}

package/dist/analyze-core.js

@@ -40,6 +40,7 @@ import { ModuleJson, parseModuleJson } from './types.js';
 import { parseWithSummary } from './schema.js';
 import { Diagnostic } from './diagnostics.js';
 import { analyzeTypescriptModule } from './typescript-exports.js';
+import { toModuleDocFields } from './tsdoc.js';
 import { analyzeSvelteModule, reclassifySnippetDeclaration, remapVirtualDiagnosticPositions } from './svelte.js';
 import { scrubVirtualSuffixes, stripVirtualSuffix, getComponentName } from './source.js';
 import { extractPath, extractDependencies } from './source-config.js';
@@ -186,7 +187,7 @@ const toModuleJson = (raw) => {
         reExports,
         externalReExports,
         externalStarExports: raw.externalStarExports,
-        ...(raw.moduleComment ? { moduleComment: raw.moduleComment } : {})
+        ...toModuleDocFields(raw.moduleDoc)
     });
 };
 // Module dispatch
@@ -211,12 +212,14 @@ const toModuleJson = (raw) => {
  * modules themselves get written-name recovery only, while `analyzeCore`
  * passes the registry its pre-pass built (see `buildAliasRegistry`).
  * `isEmittedFile` likewise: `analyzeCore` answers from its emitted set, and a
- * direct caller falls back to `isSource` (see `IsEmittedFile`).
+ * direct caller falls back to `isSource` (see `IsEmittedFile`). `fileExists`
+ * too: `analyzeCore` sees its inputs' in-memory content, and a direct caller
+ * falls back to the disk (see `SvelteFileStatus`).
  *
  * @internal Importable from `svelte-docinfo/analyze-core.js` for tests and
  * power users; not stable API.
  */
-export const analyzeModule = (sourceFile, program, options, diagnostics, log, aliasRegistry, isEmittedFile) => {
+export const analyzeModule = (sourceFile, program, options, diagnostics, log, aliasRegistry, isEmittedFile, fileExists) => {
     const checker = program.getTypeChecker();
     const modulePath = extractPath(sourceFile.id, options);
     // diagnostics carry the absolute id (see the `Diagnostic.file` schema doc);
@@ -254,7 +257,7 @@ export const analyzeModule = (sourceFile, program, options, diagnostics, log, al
         }
         // the pass-scoped extraction context — constructed here because the
         // dispatcher is where the program is in hand (see `analyzeExports`)
-        const ctx = createExtractContext(program, checker, options, diagnostics, aliasRegistry, isEmittedFile);
+        const ctx = createExtractContext(program, checker, options, diagnostics, aliasRegistry, isEmittedFile, fileExists);
         raw = analyzeTypescriptModule(sourceFile, tsSourceFile, modulePath, ctx, options);
         // a TS module can't declare a snippet, but it can re-export one from a
         // component that emits nothing, and the synthesized alias is analyzed
@@ -297,7 +300,7 @@ export const analyzeModule = (sourceFile, program, options, diagnostics, log, al
  * entirely; analysis diagnostics are dropped — the canonical's `partial`
  * flag propagates through the fill, which is the emitted signal.
  */
-const analyzeContextComponents = (contextSvelteFiles, emittedModules, inputs, aliasRegistry, isEmittedFile) => {
+const analyzeContextComponents = (contextSvelteFiles, emittedModules, inputs, aliasRegistry, isEmittedFile, fileExists) => {
     const { sourceOptions, program, svelteVirtualFiles } = inputs;
     const referenced = new Set();
     for (const mod of emittedModules) {
@@ -317,7 +320,7 @@ const analyzeContextComponents = (contextSvelteFiles, emittedModules, inputs, al
         if (!virtualFile)
             continue;
         const droppedDiagnostics = [];
-        const raw = analyzeSvelteModule(sourceFile, modulePath, program.getTypeChecker(), sourceOptions, droppedDiagnostics, program, virtualFile, aliasRegistry, isEmittedFile);
+        const raw = analyzeSvelteModule(sourceFile, modulePath, program.getTypeChecker(), sourceOptions, droppedDiagnostics, program, virtualFile, aliasRegistry, isEmittedFile, fileExists);
         if (raw)
             contextModules.push(toModuleJson(raw));
     }
@@ -352,6 +355,12 @@ export const analyzeCore = (inputs) => {
     // link to from one they have to document in place.
     const emittedIds = new Set(sourceFiles.map((f) => toPosixPath(f.id)));
     const isEmittedFile = (file) => emittedIds.has(file);
+    // Existence for `SvelteFileStatus`: the caller's answer, else the files
+    // handed in (in-memory content counts) plus the disk.
+    const knownIds = new Set(emittedIds);
+    for (const f of contextSvelteFiles ?? [])
+        knownIds.add(toPosixPath(f.id));
+    const fileExists = inputs.fileExists ?? ((file) => knownIds.has(file) || ts.sys.fileExists(file));
     // Registry pre-pass: register the emitted set's exported lost aliases
     // before any extraction, so every `resolveTypeInfo` call this cycle can
     // consult a complete registry. Svelte modules are reached through their
@@ -416,7 +425,7 @@ export const analyzeCore = (inputs) => {
         const virtualFile = svelteVirtualFiles.get(sourceFile.id);
         if (virtualFile) {
             const modulePath = extractPath(sourceFile.id, sourceOptions);
-            const raw = analyzeSvelteModule(sourceFile, modulePath, checker, sourceOptions, diagnostics, program, virtualFile, aliasRegistry, isEmittedFile);
+            const raw = analyzeSvelteModule(sourceFile, modulePath, checker, sourceOptions, diagnostics, program, virtualFile, aliasRegistry, isEmittedFile, fileExists);
             if (raw) {
                 mod = toModuleJson(raw);
             }
@@ -425,7 +434,7 @@ export const analyzeCore = (inputs) => {
             }
         }
         else {
-            mod = analyzeModule(sourceFile, program, sourceOptions, diagnostics, log, aliasRegistry, isEmittedFile);
+            mod = analyzeModule(sourceFile, program, sourceOptions, diagnostics, log, aliasRegistry, isEmittedFile, fileExists);
         }
         if (!mod)
             continue;
@@ -435,7 +444,7 @@ export const analyzeCore = (inputs) => {
     // `mergeReExports` (their edges would back-link modules absent from
     // output) and out of the emitted set.
     const contextModules = contextSvelteFiles?.length
-        ? analyzeContextComponents(contextSvelteFiles, modules, inputs, aliasRegistry, isEmittedFile)
+        ? analyzeContextComponents(contextSvelteFiles, modules, inputs, aliasRegistry, isEmittedFile, fileExists)
         : [];
     // Phase 2a: build alsoExportedFrom arrays from the modules' forward edges
     const mergedModules = mergeReExports(modules);

package/dist/cli.d.ts

@@ -103,7 +103,8 @@ export interface CliOptions {
  * Run the CLI with the given arguments.
  *
  * @param argv - command line arguments (defaults to `process.argv`)
- * @returns exit code: 0 for success, 1 if errors in diagnostics, 2 for CLI errors or any
+ * @returns exit code: 0 for success (including `--help` and `--version`), 1 if errors in
+ *   diagnostics, 2 for CLI errors (an unknown flag, a missing or invalid option value) or any
  *   thrown analysis error (including an `--on-duplicates throw` collision)
  */
 export declare const runCli: (argv?: Array<string>) => Promise<number>;

package/dist/cli.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cli.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAQH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAwBhD;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAC1B;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,sFAAsF;IACtF,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;GAMG;AACH,eAAO,MAAM,MAAM,GAAU,OAAM,KAAK,CAAC,MAAM,CAAgB,KAAG,OAAO,CAAC,MAAM,CAsO/E,CAAC"}
+{"version":3,"file":"cli.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAQH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAwBhD;;GAEG;AACH,MAAM,WAAW,UAAU;IAC1B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,6CAA6C;IAC7C,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;;OAIG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B;;;;OAIG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,4EAA4E;IAC5E,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1B;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;IAC1B;;;;;;;OAOG;IACH,IAAI,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrB,sFAAsF;IACtF,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,8EAA8E;IAC9E,MAAM,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,MAAM,GAAU,OAAM,KAAK,CAAC,MAAM,CAAgB,KAAG,OAAO,CAAC,MAAM,CAmP/E,CAAC"}

package/dist/cli.js

@@ -17,7 +17,7 @@
  *
  * @module
  */
-import { Command } from 'commander';
+import { Command, CommanderError } from 'commander';
 import { writeFile, readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 import picomatch from 'picomatch';
@@ -42,7 +42,8 @@ const isDiscoveryFlag = (value) => DISCOVERY_VALUES.includes(value);
  * Run the CLI with the given arguments.
  *
  * @param argv - command line arguments (defaults to `process.argv`)
- * @returns exit code: 0 for success, 1 if errors in diagnostics, 2 for CLI errors or any
+ * @returns exit code: 0 for success (including `--help` and `--version`), 1 if errors in
+ *   diagnostics, 2 for CLI errors (an unknown flag, a missing or invalid option value) or any
  *   thrown analysis error (including an `--on-duplicates throw` collision)
  */
 export const runCli = async (argv = process.argv) => {
@@ -68,6 +69,11 @@ export const runCli = async (argv = process.argv) => {
         }
         throw new Error(`svelte-docinfo: failed to load package.json for version. Attempted: ${attempted.join(', ')}`);
     })();
+    // Commander exits 1 on its own parse errors; throw instead so they map to 2,
+    // keeping 1 for analysis errors. Its messages go through `console.error`
+    // like the CLI's own errors.
+    program.exitOverride();
+    program.configureOutput({ writeErr: (s) => console.error(s.trimEnd()) });
     program
         .name('svelte-docinfo')
         .description('Static analysis for TypeScript and Svelte source code')
@@ -83,7 +89,8 @@ export const runCli = async (argv = process.argv) => {
         .option('--no-resolve-dependencies', 'Disable dependency resolution')
         .option('--discovery <mode>', `Source file discovery strategy: ${DISCOVERY_VALUES.join('|')} ` +
         '(default: auto — exports first, glob fallback). ' +
-        '`exports` is strict and fails if package.json exports is missing or empty ' +
+        '`exports` is strict and fails if package.json exports is missing ' +
+        'or resolves to no files ' +
         '(also incompatible with --include).')
         .option('--dist-dir <dir>', 'Dist directory for exports discovery (default: dist)')
         .option('--source-dir <dir>', 'Source directory, relative to project root or absolute inside it ' +
@@ -112,8 +119,8 @@ Examples:
   $ svelte-docinfo --source-dir src               Non-SvelteKit project (src/ root)
   $ svelte-docinfo --source-dir src/lib --source-dir src/routes
                                                   Multiple source dirs (source-root auto-derived as 'src')
-  $ svelte-docinfo --source-dir src/lib --source-dir lib/utils --source-root .
-                                                  No common prefix — module paths stay project-relative
+  $ svelte-docinfo --source-dir src/lib --source-dir lib/utils
+                                                  No common prefix — module paths are project-relative
   $ svelte-docinfo --discovery glob               Skip package.json exports
   $ svelte-docinfo --discovery exports            Strict — fail if exports missing
   $ svelte-docinfo --tsconfig tsconfig.lib.json   Use a specific tsconfig
@@ -217,6 +224,14 @@ Examples:
             exitCode = 2;
         }
     });
-    await program.parseAsync(argv);
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (error) {
+        if (!(error instanceof CommanderError))
+            throw error;
+        // `--help` and `--version` throw with exit code 0
+        return error.exitCode === 0 ? 0 : 2;
+    }
     return exitCode;
 };

package/dist/declaration-build.d.ts

@@ -13,6 +13,7 @@
  * @module
  */
 import type { DeclarationKind, DeclarationModifier, GenericParamJson, MemberKind, ParameterJsonInput, OverloadJsonInput, ComponentPropJsonInput, Reactivity, ReExportJsonInput, ExternalReExportJsonInput, TypeJson } from './types.js';
+import type { TsdocParsedComment } from './tsdoc.js';
 /**
  * Permissive type for constructing members incrementally before schema validation.
  *
@@ -131,11 +132,12 @@ export interface DeclarationAnalysis {
  */
 export interface ModuleExportsAnalysis {
     /**
-     * Module-level documentation comment. Always `undefined` for svelte2tsx
-     * virtual files — `analyzeSvelteModule` extracts Svelte module comments
-     * from the original source instead.
+     * The parsed module-level comment, projected onto `ModuleJson` by
+     * `toModuleDocFields`. Always `undefined` for svelte2tsx virtual files —
+     * `analyzeSvelteModule` extracts Svelte module comments from the original
+     * source instead.
      */
-    moduleComment?: string;
+    moduleDoc?: TsdocParsedComment;
     /** All exported declarations with `@nodocs` flags — consumer filters based on policy. */
     declarations: Array<DeclarationAnalysis>;
     /**

package/dist/declaration-build.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"declaration-build.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/declaration-build.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EACX,eAAe,EACf,mBAAmB,EACnB,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,iBAAiB,EACjB,sBAAsB,EACtB,UAAU,EACV,iBAAiB,EACjB,yBAAyB,EACzB,QAAQ,EACR,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;GAUG;AACH,MAAM,WAAW,eAAe;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,UAAU,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;IACxC,UAAU,CAAC,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,QAAQ,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,iGAAiG;IACjG,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,mFAAmF;IACnF,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,8DAA8D;IAC9D,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACpC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,eAAe,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACvC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,QAAQ,CAAC;IAC1B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,aAAa,CAAC,EAAE,KAAK,CAAC,gBAAgB,CAAC,CAAC;IACxC,SAAS,CAAC,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACrC,QAAQ,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,MAAM,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACvD,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,aAAa,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC9B,UAAU,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3B,OAAO,CAAC,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;IACjC,KAAK,CAAC,EAAE,KAAK,CAAC,sBAAsB,CAAC,CAAC;IACtC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,gBAAgB,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACjC,OAAO,CAAC,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6FAA6F;IAC7F,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wFAAwF;IACxF,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,kFAAkF;IAClF,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IACnC,0DAA0D;IAC1D,WAAW,EAAE,oBAAoB,CAAC;IAClC,2FAA2F;IAC3F,MAAM,EAAE,OAAO,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,qBAAqB;IACrC;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,yFAAyF;IACzF,YAAY,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAC;IACzC;;;;;;OAMG;IACH,SAAS,EAAE,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACpC,2FAA2F;IAC3F,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC3B;;;OAGG;IACH,iBAAiB,EAAE,KAAK,CAAC,yBAAyB,CAAC,CAAC;IACpD,6EAA6E;IAC7E,mBAAmB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACnC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,cAAe,SAAQ,qBAAqB;IAC5D,2CAA2C;IAC3C,IAAI,EAAE,MAAM,CAAC;IACb,8EAA8E;IAC9E,YAAY,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAC5B,gFAAgF;IAChF,UAAU,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CAC1B"}
+{"version":3,"file":"declaration-build.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/declaration-build.ts"],"names":[],"mappings":"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"}