svelte-docinfo 0.4.1 → 0.5.0

package/README.md

@@ -5,17 +5,17 @@
 > static analysis for TypeScript and Svelte 📜
 > [**svelte-docinfo.fuz.dev**](https://svelte-docinfo.fuz.dev/)
 
-**svelte-docinfo** extracts JSON describing the exports
+svelte-docinfo extracts JSON describing the exports
 of TypeScript and Svelte modules for open-ended use cases
 like docs, code search, and dev tools.
 It uses
 [svelte2tsx](https://github.com/sveltejs/language-tools/tree/master/packages/svelte2tsx)
-and the TypeScript compiler API to resolve types, track exports, and extract semantic details.
+and the TypeScript compiler API to resolve types, track exports+imports, and extract semantic details.
 It includes a Vite plugin, CLI, and programmatic API
 in the [npm package](https://www.npmjs.com/package/svelte-docinfo).
 
 ```bash
-npm install svelte-docinfo -D
+npm i -D svelte-docinfo
 ```
 
 - [Quick start](#quick-start)
@@ -27,11 +27,6 @@ npm install svelte-docinfo -D
 - [Credits](#credits)
 - [License](#license)
 
-Dependencies are minimal and the tool's scope is limited to data, not presentation.
-The [docs website](https://svelte-docinfo.fuz.dev/docs/api)
-for svelte-docinfo is made using itself
-and [fuz_ui](https://github.com/fuzdev/fuz_ui) components.
-
 svelte-docinfo is largely inspired by [`sveld`](https://github.com/carbon-design-system/sveld),
 but instead of AST-only inspection it uses the TypeScript compiler API for richer information,
 and also analyzes TypeScript modules.
@@ -42,6 +37,11 @@ but you may find gaps and flaws -- please open issues for bugs
 and [discussions](https://github.com/fuzdev/svelte-docinfo/discussions)
 for everything else!
 
+Dependencies are minimal and the tool's scope is limited to data, not presentation.
+The [docs website](https://svelte-docinfo.fuz.dev/docs/api)
+for svelte-docinfo is made using itself
+and [fuz_ui](https://github.com/fuzdev/fuz_ui) components.
+
 **AI disclosure:** the code and docs beyond the intro
 were mostly written by Claude Code with uneven human guidance.
 The first release took 5 months of intermittent work and ~500 manual commits.
@@ -174,7 +174,11 @@ All three produce the same JSON shape:
 }
 ```
 
-For many more worked examples — source input paired with the exact JSON `svelte-docinfo` emits — browse the [test fixtures](https://github.com/fuzdev/svelte-docinfo/tree/main/src/test/fixtures), where each case sits beside its `expected.json`.
+For examples of source input paired with the exact JSON `svelte-docinfo` emits:
+
+- see svelte-docinfo's own source code's extracted JSON at
+  [svelte-docinfo.fuz.dev/demo/extraction](https://svelte-docinfo.fuz.dev/demo/extraction)
+- browse the [test fixtures](https://github.com/fuzdev/svelte-docinfo/tree/main/src/test/fixtures)
 
 ## Vite plugin
 
@@ -314,14 +318,19 @@ See the [API docs](https://svelte-docinfo.fuz.dev/docs/api) for the full referen
 - **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, `aliasOf` for renames, `starExports` for `export * from './x'`
+- **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
 
-Known gaps: standalone `namespace Foo {}` declarations and decorators are not yet supported. Svelte 4 legacy features (slots, events, context, `$restProps`) are out of scope — Svelte 5 snippets and callback props replace most of them.
-[Issues](https://github.com/fuzdev/svelte-docinfo/issues) and
+Known gaps:
+
+- context tracking (transitive detection of common patterns seems tractable)
+- standalone `namespace Foo {}` declarations and decorators are not yet supported
+- Svelte 4 legacy features (slots, events, `$restProps`) are out of scope — Svelte 5 snippets and callback props replace most of them
+
+[Issues](https://github.com/fuzdev/svelte-docinfo/issues) for bugs and
 [discussions](https://github.com/fuzdev/svelte-docinfo/discussions) are welcome!
 
 ## Documentation

package/dist/analyze-core.d.ts

@@ -28,7 +28,6 @@
 import ts from 'typescript';
 import { z } from 'zod';
 import { ModuleJson, type ModuleJsonInput } from './types.js';
-import type { ReExportInfo } from './declaration-build.js';
 import { Diagnostic } from './diagnostics.js';
 import type { AnalysisLog } from './log.js';
 import { type SvelteVirtualFile } from './svelte.js';
@@ -1145,6 +1144,20 @@ export declare const AnalyzeResultJson: z.ZodObject<{
         dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
         dependents: z.ZodDefault<z.ZodArray<z.ZodString>>;
         starExports: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        reExports: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            module: z.ZodString;
+            typeOnly: z.ZodDefault<z.ZodBoolean>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        externalReExports: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            specifier: z.ZodString;
+            originalName: z.ZodOptional<z.ZodString>;
+            typeOnly: z.ZodDefault<z.ZodBoolean>;
+            sourceLine: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>>;
+        externalStarExports: z.ZodDefault<z.ZodArray<z.ZodString>>;
         partial: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strict>>>;
     diagnostics: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -1347,16 +1360,6 @@ export interface AnalyzeResultJsonWire {
     modules: Array<ModuleJsonInput>;
     diagnostics: Array<Diagnostic>;
 }
-/**
- * Result of analyzing a single module.
- *
- * `alsoExportedFrom` on declarations is always empty from this path —
- * cross-module re-export resolution requires all modules.
- */
-export interface ModuleAnalyzeResult {
-    module: ModuleJson;
-    reExports: Array<ReExportInfo>;
-}
 /**
  * Analyze a single non-Svelte source file and extract module metadata.
  *
@@ -1373,10 +1376,14 @@ export interface ModuleAnalyzeResult {
  *
  * Returns `undefined` when the file is skipped; the diagnostic is added to
  * `diagnostics` so the caller can keep iterating.
+ *
+ * `alsoExportedFrom` on returned declarations is always empty from this path —
+ * cross-module re-export resolution requires all modules (`mergeReExports`
+ * consumes the returned module's `reExports` in phase 2).
  */
 export declare const analyzeModule: (sourceFile: SourceFileInfo & {
     dependents?: ReadonlyArray<string>;
-}, program: ts.Program, options: ModuleSourceOptions, diagnostics: Array<Diagnostic>, log?: AnalysisLog) => ModuleAnalyzeResult | undefined;
+}, program: ts.Program, options: ModuleSourceOptions, diagnostics: Array<Diagnostic>, log?: AnalysisLog) => ModuleJson | undefined;
 /**
  * Inputs to `analyzeCore`. The caller (one-shot wrapper or session.query)
  * is responsible for normalizing `sourceOptions`, obtaining the program,

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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAAC,CAAC,EAAC,MAAM,KAAK,CAAC;AAEtB,OAAO,EAAC,UAAU,EAAE,KAAK,eAAe,EAAC,MAAM,YAAY,CAAC;AAE5D,OAAO,EAAC,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAC5C,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,UAAU,CAAC;AAE1C,OAAO,EAAsB,KAAK,iBAAiB,EAAC,MAAM,aAAa,CAAC;AACxE,OAAO,EAAqB,KAAK,cAAc,EAAmB,MAAM,aAAa,CAAC;AACtF,OAAO,EAAC,KAAK,mBAAmB,EAAmC,MAAM,oBAAoB,CAAC;AAE9F,OAAO,EAMN,KAAK,oBAAoB,EACzB,MAAM,kBAAkB,CAAC;AAI1B;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,GAAG,CAClC,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAAC,EACpD,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,KAC3B,IAAI,CAAC;AAEV;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,oBAAoB,CAAC;AAEnE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,oBAG/B,CAAC;AA8DF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAG5B,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,qBAAqB;IACrC,OAAO,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;IAChC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AA8CD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,GACzB,YAAY,cAAc,GAAG;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAC,EACjE,SAAS,EAAE,CAAC,OAAO,EACnB,SAAS,mBAAmB,EAC5B,aAAa,KAAK,CAAC,UAAU,CAAC,EAC9B,MAAM,WAAW,KACf,UAAU,GAAG,SAgEf,CAAC;AAIF;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,iBAAiB;IACjC,WAAW,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAC3C,aAAa,EAAE,mBAAmB,CAAC;IACnC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC;IACpB,kBAAkB,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IAC3D,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IACzC,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,GAAG,CAAC,EAAE,WAAW,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,iBAAiB,KAAG,iBA4FvD,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,wBAAwB,GACpC,aAAa,KAAK,CAAC,UAAU,CAAC,EAC9B,aAAa,MAAM,KACjB,IAgBF,CAAC"}

package/dist/analyze-core.js

@@ -34,7 +34,7 @@ import { analyzeSvelteModule } from './svelte.js';
 import { stripVirtualSuffix, getComponentName } from './source.js';
 import { extractPath, extractDependencies } from './source-config.js';
 import { toPosixPath } from './paths.js';
-import { sortModules, findDuplicates, mergeReExports, resolveComponentAliases, } from './postprocess.js';
+import { sortModules, findDuplicates, mergeReExports, resolveComponentAliases, compareStrings, } from './postprocess.js';
 /**
  * Convenience `OnDuplicatesCallback` that throws on any duplicate.
  *
@@ -121,17 +121,38 @@ export const AnalyzeResultJson = z.strictObject({
     modules: z.array(ModuleJson).default([]),
     diagnostics: z.array(Diagnostic).default([]),
 });
-const toModuleAnalyzeResult = (raw) => {
+const toModuleJson = (raw) => {
     const filtered = raw.declarations.filter((d) => !d.nodocs).map((d) => d.declaration);
-    const module = ModuleJson.parse({
+    // sorted for deterministic, environment-independent output —
+    // getExportsOfModule order is a TS implementation detail. Module tie-break
+    // because names can collide: a Svelte default-slot re-export re-keys to
+    // the component name, which a same-name re-export from another module may
+    // also use. The same re-keying can produce exact-duplicate edges
+    // (component + same-name script-module export from one file) — deduped on
+    // `(name, module)` so those pairs stay unique; the sourceLine tie-break
+    // makes the dedup deterministic (smallest line survives)
+    const reExports = raw.reExports
+        .slice()
+        .sort((a, b) => compareStrings(a.name, b.name) ||
+        compareStrings(a.module, b.module) ||
+        (a.sourceLine ?? 0) - (b.sourceLine ?? 0))
+        .filter((r, i, arr) => i === 0 || r.name !== arr[i - 1].name || r.module !== arr[i - 1].module);
+    const externalReExports = raw.externalReExports
+        .slice()
+        .sort((a, b) => compareStrings(a.name, b.name) ||
+        compareStrings(a.specifier, b.specifier) ||
+        (a.sourceLine ?? 0) - (b.sourceLine ?? 0));
+    return ModuleJson.parse({
         path: raw.path,
         declarations: filtered,
         dependencies: raw.dependencies,
         dependents: raw.dependents,
         starExports: raw.starExports,
+        reExports,
+        externalReExports,
+        externalStarExports: raw.externalStarExports,
         ...(raw.moduleComment ? { moduleComment: raw.moduleComment } : {}),
     });
-    return { module, reExports: raw.reExports };
 };
 // ── Module dispatch ──────────────────────────────────────────────────────────
 /**
@@ -150,6 +171,10 @@ const toModuleAnalyzeResult = (raw) => {
  *
  * Returns `undefined` when the file is skipped; the diagnostic is added to
  * `diagnostics` so the caller can keep iterating.
+ *
+ * `alsoExportedFrom` on returned declarations is always empty from this path —
+ * cross-module re-export resolution requires all modules (`mergeReExports`
+ * consumes the returned module's `reExports` in phase 2).
  */
 export const analyzeModule = (sourceFile, program, options, diagnostics, log) => {
     const checker = program.getTypeChecker();
@@ -191,6 +216,8 @@ export const analyzeModule = (sourceFile, program, options, diagnostics, log) =>
             dependents,
             starExports: [],
             reExports: [],
+            externalReExports: [],
+            externalStarExports: [],
         };
     }
     else {
@@ -204,7 +231,7 @@ export const analyzeModule = (sourceFile, program, options, diagnostics, log) =>
         log?.warn(`No analyzer for file: ${sourceFile.id}`);
         return undefined;
     }
-    return toModuleAnalyzeResult(raw);
+    return toModuleJson(raw);
 };
 /**
  * Run the two-phase analysis loop on pre-prepared inputs.
@@ -228,8 +255,7 @@ export const analyzeCore = (inputs) => {
     const checker = program.getTypeChecker();
     const diagnostics = [];
     const modules = [];
-    const collectedReExports = [];
-    // Phase 1: analyze every module, collect re-exports
+    // Phase 1: analyze every module (forward re-export edges land on `ModuleJson.reExports`)
     for (const sourceFile of sourceFiles) {
         // Failed-transform Svelte file: synthesize placeholder ModuleJson so
         // the modules array reflects the full owned set. The originating
@@ -250,30 +276,27 @@ export const analyzeCore = (inputs) => {
             log?.warn(`Svelte component ${componentName} marked partial (transform failed at ingest)`);
             continue;
         }
-        let result;
+        let mod;
         const virtualFile = svelteVirtualFiles.get(sourceFile.id);
         if (virtualFile) {
             const modulePath = extractPath(sourceFile.id, sourceOptions);
             const raw = analyzeSvelteModule(sourceFile, modulePath, checker, sourceOptions, diagnostics, program, virtualFile);
             if (raw) {
-                result = toModuleAnalyzeResult(raw);
+                mod = toModuleJson(raw);
             }
             else {
                 log?.error(`Svelte module analysis failed: ${sourceFile.id}`);
             }
         }
         else {
-            result = analyzeModule(sourceFile, program, sourceOptions, diagnostics, log);
+            mod = analyzeModule(sourceFile, program, sourceOptions, diagnostics, log);
         }
-        if (!result)
+        if (!mod)
             continue;
-        modules.push(result.module);
-        for (const reExport of result.reExports) {
-            collectedReExports.push({ reExportingModule: result.module.path, reExport });
-        }
+        modules.push(mod);
     }
-    // Phase 2a: build alsoExportedFrom arrays
-    mergeReExports(modules, collectedReExports);
+    // Phase 2a: build alsoExportedFrom arrays from the modules' forward edges
+    mergeReExports(modules);
     // Phase 2b: fill component-only fields on renamed component aliases —
     // canonical components are only fully populated after phase 1 finishes.
     resolveComponentAliases(modules);

package/dist/declaration-build.d.ts

@@ -13,23 +13,7 @@
  * @module
  */
 import { z } from 'zod';
-import type { DeclarationKind, DeclarationModifier, GenericParamJson, MemberKind, ParameterJson, OverloadJsonInput, ComponentPropJsonInput, Reactivity } from './types.js';
-/**
- * Information about a same-name re-export.
- *
- * Collected during phase 1 of analysis and passed to `mergeReExports`
- * in phase 2 to build `alsoExportedFrom` arrays on canonical declarations.
- */
-export interface ReExportInfo {
-    /**
-     * Name of the re-exported declaration. `'default'` for default-slot
-     * re-exports (`export {default} from './x'`) — that's the canonical's
-     * actual symbol name in the original module.
-     */
-    name: string;
-    /** Module path (relative to `sourceRoot`) where the declaration is originally declared. */
-    originalModule: string;
-}
+import type { DeclarationKind, DeclarationModifier, GenericParamJson, MemberKind, ParameterJson, OverloadJsonInput, ComponentPropJsonInput, Reactivity, ReExportJsonInput, ExternalReExportJsonInput } from './types.js';
 /**
  * Permissive type for constructing members incrementally before Zod validation.
  *
@@ -141,10 +125,23 @@ export interface ModuleExportsAnalysis {
     moduleComment?: string;
     /** All exported declarations with `@nodocs` flags — consumer filters based on policy. */
     declarations: Array<DeclarationAnalysis>;
-    /** Same-name re-exports (for building `alsoExportedFrom` in post-processing). */
-    reExports: Array<ReExportInfo>;
+    /**
+     * Same-name re-exports. Published as `ModuleJson.reExports` and consumed
+     * by `mergeReExports` in phase 2 to build `alsoExportedFrom` arrays on
+     * canonical declarations. Unsorted here and may contain exact duplicates
+     * (Svelte default-slot re-keying) — ordering and dedup are applied at
+     * publication in `analyze-core.ts`.
+     */
+    reExports: Array<ReExportJsonInput>;
     /** Star exports (`export * from './module'`) — module paths that are fully re-exported. */
     starExports: Array<string>;
+    /**
+     * Direct re-exports from external packages. Published as
+     * `ModuleJson.externalReExports`; unsorted here, sorted at publication.
+     */
+    externalReExports: Array<ExternalReExportJsonInput>;
+    /** External star exports (`export * from 'pkg'`) — specifiers as written. */
+    externalStarExports: Array<string>;
 }
 /**
  * Result of analyzing a module (TypeScript or Svelte).

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

package/dist/index.d.ts

@@ -17,13 +17,13 @@ export { createAnalysisSession } from './session.js';
 export type { AnalysisSession, AnalysisSessionOptions, SetFileOptions, SetFileResult, SetFilesResult, QueryOptions, } from './session.js';
 export { normalizeResolveImport } from './dep-resolver.js';
 export type { ImportResolver, ResolveImport, ResolveImportFn } from './dep-resolver.js';
-export { DeclarationKind, DeclarationModifier, MemberKind, Reactivity, GenericParamJson, ParameterJson, ComponentPropJson, OverloadJson, FunctionMemberJson, VariableMemberJson, ConstructorMemberJson, MemberJson, FunctionDeclarationJson, ClassDeclarationJson, InterfaceDeclarationJson, TypeDeclarationJson, VariableDeclarationJson, EnumDeclarationJson, ComponentDeclarationJson, SnippetDeclarationJson, NamespaceDeclarationJson, DeclarationJson, ModuleJson, } from './types.js';
+export { DeclarationKind, DeclarationModifier, MemberKind, Reactivity, GenericParamJson, ParameterJson, ComponentPropJson, OverloadJson, FunctionMemberJson, VariableMemberJson, ConstructorMemberJson, MemberJson, FunctionDeclarationJson, ClassDeclarationJson, InterfaceDeclarationJson, TypeDeclarationJson, VariableDeclarationJson, EnumDeclarationJson, ComponentDeclarationJson, SnippetDeclarationJson, NamespaceDeclarationJson, DeclarationJson, ReExportJson, ExternalReExportJson, ModuleJson, } from './types.js';
 export { getDisplayName, generateImport, compactReplacer, isKind, findTypeReferences, buildTypeReferencePatterns, } from './declaration-helpers.js';
 export type { SourceFileInfo, AnalyzerType } from './source.js';
 export { createSourceOptions, DEFAULT_SOURCE_OPTIONS } from './source-config.js';
 export type { ModuleSourceOptions, SourceOptionsDefaults } from './source-config.js';
-export { findDuplicates, mergeReExports, resolveComponentAliases } from './postprocess.js';
-export type { DuplicateDeclaration, ReExportEntry } from './postprocess.js';
+export { findDuplicates, mergeReExports, resolveComponentAliases, resolveExportSurface, } from './postprocess.js';
+export type { DuplicateDeclaration, ExportSurface, ExportSurfaceEntry } from './postprocess.js';
 export { deriveIncludePatterns } from './files.js';
 export { discoverSourceFiles } from './discovery.js';
 export type { Discovery, DiscoverSourceFilesOptions, DiscoverSourceFilesResult, } from './discovery.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAC,OAAO,EAAE,gBAAgB,EAAC,MAAM,cAAc,CAAC;AACvD,YAAY,EAAC,cAAc,EAAE,uBAAuB,EAAC,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAC,iBAAiB,EAAE,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AACvE,YAAY,EAAC,qBAAqB,EAAE,YAAY,EAAE,oBAAoB,EAAC,MAAM,mBAAmB,CAAC;AACjG,OAAO,EAAC,qBAAqB,EAAC,MAAM,cAAc,CAAC;AACnD,YAAY,EACX,eAAe,EACf,sBAAsB,EACtB,cAAc,EACd,aAAa,EACb,cAAc,EACd,YAAY,GACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAC,sBAAsB,EAAC,MAAM,mBAAmB,CAAC;AACzD,YAAY,EAAC,cAAc,EAAE,aAAa,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAItF,OAAO,EACN,eAAe,EACf,mBAAmB,EACnB,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,UAAU,EACV,uBAAuB,EACvB,oBAAoB,EACpB,wBAAwB,EACxB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,EACxB,eAAe,EACf,UAAU,GACV,MAAM,YAAY,CAAC;AAIpB,OAAO,EACN,cAAc,EACd,cAAc,EACd,eAAe,EACf,MAAM,EACN,kBAAkB,EAClB,0BAA0B,GAC1B,MAAM,0BAA0B,CAAC;AAIlC,YAAY,EAAC,cAAc,EAAE,YAAY,EAAC,MAAM,aAAa,CAAC;AAI9D,OAAO,EAAC,mBAAmB,EAAE,sBAAsB,EAAC,MAAM,oBAAoB,CAAC;AAC/E,YAAY,EAAC,mBAAmB,EAAE,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AAInF,OAAO,EAAC,cAAc,EAAE,cAAc,EAAE,uBAAuB,EAAC,MAAM,kBAAkB,CAAC;AACzF,YAAY,EAAC,oBAAoB,EAAE,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAI1E,OAAO,EAAC,qBAAqB,EAAC,MAAM,YAAY,CAAC;AAIjD,OAAO,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AACnD,YAAY,EACX,SAAS,EACT,0BAA0B,EAC1B,yBAAyB,GACzB,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EACN,SAAS,EACT,WAAW,EACX,QAAQ,EACR,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,UAAU,GACV,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAC,WAAW,EAAC,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,EAAC,OAAO,EAAE,gBAAgB,EAAC,MAAM,cAAc,CAAC;AACvD,YAAY,EAAC,cAAc,EAAE,uBAAuB,EAAC,MAAM,cAAc,CAAC;AAC1E,OAAO,EAAC,iBAAiB,EAAE,iBAAiB,EAAC,MAAM,mBAAmB,CAAC;AACvE,YAAY,EAAC,qBAAqB,EAAE,YAAY,EAAE,oBAAoB,EAAC,MAAM,mBAAmB,CAAC;AACjG,OAAO,EAAC,qBAAqB,EAAC,MAAM,cAAc,CAAC;AACnD,YAAY,EACX,eAAe,EACf,sBAAsB,EACtB,cAAc,EACd,aAAa,EACb,cAAc,EACd,YAAY,GACZ,MAAM,cAAc,CAAC;AACtB,OAAO,EAAC,sBAAsB,EAAC,MAAM,mBAAmB,CAAC;AACzD,YAAY,EAAC,cAAc,EAAE,aAAa,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAItF,OAAO,EACN,eAAe,EACf,mBAAmB,EACnB,UAAU,EACV,UAAU,EACV,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,EACrB,UAAU,EACV,uBAAuB,EACvB,oBAAoB,EACpB,wBAAwB,EACxB,mBAAmB,EACnB,uBAAuB,EACvB,mBAAmB,EACnB,wBAAwB,EACxB,sBAAsB,EACtB,wBAAwB,EACxB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,UAAU,GACV,MAAM,YAAY,CAAC;AAIpB,OAAO,EACN,cAAc,EACd,cAAc,EACd,eAAe,EACf,MAAM,EACN,kBAAkB,EAClB,0BAA0B,GAC1B,MAAM,0BAA0B,CAAC;AAIlC,YAAY,EAAC,cAAc,EAAE,YAAY,EAAC,MAAM,aAAa,CAAC;AAI9D,OAAO,EAAC,mBAAmB,EAAE,sBAAsB,EAAC,MAAM,oBAAoB,CAAC;AAC/E,YAAY,EAAC,mBAAmB,EAAE,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AAInF,OAAO,EACN,cAAc,EACd,cAAc,EACd,uBAAuB,EACvB,oBAAoB,GACpB,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAC,oBAAoB,EAAE,aAAa,EAAE,kBAAkB,EAAC,MAAM,kBAAkB,CAAC;AAI9F,OAAO,EAAC,qBAAqB,EAAC,MAAM,YAAY,CAAC;AAIjD,OAAO,EAAC,mBAAmB,EAAC,MAAM,gBAAgB,CAAC;AACnD,YAAY,EACX,SAAS,EACT,0BAA0B,EAC1B,yBAAyB,GACzB,MAAM,gBAAgB,CAAC;AAIxB,OAAO,EACN,SAAS,EACT,WAAW,EACX,QAAQ,EACR,UAAU,EACV,MAAM,EACN,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,UAAU,GACV,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAC,WAAW,EAAC,MAAM,UAAU,CAAC"}

package/dist/index.js

@@ -15,13 +15,13 @@ export { throwOnDuplicates, AnalyzeResultJson } from './analyze-core.js';
 export { createAnalysisSession } from './session.js';
 export { normalizeResolveImport } from './dep-resolver.js';
 // ── Types (Zod schemas + TypeScript interfaces) ─────────────────────────────
-export { DeclarationKind, DeclarationModifier, MemberKind, Reactivity, GenericParamJson, ParameterJson, ComponentPropJson, OverloadJson, FunctionMemberJson, VariableMemberJson, ConstructorMemberJson, MemberJson, FunctionDeclarationJson, ClassDeclarationJson, InterfaceDeclarationJson, TypeDeclarationJson, VariableDeclarationJson, EnumDeclarationJson, ComponentDeclarationJson, SnippetDeclarationJson, NamespaceDeclarationJson, DeclarationJson, ModuleJson, } from './types.js';
+export { DeclarationKind, DeclarationModifier, MemberKind, Reactivity, GenericParamJson, ParameterJson, ComponentPropJson, OverloadJson, FunctionMemberJson, VariableMemberJson, ConstructorMemberJson, MemberJson, FunctionDeclarationJson, ClassDeclarationJson, InterfaceDeclarationJson, TypeDeclarationJson, VariableDeclarationJson, EnumDeclarationJson, ComponentDeclarationJson, SnippetDeclarationJson, NamespaceDeclarationJson, DeclarationJson, ReExportJson, ExternalReExportJson, ModuleJson, } from './types.js';
 // ── Declaration helpers ────────────────────────────────────────────────────
 export { getDisplayName, generateImport, compactReplacer, isKind, findTypeReferences, buildTypeReferencePatterns, } from './declaration-helpers.js';
 // ── Source options ──────────────────────────────────────────────────────────
 export { createSourceOptions, DEFAULT_SOURCE_OPTIONS } from './source-config.js';
 // ── Post-processing ────────────────────────────────────────────────────────
-export { findDuplicates, mergeReExports, resolveComponentAliases } from './postprocess.js';
+export { findDuplicates, mergeReExports, resolveComponentAliases, resolveExportSurface, } from './postprocess.js';
 // ── File system constants ──────────────────────────────────────────────────
 export { deriveIncludePatterns } from './files.js';
 // ── File discovery ──────────────────────────────────────────────────────────

package/dist/postprocess.d.ts

@@ -13,7 +13,6 @@
  * @module
  */
 import type { DeclarationJson, ModuleJson } from './types.js';
-import type { ReExportInfo } from './declaration-build.js';
 import type { SourceFileInfo } from './source.js';
 /**
  * A duplicate declaration with its full metadata and module path.
@@ -27,6 +26,14 @@ export interface DuplicateDeclaration {
 /**
  * Find duplicate declaration names across modules.
  *
+ * A duplicate is two *different things* sharing a name in the flat namespace.
+ * Occurrences are compared by canonical identity — `aliasOf` chains are
+ * resolved first, so an alias and its canonical (or two aliases of the same
+ * canonical) are one thing, not a collision. Documenting a same-name re-export
+ * (which synthesizes an alias) or re-exporting a component under its own name
+ * (`export {default as Foo} from './Foo.svelte'`) therefore doesn't flag.
+ * When a name does flag, all occurrences are reported, aliases included.
+ *
  * Callers can decide how to handle duplicates (throw, warn, ignore).
  *
  * @returns `Map` of declaration names to their `DuplicateDeclaration` occurrences (only includes duplicates)
@@ -46,59 +53,59 @@ export interface DuplicateDeclaration {
  * ```
  */
 export declare const findDuplicates: (modules: Array<ModuleJson>) => Map<string, Array<DuplicateDeclaration>>;
+/**
+ * Code-unit string comparator for deterministic output ordering.
+ *
+ * Unlike `localeCompare` (host-locale/ICU-dependent, so byte-identical input
+ * can serialize in different orders on different machines), code-unit order is
+ * environment-independent — and it matches the default `Array.prototype.sort`
+ * used for `alsoExportedFrom`, `dependencies`, and `dependents`.
+ */
+export declare const compareStrings: (a: string, b: string) => number;
 /**
  * Sort modules alphabetically by path for deterministic output and cleaner diffs.
  *
+ * Code-unit order (`compareStrings`) so the output is environment-independent.
+ *
  * @param modules - the modules to sort
  * @returns a new sorted array (does not mutate input)
  */
 export declare const sortModules: (modules: Array<ModuleJson>) => Array<ModuleJson>;
 /**
- * A collected re-export with its source module context.
- *
- * Used during the two-phase re-export resolution:
- * 1. Phase 1: Collect re-exports from each module during analysis
- * 2. Phase 2: Group by original module and merge into `alsoExportedFrom`
- */
-export interface ReExportEntry {
-    /** The module that re-exports the declaration. */
-    reExportingModule: string;
-    /** The re-export info (name and original module). */
-    reExport: ReExportInfo;
-}
-/**
- * Build `alsoExportedFrom` arrays from collected re-export data.
- *
- * This function resolves the two-phase re-export problem:
+ * Build `alsoExportedFrom` arrays from the modules' forward re-export edges.
  *
- * **Problem**: When module A re-exports from module B, we discover this while
- * analyzing A, but need to update B's declarations. However, B may already be
- * processed or may be processed later.
- *
- * **Solution**: Collect all re-exports in phase 1, then merge them in phase 2
- * after all modules are analyzed.
+ * Each module carries its same-name re-export edges as `ModuleJson.reExports`
+ * (collected in phase 1); this phase-2 pass inverts them onto the canonical
+ * declarations so both directions of the same fact are queryable. Edges whose
+ * canonical module or declaration is absent from `modules` are skipped — the
+ * forward entry remains without a back-link (see `ReExportJson` for the
+ * presence caveats).
  *
  * Component-only fields on renamed component aliases (`props`,
  * `acceptsChildren`, etc.) are populated separately by `resolveComponentAliases`
  * — call it after this function. They split because they touch disjoint fields
  * and have different inputs.
  *
- * @param modules - the modules array with all modules (will be mutated)
- * @param collectedReExports - array of re-exports collected during phase 1
- * @mutates modules - unions new re-exporters into `declaration.alsoExportedFrom`
+ * @param modules - the modules array with all modules (will be mutated).
+ *   Must be parsed `ModuleJson`s — wire JSON strips empty arrays, so run
+ *   raw JSON through `AnalyzeResultJson.parse` first or `reExports` may be
+ *   `undefined`
+ * @mutates modules - unions re-exporters into `declaration.alsoExportedFrom`
  *   (deduped + sorted), so a second call with the same inputs is a no-op
  *
  * @example
  * ```ts
  * // helpers.ts exports: foo, bar
- * // index.ts does: export {foo, bar} from './files.js'
+ * // index.ts does: export {foo, bar} from './helpers.js'
+ * // (so index.ts's ModuleJson carries reExports:
+ * //   [{name: 'foo', module: 'helpers.ts'}, {name: 'bar', module: 'helpers.ts'}])
  * //
  * // After processing:
  * // - helpers.ts foo declaration gets: alsoExportedFrom: ['index.ts']
  * // - helpers.ts bar declaration gets: alsoExportedFrom: ['index.ts']
  * ```
  */
-export declare const mergeReExports: (modules: Array<ModuleJson>, collectedReExports: Array<ReExportEntry>) => void;
+export declare const mergeReExports: (modules: Array<ModuleJson>) => void;
 /**
  * Copy props/acceptsChildren/lang/etc. from canonical component declarations
  * onto synthesized component-aliased declarations.
@@ -142,4 +149,87 @@ export declare const resolveComponentAliases: (modules: Array<ModuleJson>) => vo
 export declare const computeDependents: (files: ReadonlyArray<SourceFileInfo>) => Array<SourceFileInfo & {
     dependents?: ReadonlyArray<string>;
 }>;
+/**
+ * One name on a module's resolved export surface.
+ */
+export interface ExportSurfaceEntry {
+    /**
+     * Exported name, in the docinfo model's terms — Svelte components appear
+     * under their filename-derived name (the model's convention for default
+     * exports of `.svelte` files), not `'default'`.
+     */
+    name: string;
+    /**
+     * How the name reaches this module's surface: an own declaration
+     * (including synthesized aliases), a same-name re-export edge, a direct
+     * external re-export, or projection through `export * from './x'`.
+     */
+    via: 'declaration' | 'reExport' | 'external' | 'star';
+    /** Canonical module path, when known (`undefined` for external entries). */
+    module?: string;
+    /** The canonical declaration, when present in the analyzed set. */
+    declaration?: DeclarationJson;
+    /** Package specifier for external entries (as written in the statement). */
+    specifier?: string;
+    /** Name inside the external package when renamed. */
+    originalName?: string;
+    /** Type-only re-export — the name is erased at runtime. */
+    typeOnly?: boolean;
+    /** For star-projected entries: the `starExports` target the name arrived through. */
+    starFrom?: string;
+}
+/**
+ * A module's resolved export surface — see `resolveExportSurface`.
+ */
+export interface ExportSurface {
+    /** Surface entries, sorted by `name` (code-unit order). */
+    entries: Array<ExportSurfaceEntry>;
+    /**
+     * Star targets (own or transitive) absent from the analyzed set — their
+     * projected names are unknown, so the surface is incomplete.
+     */
+    unresolvedStarExports: Array<string>;
+    /**
+     * External star specifiers reachable from this module (own or transitive)
+     * — their projected names are unknowable without analyzing the package.
+     */
+    externalStarExports: Array<string>;
+}
+/**
+ * Resolve a module's full export surface from the analyzed model, applying
+ * ES module semantics to star exports.
+ *
+ * Combines the module's own `declarations` (including synthesized aliases),
+ * `reExports` edges, `externalReExports`, and transitively-resolved
+ * `starExports` into one deduped, name-sorted list. The ES rules applied to
+ * star projection:
+ *
+ * - explicit exports (declarations, edges, externals) shadow star-projected
+ *   names
+ * - a name projected by two stars that resolve to *different* canonicals is
+ *   ambiguous and excluded (same canonical through a diamond is included
+ *   once)
+ * - `default` is never star-projected — including canonical Svelte component
+ *   declarations, which represent their file's default export. (Caveat: a
+ *   star-projected re-export edge whose canonical is a component is treated
+ *   as a default-slot re-export and skipped; a `<script module>` const
+ *   sharing the component's exact name would be skipped with it.)
+ *
+ * A Position-3 alias and its `reExports` edge are the same fact — the
+ * declaration entry wins, inheriting the edge's `typeOnly`.
+ *
+ * Cyclic star graphs terminate by contributing nothing along the back-edge
+ * (an approximation of ES fixpoint resolution — fine in practice). Surfaces
+ * resolved inside a cycle are path-relative and not memoized, so sibling
+ * star paths resolve independently rather than inheriting them. Star
+ * targets missing from `modules` are reported in `unresolvedStarExports`
+ * rather than guessed at; `externalStarExports` aggregates external star
+ * specifiers reachable from the module, whose names are unknowable.
+ *
+ * @param modules - the analyzed modules (parsed `ModuleJson`s — run wire
+ *   JSON through `AnalyzeResultJson.parse` first)
+ * @param path - the module to resolve, as a `ModuleJson.path` value
+ * @returns the resolved surface, or `null` when `path` isn't in `modules`
+ */
+export declare const resolveExportSurface: (modules: Array<ModuleJson>, path: string) => ExportSurface | null;
 //# sourceMappingURL=postprocess.d.ts.map

package/dist/postprocess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postprocess.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/postprocess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAA2B,eAAe,EAAE,UAAU,EAAC,MAAM,YAAY,CAAC;AACtF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAuBhD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,qCAAqC;IACrC,WAAW,EAAE,eAAe,CAAC;IAC7B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,cAAc,GAC1B,SAAS,KAAK,CAAC,UAAU,CAAC,KACxB,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,oBAAoB,CAAC,CA4BzC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,KAAK,CAAC,UAAU,CAExE,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC7B,kDAAkD;IAClD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,QAAQ,EAAE,YAAY,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,cAAc,GAC1B,SAAS,KAAK,CAAC,UAAU,CAAC,EAC1B,oBAAoB,KAAK,CAAC,aAAa,CAAC,KACtC,IAkCF,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,IAoDpE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,aAAa,CAAC,cAAc,CAAC,KAClC,KAAK,CAAC,cAAc,GAAG;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAC,CAwD7D,CAAC"}
+{"version":3,"file":"postprocess.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/postprocess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAA2B,eAAe,EAAE,UAAU,EAAC,MAAM,YAAY,CAAC;AACtF,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAuBhD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,qCAAqC;IACrC,WAAW,EAAE,eAAe,CAAC;IAC7B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;CACf;AA6CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,cAAc,GAC1B,SAAS,KAAK,CAAC,UAAU,CAAC,KACxB,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAwCzC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAAsC,CAAC;AAE7F;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,KAAK,CAAC,UAAU,CAExE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,IAmC3D,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,IAoDpE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,aAAa,CAAC,cAAc,CAAC,KAClC,KAAK,CAAC,cAAc,GAAG;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAC,CAwD7D,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,GAAG,EAAE,aAAa,GAAG,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;IACtD,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,2DAA2D;IAC3D,OAAO,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACnC;;;OAGG;IACH,qBAAqB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,mBAAmB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACnC;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,oBAAoB,GAChC,SAAS,KAAK,CAAC,UAAU,CAAC,EAC1B,MAAM,MAAM,KACV,aAAa,GAAG,IA+IlB,CAAC"}