svelte-docinfo 0.12.0 → 0.13.0

package/dist/svelte-scripts.d.ts

@@ -0,0 +1,144 @@
+/**
+ * Locating a Svelte component's script tags: its instance `<script>` and its
+ * `<script module>`.
+ *
+ * Svelte takes a `<script>` for one of those only at the top level of the
+ * file. Nested in an element, a block, or `<svelte:head>` it's an ordinary
+ * element (a JSON-LD block, an inline analytics snippet), and its content says
+ * nothing about the component. So finding the tags takes two steps: a regex
+ * scan for candidates (`scanScriptTags`), then a decision about which of
+ * them are top-level (`findScriptTags`).
+ *
+ * @internal
+ *
+ * @module
+ */
+/** A located script tag: parsed attributes, content, and where the content starts in the source. */
+export interface SvelteScriptTag {
+    /** Opening-tag attributes; bare attributes (`module`) map to `true`. */
+    attributes: Map<string, string | true>;
+    content: string;
+    /** Offset of `content` within the source, for mapping script positions to original lines. */
+    start: number;
+}
+/** A script tag the scan matched, before anything has decided whether it's top-level. */
+export interface ScannedScriptTag extends SvelteScriptTag {
+    /** Offset of the tag's opening `<`, which is where Svelte's parser places the script. */
+    open: number;
+    /** Offset just past the tag's closing `>`. */
+    end: number;
+    /**
+     * Whether the scan alone proves the tag top-level, with no parser: see
+     * `scanScriptTags` for the proof and its conditions.
+     */
+    provenTopLevel: boolean;
+}
+/**
+ * Scan Svelte source for script tags with content, in source order, and mark
+ * the ones the scan itself proves top-level.
+ *
+ * The scan is syntactic and knows nothing about nesting, so it returns nested
+ * tags too; `findScriptTags` is the function that answers which are the
+ * component's. Limits: whitespace around an attribute `=` makes a tag
+ * unmatchable (Svelte rejects one of those spellings, and svelte2tsx matches
+ * neither), and `</script>` in a string literal ends the content early.
+ *
+ * **`provenTopLevel`** holds for a tag when everything from the start of the
+ * file to it is whitespace, complete HTML comments, and earlier script tags
+ * that are themselves proven. Svelte's parser reads each of those at the root
+ * and comes back to the root: whitespace is text, a comment runs to the first
+ * `-->`, and a top-level script runs from its opening tag to the first
+ * `</script>`, the same extents the regex matched. So it meets this tag at the
+ * root, where a `<script>` is the instance or module script.
+ *
+ * Anything that would need more than that argument leaves the tag unproven,
+ * along with every tag after it:
+ *
+ * - any other text or markup before the tag: a `<style>`,
+ *   `<svelte:options>`, an unterminated comment, what's left over when a
+ *   `</script>` in a string ended an earlier match early, and tags the regex
+ *   doesn't match (`<SCRIPT>`, a spelling with whitespace around `=`)
+ * - a self-closing `<script />`, which Svelte's parser rejects at the top
+ *   level
+ * - attributes outside `UNAMBIGUOUS_ATTRIBUTES_MATCHER`
+ */
+export declare const scanScriptTags: (svelteSource: string) => Array<ScannedScriptTag>;
+/**
+ * A script tag is a module script when it carries a `module` attribute
+ * (Svelte 5) or `context="module"` (Svelte 4) — Svelte's `read_script` test,
+ * minus its error paths. `module` inside an attribute *value* doesn't count.
+ */
+export declare const isModuleScript: (attributes: Map<string, string | true>) => boolean;
+/** The part of Svelte's parsed root that `findScriptTags` reads. */
+export interface SvelteTemplateScripts {
+    /** The instance script, at the offset of its opening `<`. */
+    instance?: {
+        start: number;
+    } | null;
+    /** The module script, at the offset of its opening `<`. */
+    module?: {
+        start: number;
+    } | null;
+}
+/**
+ * Parses a Svelte source whose script and style content is blanked, and says
+ * where its top-level scripts are. Throws when the source doesn't parse.
+ */
+export type ParseSvelteTemplate = (blankedSource: string) => SvelteTemplateScripts;
+/**
+ * How `findScriptTags` decided which tags are top-level:
+ *
+ * - `'scan'` — the scan proved every tag top-level (`provenTopLevel`), so
+ *   nothing was parsed
+ * - `'parser'` — Svelte's parser said which tags are the instance and module
+ *   scripts
+ * - `'unparsed'` — the parser threw, and every matched tag is returned
+ */
+export type ScriptTagsDecision = 'scan' | 'parser' | 'unparsed';
+/** What `findScriptTags` returns. */
+export interface FoundScriptTags {
+    /** The component's script tags, in source order. */
+    tags: Array<SvelteScriptTag>;
+    decidedBy: ScriptTagsDecision;
+}
+/** Options for `findScriptTags`. */
+export interface FindScriptTagsOptions {
+    /**
+     * Take the scan's proof when it covers every tag, without parsing.
+     * `false` sends every source with a tag to the parser.
+     *
+     * @default true
+     */
+    scanProof?: boolean;
+    /** The parser asked about tags the scan can't prove. Defaults to Svelte's. */
+    parseTemplate?: ParseSvelteTemplate;
+}
+/**
+ * Find a component's script tags: the `<script>` tags at the top level of the
+ * source, in source order. A `<script>` nested in an element, a block, or
+ * `<svelte:head>` isn't one, matching Svelte, which reads only a top-level
+ * tag as the instance or module script.
+ *
+ * `scanScriptTags` finds the candidates. When it proves every one of them
+ * top-level, which covers the usual component with its scripts ahead of the
+ * template, that's the answer. Otherwise Svelte's parser decides: the source
+ * is parsed with script and style content blanked, and the tags at the
+ * offsets of the root's `instance` and `module` are kept. svelte2tsx parses
+ * the same blanked source, but demotes only the tags the parser reads as
+ * nested elements, so a tag spelled inside an expression string or an
+ * attribute value is still a script to it and isn't one here.
+ *
+ * Limits: a `</script>` or `</style>` inside a string or comment ends that
+ * tag's blanked content early, and what's left over is parsed as template.
+ * And svelte2tsx's own tag matcher is narrower in one spelling: it doesn't
+ * take a closing tag with whitespace before the `>` (`</script >`), so there
+ * its virtual doesn't have the scripts as written while this returns them. A
+ * legacy component
+ * written that way documents no props, with a `svelte_prop_failed` warning
+ * for each `export let`; a runes one documents none, with no warning.
+ *
+ * @param svelteSource - the full Svelte source code
+ * @returns the top-level script tags and how they were decided
+ */
+export declare const findScriptTags: (svelteSource: string, options?: FindScriptTagsOptions) => FoundScriptTags;
+//# sourceMappingURL=svelte-scripts.d.ts.map

package/dist/svelte-scripts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"svelte-scripts.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte-scripts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH,oGAAoG;AACpG,MAAM,WAAW,eAAe;IAC/B,wEAAwE;IACxE,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,6FAA6F;IAC7F,KAAK,EAAE,MAAM,CAAC;CACd;AAED,yFAAyF;AACzF,MAAM,WAAW,gBAAiB,SAAQ,eAAe;IACxD,yFAAyF;IACzF,IAAI,EAAE,MAAM,CAAC;IACb,8CAA8C;IAC9C,GAAG,EAAE,MAAM,CAAC;IACZ;;;OAGG;IACH,cAAc,EAAE,OAAO,CAAC;CACxB;AAwCD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,cAAc,GAAI,cAAc,MAAM,KAAG,KAAK,CAAC,gBAAgB,CA8B3E,CAAC;AAiBF;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,KAAG,OACL,CAAC;AAuDpE,oEAAoE;AACpE,MAAM,WAAW,qBAAqB;IACrC,6DAA6D;IAC7D,QAAQ,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IACpC,2DAA2D;IAC3D,MAAM,CAAC,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CAClC;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,aAAa,EAAE,MAAM,KAAK,qBAAqB,CAAC;AAUnF;;;;;;;;GAQG;AACH,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,UAAU,CAAC;AAEhE,qCAAqC;AACrC,MAAM,WAAW,eAAe;IAC/B,oDAAoD;IACpD,IAAI,EAAE,KAAK,CAAC,eAAe,CAAC,CAAC;IAC7B,SAAS,EAAE,kBAAkB,CAAC;CAC9B;AAED,oCAAoC;AACpC,MAAM,WAAW,qBAAqB;IACrC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,8EAA8E;IAC9E,aAAa,CAAC,EAAE,mBAAmB,CAAC;CACpC;AAQD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,cAAc,GAC1B,cAAc,MAAM,EACpB,UAAU,qBAAqB,KAC7B,eAwBF,CAAC"}

package/dist/svelte-scripts.js

@@ -0,0 +1,242 @@
+/**
+ * Locating a Svelte component's script tags: its instance `<script>` and its
+ * `<script module>`.
+ *
+ * Svelte takes a `<script>` for one of those only at the top level of the
+ * file. Nested in an element, a block, or `<svelte:head>` it's an ordinary
+ * element (a JSON-LD block, an inline analytics snippet), and its content says
+ * nothing about the component. So finding the tags takes two steps: a regex
+ * scan for candidates (`scanScriptTags`), then a decision about which of
+ * them are top-level (`findScriptTags`).
+ *
+ * @internal
+ *
+ * @module
+ */
+import { parse } from 'svelte/compiler';
+/**
+ * Matches, left to right, an HTML comment or a script tag.
+ *
+ * Ports Svelte's preprocessor regex (`svelte/src/compiler/preprocess`):
+ * quote-aware attributes (`>` inside a value doesn't end the tag),
+ * commented-out scripts consumed by the comment alternative, a self-closing
+ * form with no content. Adaptations: the `d` flag for content offsets, no `i`
+ * flag (`<Script>` is a component), `\s*` before the closing `>` per the
+ * parser's `/<\/script\s*>/`.
+ */
+const SCRIPT_TAG_MATCHER = /<!--[^]*?-->|<script((?:\s+[^=>'"/\s]+=(?:"[^"]*"|'[^']*'|[^>\s]+)|\s+[^=>'"/\s]+)*\s*)(?:\/>|>([^]*?)<\/script\s*>)/dg;
+/** `SCRIPT_TAG_MATCHER` for style tags, whose content is blanked before parsing. */
+const STYLE_TAG_MATCHER = /<!--[^]*?-->|<style(?:\s+[^=>'"/\s]+=(?:"[^"]*"|'[^']*'|[^>\s]+)|\s+[^=>'"/\s]+)*\s*>([^]*?)<\/style\s*>/dg;
+/**
+ * The attribute spellings the scan's proof accepts: names of word characters,
+ * values double-quoted, single-quoted, or bare word characters, whitespace
+ * between attributes. Narrower than `SCRIPT_TAG_MATCHER`'s attribute branch
+ * on purpose. That branch can backtrack into a second reading of the same
+ * text (an unterminated quote read as a bare value), and Svelte's parser,
+ * which never backtracks, may take the other one. This grammar has a single
+ * reading, the one the parser's `read_static_attribute` makes.
+ */
+const UNAMBIGUOUS_ATTRIBUTES_MATCHER = /^(?:[ \t\r\n]+[A-Za-z][\w-]*(?:=(?:"[^"]*"|'[^']*'|[\w.-]+))?)*[ \t\r\n]*$/;
+const WHITESPACE_MATCHER = /\s*/y;
+/** Whether `source` holds only whitespace from `start` up to `end`. */
+const isWhitespaceBetween = (source, start, end) => {
+    WHITESPACE_MATCHER.lastIndex = start;
+    WHITESPACE_MATCHER.test(source);
+    return WHITESPACE_MATCHER.lastIndex >= end;
+};
+/**
+ * Scan Svelte source for script tags with content, in source order, and mark
+ * the ones the scan itself proves top-level.
+ *
+ * The scan is syntactic and knows nothing about nesting, so it returns nested
+ * tags too; `findScriptTags` is the function that answers which are the
+ * component's. Limits: whitespace around an attribute `=` makes a tag
+ * unmatchable (Svelte rejects one of those spellings, and svelte2tsx matches
+ * neither), and `</script>` in a string literal ends the content early.
+ *
+ * **`provenTopLevel`** holds for a tag when everything from the start of the
+ * file to it is whitespace, complete HTML comments, and earlier script tags
+ * that are themselves proven. Svelte's parser reads each of those at the root
+ * and comes back to the root: whitespace is text, a comment runs to the first
+ * `-->`, and a top-level script runs from its opening tag to the first
+ * `</script>`, the same extents the regex matched. So it meets this tag at the
+ * root, where a `<script>` is the instance or module script.
+ *
+ * Anything that would need more than that argument leaves the tag unproven,
+ * along with every tag after it:
+ *
+ * - any other text or markup before the tag: a `<style>`,
+ *   `<svelte:options>`, an unterminated comment, what's left over when a
+ *   `</script>` in a string ended an earlier match early, and tags the regex
+ *   doesn't match (`<SCRIPT>`, a spelling with whitespace around `=`)
+ * - a self-closing `<script />`, which Svelte's parser rejects at the top
+ *   level
+ * - attributes outside `UNAMBIGUOUS_ATTRIBUTES_MATCHER`
+ */
+export const scanScriptTags = (svelteSource) => {
+    const scripts = [];
+    // whether everything up to `cursor` is whitespace, comments, and proven scripts
+    let atRoot = true;
+    let cursor = 0;
+    SCRIPT_TAG_MATCHER.lastIndex = 0;
+    let match;
+    while ((match = SCRIPT_TAG_MATCHER.exec(svelteSource)) !== null) {
+        atRoot &&= isWhitespaceBetween(svelteSource, cursor, match.index);
+        cursor = match.index + match[0].length;
+        const attrs = match[1];
+        // the comment alternative captures no attributes
+        if (attrs === undefined)
+            continue;
+        const content = match[2];
+        if (content === undefined) {
+            // self-closing, so no content to return
+            atRoot = false;
+            continue;
+        }
+        atRoot &&= UNAMBIGUOUS_ATTRIBUTES_MATCHER.test(attrs);
+        scripts.push({
+            attributes: parseAttributes(attrs),
+            content,
+            start: match.indices[2][0],
+            open: match.index,
+            end: cursor,
+            provenTopLevel: atRoot
+        });
+    }
+    return scripts;
+};
+/**
+ * Parse an opening-tag attribute string into a name → value map — bare
+ * attributes map to `true`. The token grammar mirrors `SCRIPT_TAG_MATCHER`'s
+ * attribute branch, so anything that regex matched parses cleanly here.
+ */
+const parseAttributes = (attrs) => {
+    const attributes = new Map();
+    const attributeRegex = /([^=>'"/\s]+)(?:=(?:"([^"]*)"|'([^']*)'|([^>\s]+)))?/g;
+    let match;
+    while ((match = attributeRegex.exec(attrs)) !== null) {
+        attributes.set(match[1], match[2] ?? match[3] ?? match[4] ?? true);
+    }
+    return attributes;
+};
+/**
+ * A script tag is a module script when it carries a `module` attribute
+ * (Svelte 5) or `context="module"` (Svelte 4) — Svelte's `read_script` test,
+ * minus its error paths. `module` inside an attribute *value* doesn't count.
+ */
+export const isModuleScript = (attributes) => attributes.has('module') || attributes.get('context') === 'module';
+/**
+ * Copy `svelteSource` with the content of its script and style tags
+ * overwritten by spaces, newlines kept, so every offset and line still means
+ * what it meant. Script content needn't be JavaScript Svelte's parser accepts,
+ * and a nested tag's content would be read as template.
+ *
+ * A style tag that opens inside a script tag is text in that script, and the
+ * search for styles resumes after the script. A leading byte-order mark
+ * becomes a space too: Svelte's `parse` strips one, which would shift every
+ * offset it reports.
+ */
+const blankVerbatimContent = (svelteSource, scripts) => {
+    const ranges = scripts.map((tag) => [
+        tag.start,
+        tag.start + tag.content.length
+    ]);
+    STYLE_TAG_MATCHER.lastIndex = 0;
+    let match;
+    while ((match = STYLE_TAG_MATCHER.exec(svelteSource)) !== null) {
+        const range = match.indices[1];
+        // the comment alternative captures no content
+        if (!range)
+            continue;
+        const open = match.index;
+        const enclosing = scripts.find((tag) => tag.open < open && open < tag.end);
+        if (enclosing) {
+            STYLE_TAG_MATCHER.lastIndex = enclosing.end;
+            continue;
+        }
+        ranges.push(range);
+    }
+    // a style's content can hold a matched script, so ranges can overlap: each
+    // is clipped to what's still ahead of the cursor
+    ranges.sort((a, b) => a[0] - b[0]);
+    let blanked = '';
+    let cursor = 0;
+    if (svelteSource.charCodeAt(0) === 0xfeff) {
+        blanked = ' ';
+        cursor = 1;
+    }
+    for (const [rangeStart, end] of ranges) {
+        const start = Math.max(rangeStart, cursor);
+        if (end <= start)
+            continue;
+        blanked +=
+            svelteSource.slice(cursor, start) + svelteSource.slice(start, end).replace(/[^\n]/g, ' ');
+        cursor = end;
+    }
+    return blanked + svelteSource.slice(cursor);
+};
+/**
+ * The default `ParseSvelteTemplate`: Svelte's own parser. `loose` keeps it
+ * from throwing on a template error, the way svelte2tsx parses under
+ * `emitOnTemplateError`; `modern` skips the conversion to the legacy AST.
+ */
+const parseSvelteTemplate = (blankedSource) => parse(blankedSource, { modern: true, loose: true });
+const toScriptTag = ({ attributes, content, start }) => ({
+    attributes,
+    content,
+    start
+});
+/**
+ * Find a component's script tags: the `<script>` tags at the top level of the
+ * source, in source order. A `<script>` nested in an element, a block, or
+ * `<svelte:head>` isn't one, matching Svelte, which reads only a top-level
+ * tag as the instance or module script.
+ *
+ * `scanScriptTags` finds the candidates. When it proves every one of them
+ * top-level, which covers the usual component with its scripts ahead of the
+ * template, that's the answer. Otherwise Svelte's parser decides: the source
+ * is parsed with script and style content blanked, and the tags at the
+ * offsets of the root's `instance` and `module` are kept. svelte2tsx parses
+ * the same blanked source, but demotes only the tags the parser reads as
+ * nested elements, so a tag spelled inside an expression string or an
+ * attribute value is still a script to it and isn't one here.
+ *
+ * Limits: a `</script>` or `</style>` inside a string or comment ends that
+ * tag's blanked content early, and what's left over is parsed as template.
+ * And svelte2tsx's own tag matcher is narrower in one spelling: it doesn't
+ * take a closing tag with whitespace before the `>` (`</script >`), so there
+ * its virtual doesn't have the scripts as written while this returns them. A
+ * legacy component
+ * written that way documents no props, with a `svelte_prop_failed` warning
+ * for each `export let`; a runes one documents none, with no warning.
+ *
+ * @param svelteSource - the full Svelte source code
+ * @returns the top-level script tags and how they were decided
+ */
+export const findScriptTags = (svelteSource, options) => {
+    const scripts = scanScriptTags(svelteSource);
+    if (scripts.length === 0)
+        return { tags: [], decidedBy: 'scan' };
+    if (options?.scanProof !== false && scripts.every((tag) => tag.provenTopLevel)) {
+        return { tags: scripts.map(toScriptTag), decidedBy: 'scan' };
+    }
+    const parseTemplate = options?.parseTemplate ?? parseSvelteTemplate;
+    let parsed;
+    try {
+        parsed = parseTemplate(blankVerbatimContent(svelteSource, scripts));
+    }
+    catch (_) {
+        // Every matched tag, nested ones included: the answer the scan alone
+        // gives. Svelte's parser throws here on a template error when it predates
+        // `loose` parsing (Svelte 5.13), which the peer range (5.0 and up) still
+        // admits, and in any version on the few errors `loose` doesn't absorb.
+        // TODO: remove this fallback when the `svelte` peer floor reaches a
+        // version with `loose` parsing
+        return { tags: scripts.map(toScriptTag), decidedBy: 'unparsed' };
+    }
+    const topLevel = new Set([parsed.instance?.start, parsed.module?.start]);
+    return {
+        tags: scripts.filter((tag) => topLevel.has(tag.open)).map(toScriptTag),
+        decidedBy: 'parser'
+    };
+};

package/dist/svelte.d.ts

@@ -19,6 +19,8 @@
  * @see `typescript-extract-type-json.ts` for `resolveTypeInfo`, `referenceSymbolName`, `tupleElements`, `restElementForms`
  * @see `tsdoc.ts` for `parseComment`, `applyToDeclaration`
  * @see `source.ts` for `SourceFileInfo`, `getComponentName`
+ * @see `svelte-legacy.ts` for `scanLegacyExports`, `resolveLegacyPropsAnchor`
+ * @see `svelte-scripts.ts` for `findScriptTags`, `isModuleScript`
  *
  * @module
  */
@@ -31,6 +33,7 @@ import { type AliasRegistry } from './typescript-extract-type-json.js';
 import { type SourceFileInfo } from './source.js';
 import { type ModuleSourceOptions } from './source-config.js';
 import { type Diagnostic } from './diagnostics.js';
+import { type SvelteScriptTag } from './svelte-scripts.js';
 /** Resolved source map type (avoids repeating the verbose `InstanceType<...>` inline). */
 type SourceMap = InstanceType<typeof TraceMap>;
 /**
@@ -55,6 +58,16 @@ export interface SvelteVirtualFile {
      * derived from it at output.
      */
     scriptKind: ts.ScriptKind;
+    /**
+     * The component's script tags as located in the original source: the
+     * top-level `<script>` tags, in source order (`findScriptTags`).
+     * `transformSvelteSource` locates them once, and `analyzeSvelteModule`
+     * reads the instance and module scripts from here on every analysis.
+     *
+     * Optional so a virtual built by hand needs none: `analyzeSvelteModule`
+     * then locates them in the source it's given.
+     */
+    scriptTags?: ReadonlyArray<SvelteScriptTag>;
 }
 /**
  * Result of `transformSvelteSource` — a virtual file (when transform succeeded)
@@ -92,18 +105,24 @@ export interface TransformResult {
  */
 export declare const transformSvelteSource: (sourceFile: SourceFileInfo) => TransformResult;
 /**
- * Extract the content of the main `<script>` tag from Svelte source —
- * commented-out scripts skipped, module scripts (`<script module>`,
- * `<script context="module">`) excluded.
+ * Extract the content of the component's instance `<script>` from Svelte
+ * source: the top-level one that isn't a module script (`<script module>`,
+ * `<script context="module">`). A commented-out script doesn't count, and
+ * neither does one nested in the template (`<svelte:head>`, an element, a
+ * block), which is an ordinary element.
+ *
+ * Locates the tags itself on every call (`findScriptTags`), parsing the
+ * template when the scan can't prove them top-level.
  *
- * @returns the script tag content, or undefined if no matching script tag is found
+ * @returns the script tag content, or undefined if the source has no instance script
  */
 export declare const extractScriptContent: (svelteSource: string) => string | undefined;
 /**
- * Extract the content of the module `<script>` tag from Svelte source.
+ * Extract the content of the component's module `<script>` from Svelte source.
  *
- * Counterpart of `extractScriptContent`: matches only module scripts, so the
- * two partition a source's script tags consistently.
+ * Counterpart of `extractScriptContent`: matches only the module script, under
+ * the same top-level rule and at the same per-call cost, so the two partition
+ * a source's script tags consistently.
  *
  * @returns the module script tag content, or undefined if no module script is found
  */
@@ -253,10 +272,13 @@ export declare const synthesizeSnippetTypeSignature: (parameters: Array<Paramete
  * 2. svelte2tsx internals are filtered (`isSvelte2tsxGeneratedExport`) and
  *    exported snippets reclassified to `kind: 'snippet'` (`isSnippetReturnType`);
  *    2b remaps module-level `sourceLine`s to the original `.svelte` source
- * 3. the component declaration is synthesized: props via `extractPropsViaChecker`,
- *    `acceptsChildren` from a `Snippet`-typed `children` prop or, failing that,
- *    template use (`__sveltets_2_ensureSnippet`), plus generics, doc comment, and
- *    source line from the landmarks `findComponentNodes` locates
+ * 3. the component declaration is synthesized: props via `extractPropsViaChecker`
+ *    from the component's `PropsAnchor` (`resolveRunesPropsAnchor` for a
+ *    `$props()` declaration, else `resolveExportLetPropsAnchor` for a legacy
+ *    component's exports), `acceptsChildren` from a `Snippet`-typed `children`
+ *    prop, template use (`__sveltets_2_ensureSnippet`) or, failing those, a
+ *    legacy component's default slot (`hasDefaultSlot`), plus generics, doc
+ *    comment, and source line from the landmarks `findComponentNodes` locates
  * 4. the module comment is read from the original source
  * 5. declarations combine, component first
  * 6. dependencies are extracted

package/dist/svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,QAAQ,EAAuB,MAAM,2BAA2B,CAAC;AAG1E,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAGX,kBAAkB,EAElB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EACX,oBAAoB,EAEpB,cAAc,EACd,MAAM,wBAAwB,CAAC;AAOhC,OAAO,EAUN,KAAK,aAAa,EAClB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAMN,KAAK,aAAa,EAClB,MAAM,mCAAmC,CAAC;AAM3C,OAAO,EACN,KAAK,cAAc,EAKnB,MAAM,aAAa,CAAC;AACrB,OAAO,EAAE,KAAK,mBAAmB,EAAuB,MAAM,oBAAoB,CAAC;AAEnF,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD,0FAA0F;AAC1F,KAAK,SAAS,GAAG,YAAY,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B;;;;;;;OAOG;IACH,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC;CAC1B;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACvC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,GAAI,YAAY,cAAc,KAAG,eA4DlE,CAAC;AAkLF;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SACgB,CAAC;AAEtF;;;;;;;GAOG;AACH,eAAO,MAAM,0BAA0B,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SACS,CAAC;AAoKrF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SAsBxE,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B,GAAI,eAAe,MAAM,KAAG,MAAM,GAAG,SACpB,CAAC;AAwIzD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,+BAA+B,GAC3C,aAAa,KAAK,CAAC,UAAU,CAAC,EAC9B,cAAc,QAAQ,CAAC,iBAAiB,CAAC,KACvC,IAoBF,CAAC;AAkKF;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,CAAC,WAAW,KAAG,OACiB,CAAC;AAEzF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,wBAAwB,GACpC,aAAa,EAAE,CAAC,IAAI,EACpB,SAAS,EAAE,CAAC,WAAW,EACvB,eAAe,aAAa,GAAG,SAAS,EACxC,cAAc,EAAE,CAAC,QAAQ,KACvB,KAAK,CAAC,kBAAkB,CA8B1B,CAAC;AAsBF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAKxD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,4BAA4B,GAAI,aAAa,oBAAoB,KAAG,IAWhF,CAAC;AAEF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,8BAA8B,GAAI,YAAY,KAAK,CAAC,kBAAkB,CAAC,KAAG,MAKtF,CAAC;AA+SF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,mBAAmB,GAC/B,YAAY,cAAc,GAAG;IAAE,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAE,EACnE,YAAY,MAAM,EAClB,SAAS,EAAE,CAAC,WAAW,EACvB,SAAS,mBAAmB,EAC5B,aAAa,KAAK,CAAC,UAAU,CAAC,EAC9B,SAAS,EAAE,CAAC,OAAO,EACnB,aAAa,iBAAiB,EAC9B,gBAAgB,aAAa,EAC7B,gBAAgB,aAAa,KAC3B,cAAc,GAAG,SAyTnB,CAAC"}
+{"version":3,"file":"svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte.ts"],"names":[],"mappings":"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"}