svelte-docinfo 0.5.4 → 0.6.0

package/dist/diagnostics.js

@@ -51,9 +51,14 @@
  * ## File Path Contract
  *
  * `Diagnostic.file` is always project-root-relative — no leading slash,
- * no `./` prefix. `analyze` / `analyzeFromFiles` normalize paths from all
- * sources (extraction, discovery, dependency resolution) before returning.
- * Consumers that need an absolute path can rejoin with `projectRoot`.
+ * 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`.
+ *
+ * It names a *file*, not a module: `ModuleJson.path` is relative to
+ * `sourceRoot`, so `file` is not a lookup key into `modules`.
  *
  * @module
  */
@@ -75,6 +80,7 @@ export const DiagnosticKind = z.enum([
     'signature_analysis_failed',
     'class_member_failed',
     'svelte_prop_failed',
+    'legacy_props',
     'module_skipped',
     'module_unreadable',
     'import_parse_failed',
@@ -85,6 +91,7 @@ export const DiagnosticKind = z.enum([
     'duplicate_declaration',
     'transform_failed',
     'resolver_failed',
+    'alias_lost'
 ]);
 // Variants
 /**
@@ -105,6 +112,21 @@ const baseDiagnosticFields = {
      * 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.
      */
     file: z.string(),
     /** Line number (1-based), absent if location unavailable. */
@@ -113,7 +135,7 @@ const baseDiagnosticFields = {
     column: z.number().int().positive().optional(),
     /** Human-readable description of the issue. */
     message: z.string(),
-    severity: DiagnosticSeverity,
+    severity: DiagnosticSeverity
 };
 /**
  * Type extraction failed (e.g., complex or recursive types).
@@ -122,7 +144,7 @@ export const TypeExtractionDiagnostic = z.strictObject({
     kind: z.literal('type_extraction_failed'),
     ...baseDiagnosticFields,
     /** Name of the symbol whose type couldn't be extracted. */
-    symbolName: z.string(),
+    symbolName: z.string()
 });
 /**
  * Function/method signature analysis failed.
@@ -131,7 +153,7 @@ export const SignatureAnalysisDiagnostic = z.strictObject({
     kind: z.literal('signature_analysis_failed'),
     ...baseDiagnosticFields,
     /** Name of the function or method. */
-    functionName: z.string(),
+    functionName: z.string()
 });
 /**
  * Class member analysis failed.
@@ -142,10 +164,17 @@ export const ClassMemberDiagnostic = z.strictObject({
     /** Name of the class. */
     className: z.string(),
     /** Name of the member that failed. */
-    memberName: z.string(),
+    memberName: z.string()
 });
 /**
  * Svelte prop type resolution failed.
+ *
+ * `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.
  */
 export const SveltePropDiagnostic = z.strictObject({
     kind: z.literal('svelte_prop_failed'),
@@ -153,7 +182,25 @@ export const SveltePropDiagnostic = z.strictObject({
     /** Name of the component. */
     componentName: z.string(),
     /** Name of the prop. */
-    propName: z.string(),
+    propName: z.string()
+});
+/**
+ * Legacy (runes-less) component props detected — not extracted.
+ *
+ * `export let` components are still-legal Svelte 5 syntax, but prop extraction
+ * anchors on the `$props()` declaration, so their props yield no
+ * `ComponentPropJson` entries. Emitted once per component, listing the
+ * detected prop names — exported `let`/`var` statements plus export-clause
+ * renames of mutable bindings (`export {a as b}`) — with `line` pointing at
+ * the first legacy prop export in the original `.svelte` source.
+ */
+export const LegacyPropsDiagnostic = z.strictObject({
+    kind: z.literal('legacy_props'),
+    ...baseDiagnosticFields,
+    /** Name of the component. */
+    componentName: z.string(),
+    /** Exported prop names, in source order. */
+    propNames: z.array(z.string()).min(1)
 });
 /**
  * Module was skipped during the analysis pass.
@@ -173,7 +220,7 @@ export const ModuleSkippedDiagnostic = z.strictObject({
     kind: z.literal('module_skipped'),
     ...baseDiagnosticFields,
     /** Reason the module was skipped. */
-    reason: z.enum(['not_in_program', 'no_analyzer', 'requires_program']),
+    reason: z.enum(['not_in_program', 'no_analyzer', 'requires_program'])
 });
 /**
  * File discovered via package.json `exports` exists but couldn't be read.
@@ -185,14 +232,14 @@ export const ModuleSkippedDiagnostic = z.strictObject({
  */
 export const ModuleUnreadableDiagnostic = z.strictObject({
     kind: z.literal('module_unreadable'),
-    ...baseDiagnosticFields,
+    ...baseDiagnosticFields
 });
 /**
  * Import parsing failed during dependency resolution.
  */
 export const ImportParseDiagnostic = z.strictObject({
     kind: z.literal('import_parse_failed'),
-    ...baseDiagnosticFields,
+    ...baseDiagnosticFields
 });
 /**
  * Duplicate comment sources detected (e.g., both HTML and JSDoc `@module`,
@@ -202,7 +249,7 @@ export const DuplicateCommentDiagnostic = z.strictObject({
     kind: z.literal('duplicate_comment'),
     ...baseDiagnosticFields,
     /** Which comment type is duplicated. */
-    commentType: z.enum(['module_comment', 'doc_comment']),
+    commentType: z.enum(['module_comment', 'doc_comment'])
 });
 /**
  * A JSDoc tag found somewhere it has no effect.
@@ -210,8 +257,9 @@ export const DuplicateCommentDiagnostic = z.strictObject({
  * Two contexts emit this:
  *
  * - **Non-primary overload signature** — symbol-scope tags (`@example`,
- *   `@deprecated`, `@since`, `@see`, `@throws`, `@mutates`, `@default`,
- *   `@nodocs`) describe the function as a whole, not individual signatures.
+ *   `@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
@@ -230,18 +278,20 @@ export const MisplacedTagDiagnostic = z.strictObject({
     tagName: z.enum([
         'example',
         'deprecated',
+        'internal',
         'since',
         'see',
         'throws',
         'mutates',
         'default',
-        'nodocs',
+        'nodocs'
     ]),
     /**
-     * Name of the function or method whose overload carries the misplaced tag.
-     * Absent for module-comment misplacements (no enclosing symbol).
+     * Name of the enclosing symbol: the function or method whose overload
+     * carries the misplaced tag. Absent for module-comment misplacements (no
+     * enclosing symbol).
      */
-    functionName: z.string().optional(),
+    functionName: z.string().optional()
 });
 /**
  * `@param` tag references a name that doesn't match any actual parameter.
@@ -255,7 +305,7 @@ export const UnknownParamDiagnostic = z.strictObject({
     /** The `@param` key that didn't match a real parameter. */
     paramName: z.string(),
     /** Name of the function or method. */
-    functionName: z.string(),
+    functionName: z.string()
 });
 /**
  * A declaration `name` appears in more than one module.
@@ -271,16 +321,25 @@ export const DuplicateDeclarationDiagnostic = z.strictObject({
     ...baseDiagnosticFields,
     /** The duplicated declaration name. */
     declarationName: z.string(),
-    /** Module paths where the name was defined (>= 2). */
-    modules: z.array(z.string()).min(2),
+    /**
+     * 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.
+     */
+    modules: z.array(z.string()).min(2)
 });
 /**
  * Source map parsing failed for a Svelte virtual file.
  *
- * Analysis continues using virtual-file positions, so downstream `line`/`column`
- * fields on other diagnostics may point into the svelte2tsx-generated TS rather
- * than the original `.svelte` source. Rare; usually signals a malformed or
- * incompatible svelte2tsx output.
+ * 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
+ * `sourceLine`s 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
@@ -288,7 +347,7 @@ export const DuplicateDeclarationDiagnostic = z.strictObject({
  */
 export const SourceMapFailedDiagnostic = z.strictObject({
     kind: z.literal('source_map_failed'),
-    ...baseDiagnosticFields,
+    ...baseDiagnosticFields
 });
 /**
  * svelte2tsx transform threw for a `.svelte` file.
@@ -301,7 +360,7 @@ export const SourceMapFailedDiagnostic = z.strictObject({
  */
 export const TransformFailedDiagnostic = z.strictObject({
     kind: z.literal('transform_failed'),
-    ...baseDiagnosticFields,
+    ...baseDiagnosticFields
 });
 /**
  * Import resolver threw while resolving a specifier.
@@ -318,7 +377,30 @@ export const ResolverFailedDiagnostic = z.strictObject({
     kind: z.literal('resolver_failed'),
     ...baseDiagnosticFields,
     /** The import specifier the resolver failed on. */
-    specifier: z.string(),
+    specifier: z.string()
+});
+/**
+ * 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.
+ *
+ * Always `warning`, query-time category (recomputed each `query()`).
+ */
+export const AliasLostDiagnostic = z.strictObject({
+    kind: z.literal('alias_lost'),
+    ...baseDiagnosticFields,
+    /** Name of the alias whose right-hand side resolves to a nameless type. */
+    aliasName: z.string()
 });
 /**
  * Discriminated union of all diagnostic variants.
@@ -328,6 +410,7 @@ export const Diagnostic = z.discriminatedUnion('kind', [
     SignatureAnalysisDiagnostic,
     ClassMemberDiagnostic,
     SveltePropDiagnostic,
+    LegacyPropsDiagnostic,
     ModuleSkippedDiagnostic,
     ModuleUnreadableDiagnostic,
     ImportParseDiagnostic,
@@ -338,6 +421,7 @@ export const Diagnostic = z.discriminatedUnion('kind', [
     DuplicateDeclarationDiagnostic,
     TransformFailedDiagnostic,
     ResolverFailedDiagnostic,
+    AliasLostDiagnostic
 ]);
 // Helpers
 /**

package/dist/discovery.d.ts

@@ -45,7 +45,9 @@ export interface DiscoverSourceFilesOptions {
      */
     sourceOptions: ModuleSourceOptions;
     /**
-     * Glob patterns to include (relative to `projectRoot`).
+     * Glob patterns to include (relative to `projectRoot`; an absolute pattern
+     * inside the root relativizes, an out-of-root one throws — see
+     * `normalizeIncludePatterns`).
      *
      * Filter for glob-based discovery. When `discovery` is `'auto'` (default),
      * providing `include` collapses the chain to glob immediately. Combining
@@ -97,7 +99,10 @@ export interface DiscoverSourceFilesResult {
  * - `'glob'` — glob only; `include` parameterizes the search.
  *
  * Exclusion globs come from `sourceOptions.exclude` (the single source of
- * truth, also applied at analysis time by `isSource()`).
+ * truth, also applied at analysis time by `isSource()`). Beneath it, the
+ * always-on baseline (`node_modules` + dot-directories, see
+ * `hasBaselineExcludedSegment` in `source-config.ts`) applies at both stages
+ * and is not affected by `exclude` overrides.
  *
  * @param options - discovery configuration
  * @returns discovered files (content loaded) and any diagnostics from the exports step

package/dist/discovery.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"discovery.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAChD,OAAO,EAAC,KAAK,mBAAmB,EAAgB,MAAM,oBAAoB,CAAC;AAC3E,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AACjD,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,UAAU,CAAC;AAI1C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;AAEpD,yCAAyC;AACzC,MAAM,WAAW,0BAA0B;IAC1C;;;;;;;;;OASG;IACH,aAAa,EAAE,mBAAmB,CAAC;IAEnC;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAExB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,2CAA2C;IAC3C,GAAG,CAAC,EAAE,WAAW,CAAC;CAClB;AAED,uCAAuC;AACvC,MAAM,WAAW,yBAAyB;IACzC,2DAA2D;IAC3D,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IAC7B,qFAAqF;IACrF,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,mBAAmB,GAC/B,SAAS,0BAA0B,KACjC,OAAO,CAAC,yBAAyB,CAgGnC,CAAC"}
+{"version":3,"file":"discovery.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/discovery.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EACN,KAAK,mBAAmB,EAGxB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAI5C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;AAEpD,yCAAyC;AACzC,MAAM,WAAW,0BAA0B;IAC1C;;;;;;;;;OASG;IACH,aAAa,EAAE,mBAAmB,CAAC;IAEnC;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAExB;;;;;OAKG;IACH,SAAS,CAAC,EAAE,SAAS,CAAC;IAEtB;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB,2CAA2C;IAC3C,GAAG,CAAC,EAAE,WAAW,CAAC;CAClB;AAED,uCAAuC;AACvC,MAAM,WAAW,yBAAyB;IACzC,2DAA2D;IAC3D,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,CAAC;IAC7B,qFAAqF;IACrF,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,mBAAmB,GAC/B,SAAS,0BAA0B,KACjC,OAAO,CAAC,yBAAyB,CAmGnC,CAAC"}

package/dist/discovery.js

@@ -10,7 +10,7 @@
  *
  * @module
  */
-import { getSourceRoot } from './source-config.js';
+import { getSourceRoot, normalizeIncludePatterns } from './source-config.js';
 import { globFiles, deriveIncludePatterns } from './files.js';
 import { discoverFromExports } from './exports.js';
 /**
@@ -28,7 +28,10 @@ import { discoverFromExports } from './exports.js';
  * - `'glob'` — glob only; `include` parameterizes the search.
  *
  * Exclusion globs come from `sourceOptions.exclude` (the single source of
- * truth, also applied at analysis time by `isSource()`).
+ * truth, also applied at analysis time by `isSource()`). Beneath it, the
+ * always-on baseline (`node_modules` + dot-directories, see
+ * `hasBaselineExcludedSegment` in `source-config.ts`) applies at both stages
+ * and is not affected by `exclude` overrides.
  *
  * @param options - discovery configuration
  * @returns discovered files (content loaded) and any diagnostics from the exports step
@@ -43,8 +46,11 @@ import { discoverFromExports } from './exports.js';
  * ```
  */
 export const discoverSourceFiles = async (options) => {
-    const { sourceOptions, include, discovery = 'auto', distDir, log } = options;
+    const { sourceOptions, discovery = 'auto', distDir, log } = options;
     const { projectRoot, exclude } = sourceOptions;
+    // In-root absolute patterns relativize (out-of-root throws) so the glob
+    // and its anchored baseline ignores see projectRoot-relative patterns.
+    const include = options.include && normalizeIncludePatterns(options.include, projectRoot);
     // Reject contradictory configurations early. `include` parameterizes glob,
     // so combining it with strict `'exports'` is a user error rather than a
     // silent override.
@@ -84,7 +90,7 @@ export const discoverSourceFiles = async (options) => {
                 projectRoot,
                 exclude,
                 sourceDir,
-                distDir,
+                distDir
             });
             const { files: exportsFiles, diagnostics: exportsDiagnostics } = exportsResult;
             diagnostics = exportsDiagnostics;
@@ -118,7 +124,7 @@ export const discoverSourceFiles = async (options) => {
         files = await globFiles({
             projectRoot,
             include: include ?? deriveIncludePatterns(sourceOptions.sourcePaths),
-            exclude,
+            exclude
         });
         log?.info(`Discovered ${files.length} source files via glob`);
     }

package/dist/exports.d.ts

@@ -57,6 +57,20 @@ export interface ExportsDiscoveryResult {
 export interface ParsedExports {
     /** All parsed export entries. */
     entries: Array<ExportEntry>;
+    /**
+     * Specifiers (exact or wildcard patterns) whose export target resolves
+     * nothing — a literal `null`, or a conditions object with no usable
+     * target. Node's explicit-exclusion form: `"./internal/*": null` blocks
+     * the subpaths a broader wildcard would otherwise expose. Discovery
+     * honors these with Node's best-match semantics: a subpath whose
+     * most-specific matching key is blocked is not exported, so its source
+     * file is not discovered.
+     *
+     * Interpret via `createBlockedSpecifierChecker` — a naive membership
+     * check (`blocked.includes(specifier)`) is wrong for wildcard keys and
+     * ignores the positive keys that can out-match a blocked one.
+     */
+    blocked: Array<string>;
     /** Whether the package.json had an exports field. */
     hasExports: boolean;
 }
@@ -64,12 +78,28 @@ export interface ParsedExports {
  * Read and parse the exports field from package.json.
  *
  * Handles all Node.js export formats: strings, objects with conditions,
- * nested conditions, null exclusions, and wildcard patterns.
+ * nested conditions, fallback arrays (first usable element), null exclusions
+ * (surfaced on `blocked` for best-match blocking during discovery), and
+ * wildcard patterns.
  *
  * @param projectRoot - absolute path to project root
- * @returns parsed `ParsedExports`, or `{entries: [], hasExports: false}` if no exports field
+ * @returns parsed `ParsedExports`, or `{entries: [], blocked: [], hasExports: false}` if no exports field
  */
 export declare const parsePackageExports: (projectRoot: string) => Promise<ParsedExports>;
+/**
+ * Build a predicate deciding whether an export specifier is blocked, per
+ * Node's resolution semantics: an exact (starless) key wins outright, else
+ * the best-matching wildcard key (`comparePatternKeys`) decides — and when
+ * that winner's target is `null`, the subpath is not exported.
+ *
+ * Blocking is only observable when blocked keys exist, so this returns
+ * `null` for the common no-blocked-keys case and callers skip specifier
+ * computation entirely.
+ *
+ * Exported for consumers reading `ParsedExports.blocked` directly — this is
+ * the one implementation of the interpretation rule.
+ */
+export declare const createBlockedSpecifierChecker: (parsed: ParsedExports) => ((specifier: string) => boolean) | null;
 /**
  * Map a dist file path to its source file path.
  *
@@ -98,6 +128,13 @@ export declare const mapDistToSource: (distPath: string, condition: string, opti
  * For concrete exports, maps directly to source paths and verifies existence.
  * For wildcard exports, globs the source directory for matching files.
  *
+ * Null-target keys are honored with Node's resolution semantics: a subpath
+ * whose most-specific matching key is `null` is not exported, so its file is
+ * not discovered — `"./internal/*": null` beside the usual `"./*.js"`
+ * wildcards keeps `src/lib/internal/` out of discovery exactly as it keeps
+ * the subpaths unresolvable for consumers (the `src/lib/internal/`
+ * convention's exports half).
+ *
  * @param options - discovery configuration
  * @returns `ExportsDiscoveryResult` with discovered files and any error diagnostics
  */

package/dist/exports.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exports.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/exports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAChD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAOjD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,SAAS,EAAE,OAAO,CAAC;IACnB,2GAA2G;IAC3G,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACtC;;;;OAIG;IACH,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC;IACpC,oEAAoE;IACpE,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,iCAAiC;IACjC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IAC5B,qDAAqD;IACrD,UAAU,EAAE,OAAO,CAAC;CACpB;AASD;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,aAAa,CA+BpF,CAAC;AAoCF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAC3B,UAAU,MAAM,EAChB,WAAW,MAAM,EACjB,SAAS;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,KAC3C,MAAM,GAAG,IAwCX,CAAC;AAkBF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,mBAAmB,GAC/B,SAAS,uBAAuB,KAC9B,OAAO,CAAC,sBAAsB,CA0DhC,CAAC"}
+{"version":3,"file":"exports.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/exports.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAOH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAQnD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,uDAAuD;IACvD,SAAS,EAAE,OAAO,CAAC;IACnB,2GAA2G;IAC3G,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC,qCAAqC;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,OAAO,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACxB;AAED;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACtC;;;;OAIG;IACH,KAAK,EAAE,KAAK,CAAC,cAAc,CAAC,GAAG,IAAI,CAAC;IACpC,oEAAoE;IACpE,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,iCAAiC;IACjC,OAAO,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC;IAC5B;;;;;;;;;;;;OAYG;IACH,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACvB,qDAAqD;IACrD,UAAU,EAAE,OAAO,CAAC;CACpB;AASD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAU,aAAa,MAAM,KAAG,OAAO,CAAC,aAAa,CA+CpF,CAAC;AAuFF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,6BAA6B,GACzC,QAAQ,aAAa,KACnB,CAAC,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,CAAC,GAAG,IA+BrC,CAAC;AAIF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,GAC3B,UAAU,MAAM,EAChB,WAAW,MAAM,EACjB,SAAS;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,KAC7C,MAAM,GAAG,IAwCX,CAAC;AAqCF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,mBAAmB,GAC/B,SAAS,uBAAuB,KAC9B,OAAO,CAAC,sBAAsB,CAgEhC,CAAC"}