@urbicon-ui/i18n 6.3.7 → 6.3.9

package/dist/audit/glob.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tiny key-glob matcher shared by the translation audit (`ignoreKeys`) and the
+ * unused-key reconciler (`dynamicKeys`/`ignoreKeys`). Supports exact keys and a
+ * trailing `*` wildcard, so `errors.*` matches `errors.timeout` but not `errorsX`
+ * is intentional — `errors.*` slices to the prefix `errors.` (the dot is kept).
+ */
+export declare function makeGlobMatcher(patterns: string[] | undefined): (key: string) => boolean;

package/dist/audit/glob.js

@@ -0,0 +1,19 @@
+/**
+ * Tiny key-glob matcher shared by the translation audit (`ignoreKeys`) and the
+ * unused-key reconciler (`dynamicKeys`/`ignoreKeys`). Supports exact keys and a
+ * trailing `*` wildcard, so `errors.*` matches `errors.timeout` but not `errorsX`
+ * is intentional — `errors.*` slices to the prefix `errors.` (the dot is kept).
+ */
+export function makeGlobMatcher(patterns) {
+    if (!patterns || patterns.length === 0)
+        return () => false;
+    const exact = new Set();
+    const prefixes = [];
+    for (const pattern of patterns) {
+        if (pattern.endsWith('*'))
+            prefixes.push(pattern.slice(0, -1));
+        else
+            exact.add(pattern);
+    }
+    return (key) => exact.has(key) || prefixes.some((prefix) => key.startsWith(prefix));
+}

package/dist/audit/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * `@urbicon-ui/i18n/audit` — the dependency-free data-level audit (Feature A,
+ * also on the main entry) plus the source-scanning unused-key detector
+ * (Feature B). The scanner lazily imports `typescript` and `svelte/compiler`
+ * (optional peers), so this subpath stays out of the i18n runtime entry and the
+ * heavy deps load only when a scan actually runs.
+ *
+ * The CLI (`urbicon i18n`) is the filesystem front end over this pure core: it
+ * globs sources, reads bundles, then calls `scanSources` + `findUnusedKeys` +
+ * `auditTranslations` here.
+ */
+export type { I18nMissingKey, Locale } from '../i18n/types.js';
+export { isLocaleSupported, SUPPORTED_LOCALES } from '../i18n/types.js';
+export { collectDeepKeys } from '../utils/deep-keys.js';
+export { makeGlobMatcher } from './glob.js';
+export type { MissingKeyCollector, MissingKeyRecord } from './missing-key-collector.js';
+export { createMissingKeyCollector } from './missing-key-collector.js';
+export type { FindHardcodedOptions, HardcodedFinding } from './scan/hardcoded.js';
+export { findHardcodedStrings } from './scan/hardcoded.js';
+export type { ScanSourcesResult } from './scan/scanner.js';
+export { scanSource, scanSources } from './scan/scanner.js';
+export type { KeyUsageSite, ScanOptions, UsageScan } from './scan/types.js';
+export type { AuditTranslationsOptions, TranslationAuditReport, TranslationFinding, TranslationFindingCode, TranslationFindingSeverity } from './translations.js';
+export { auditTranslations } from './translations.js';
+export type { DynamicPrefixCoverage, FindUnusedOptions, UnusedKeyFinding, UnusedReport, UsedButUndefinedFinding } from './unused.js';
+export { findUnusedKeys } from './unused.js';

package/dist/audit/index.js

@@ -0,0 +1,24 @@
+/**
+ * `@urbicon-ui/i18n/audit` — the dependency-free data-level audit (Feature A,
+ * also on the main entry) plus the source-scanning unused-key detector
+ * (Feature B). The scanner lazily imports `typescript` and `svelte/compiler`
+ * (optional peers), so this subpath stays out of the i18n runtime entry and the
+ * heavy deps load only when a scan actually runs.
+ *
+ * The CLI (`urbicon i18n`) is the filesystem front end over this pure core: it
+ * globs sources, reads bundles, then calls `scanSources` + `findUnusedKeys` +
+ * `auditTranslations` here.
+ */
+export { isLocaleSupported, SUPPORTED_LOCALES } from '../i18n/types.js';
+// Re-exported so the CLI can derive defined keys from a bundle and validate
+// locale tags without importing the main (Svelte-bearing) entry — keeps the node
+// CLI free of Svelte runtime.
+export { collectDeepKeys } from '../utils/deep-keys.js';
+export { makeGlobMatcher } from './glob.js';
+export { createMissingKeyCollector } from './missing-key-collector.js';
+export { findHardcodedStrings } from './scan/hardcoded.js';
+// Usage scanner (Feature B) + hardcoded-string lint (Feature C).
+export { scanSource, scanSources } from './scan/scanner.js';
+// Data-level translation audit (Feature A).
+export { auditTranslations } from './translations.js';
+export { findUnusedKeys } from './unused.js';

package/dist/audit/missing-key-collector.d.ts

@@ -0,0 +1,39 @@
+/**
+ * `createMissingKeyCollector` — a ready-made `onMissingKey` sink that records
+ * every resolved-nowhere key so a test or E2E run can assert "no missing keys
+ * were hit", or feed observed dynamic keys into the unused-key scanner.
+ *
+ * ```ts
+ * const misses = createMissingKeyCollector();
+ * configureI18n({ onMissingKey: misses.onMissingKey });
+ * // … render / exercise the app …
+ * expect(misses.isClean()).toBe(true); // fail-loud on any raw-key render
+ * ```
+ *
+ * This is the runtime counterpart to {@link auditTranslations}: the audit catches
+ * keys missing *between bundles* statically; the collector catches keys a code
+ * path actually *requested* but no bundle defined — including dynamically built
+ * ones a static scan cannot see.
+ */
+import type { I18nMissingKey, Locale } from '../i18n/types.js';
+export interface MissingKeyRecord {
+    /** The unresolved key. */
+    key: string;
+    /** Active locale when the miss occurred. */
+    locale: Locale;
+    /** Package scope, if the call was package-scoped. */
+    packageName?: string;
+    /** How many times this (key, locale, package) miss was observed. */
+    count: number;
+}
+export interface MissingKeyCollector {
+    /** Wire this into `configureI18n({ onMissingKey })`. */
+    onMissingKey: (info: I18nMissingKey) => void;
+    /** Distinct misses observed, sorted by key then locale, with hit counts. */
+    report(): MissingKeyRecord[];
+    /** Whether no miss has been observed (convenience for assertions). */
+    isClean(): boolean;
+    /** Forget everything observed so far (e.g. in a `beforeEach`). */
+    reset(): void;
+}
+export declare function createMissingKeyCollector(): MissingKeyCollector;

package/dist/audit/missing-key-collector.js

@@ -0,0 +1,46 @@
+/**
+ * `createMissingKeyCollector` — a ready-made `onMissingKey` sink that records
+ * every resolved-nowhere key so a test or E2E run can assert "no missing keys
+ * were hit", or feed observed dynamic keys into the unused-key scanner.
+ *
+ * ```ts
+ * const misses = createMissingKeyCollector();
+ * configureI18n({ onMissingKey: misses.onMissingKey });
+ * // … render / exercise the app …
+ * expect(misses.isClean()).toBe(true); // fail-loud on any raw-key render
+ * ```
+ *
+ * This is the runtime counterpart to {@link auditTranslations}: the audit catches
+ * keys missing *between bundles* statically; the collector catches keys a code
+ * path actually *requested* but no bundle defined — including dynamically built
+ * ones a static scan cannot see.
+ */
+export function createMissingKeyCollector() {
+    const records = new Map();
+    const idOf = (info) => `${info.packageName ?? ''}::${info.locale}::${info.key}`;
+    return {
+        onMissingKey(info) {
+            const id = idOf(info);
+            const existing = records.get(id);
+            if (existing) {
+                existing.count += 1;
+                return;
+            }
+            records.set(id, {
+                key: info.key,
+                locale: info.locale,
+                packageName: info.packageName,
+                count: 1
+            });
+        },
+        report() {
+            return [...records.values()].sort((a, b) => a.key.localeCompare(b.key) || a.locale.localeCompare(b.locale));
+        },
+        isClean() {
+            return records.size === 0;
+        },
+        reset() {
+            records.clear();
+        }
+    };
+}

package/dist/audit/scan/hardcoded.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Hardcoded-string lint (Feature C) — surface literal UI copy in `.svelte` markup
+ * that was never routed through i18n. Heuristic and therefore ADVISORY by default
+ * (the CLI gates it only on opt-in): it flags plain markup text and a small set of
+ * human-readable attributes (`aria-label`, `title`, `placeholder`, `alt`), skips
+ * code-shaped strings, and never looks inside `<script>`/`<style>` (those hold no
+ * Text/Attribute AST nodes) or a `<T>` component (already translated).
+ */
+export interface HardcodedFinding {
+    file: string;
+    line: number;
+    /** The offending literal, trimmed. */
+    text: string;
+    /** Markup text content, or a flagged attribute value. */
+    kind: 'text' | 'attribute';
+    /** The attribute name when `kind === 'attribute'`. */
+    attribute?: string;
+    context: string;
+}
+export interface FindHardcodedOptions {
+    /** Exact strings or `prefix*` globs to never flag. */
+    ignoreStrings?: string[];
+    /** Attribute names to check (default: aria-label, title, placeholder, alt). */
+    attributes?: string[];
+    /** Length window for a candidate (default 3–80). */
+    minLength?: number;
+    maxLength?: number;
+}
+export declare function findHardcodedStrings(code: string, file: string, options?: FindHardcodedOptions): Promise<HardcodedFinding[]>;

package/dist/audit/scan/hardcoded.js

@@ -0,0 +1,86 @@
+/**
+ * Hardcoded-string lint (Feature C) — surface literal UI copy in `.svelte` markup
+ * that was never routed through i18n. Heuristic and therefore ADVISORY by default
+ * (the CLI gates it only on opt-in): it flags plain markup text and a small set of
+ * human-readable attributes (`aria-label`, `title`, `placeholder`, `alt`), skips
+ * code-shaped strings, and never looks inside `<script>`/`<style>` (those hold no
+ * Text/Attribute AST nodes) or a `<T>` component (already translated).
+ */
+import { makeGlobMatcher } from '../glob.js';
+import { makeContextAt, makeLineAt } from './recognize.js';
+import { asNodes, asString, loadParse, walkAst } from './svelte-ast.js';
+const DEFAULT_ATTRIBUTES = ['aria-label', 'title', 'placeholder', 'alt'];
+/** Does a trimmed string read like human UI copy rather than code/identifiers/data? */
+function looksLikeCopy(text, min, max) {
+    if (text.length < min || text.length > max)
+        return false;
+    if (!/[a-zA-Z]/.test(text))
+        return false; // needs a letter
+    if (/^https?:\/\//.test(text))
+        return false; // URL
+    if (/^[\w.-]+@[\w.-]+$/.test(text))
+        return false; // email
+    if (/^[A-Z0-9_]+$/.test(text))
+        return false; // CONST_CASE
+    if (/^\w+(\.\w+)+$/.test(text))
+        return false; // dotted key / filename
+    if (/^[a-z][a-zA-Z0-9]*$/.test(text))
+        return false; // single camelCase token (variable-ish)
+    if (/^[\d\s.,:;/–—-]+$/.test(text))
+        return false; // numbers / dates / separators
+    if (/[{}<>=]/.test(text))
+        return false; // markup/code fragments
+    return true;
+}
+export async function findHardcodedStrings(code, file, options = {}) {
+    const parse = await loadParse();
+    const ast = parse(code, { modern: true });
+    const lineAt = makeLineAt(code);
+    const contextAt = makeContextAt(code);
+    const checked = new Set((options.attributes ?? DEFAULT_ATTRIBUTES).map((name) => name.toLowerCase()));
+    const isIgnored = makeGlobMatcher(options.ignoreStrings);
+    const min = options.minLength ?? 3;
+    const max = options.maxLength ?? 80;
+    const findings = [];
+    const seen = new Set(); // dedupe identical text@line
+    const skipText = new WeakSet(); // attribute-value Text + <T> subtree Text
+    const consider = (text, line, kind, attribute) => {
+        const trimmed = text?.trim();
+        if (!trimmed || isIgnored(trimmed) || !looksLikeCopy(trimmed, min, max))
+            return;
+        const id = `${line}:${trimmed}`;
+        if (seen.has(id))
+            return;
+        seen.add(id);
+        findings.push({ file, line, text: trimmed, kind, attribute, context: contextAt(line) });
+    };
+    // Pass 1 — attributes (and collect Text to exclude from the markup pass). Text/
+    // Attribute nodes exist only in the template, so walking the whole Root is safe.
+    walkAst(ast, (node) => {
+        if (node.type === 'Attribute') {
+            const values = asNodes(node.value);
+            for (const value of values)
+                if (value.type === 'Text')
+                    skipText.add(value);
+            const name = asString(node.name)?.toLowerCase();
+            const single = values.length === 1 ? values[0] : undefined;
+            if (name && checked.has(name) && single?.type === 'Text') {
+                consider(asString(single.data), lineAt(node.start ?? 0), 'attribute', name);
+            }
+        }
+        else if (node.type === 'Component' && asString(node.name) === 'T') {
+            walkAst(node, (inner) => {
+                if (inner.type === 'Text')
+                    skipText.add(inner);
+            });
+        }
+    });
+    // Pass 2 — markup text not already claimed by an attribute or a <T> subtree.
+    walkAst(ast, (node) => {
+        if (node.type === 'Text' && !skipText.has(node)) {
+            consider(asString(node.data), lineAt(node.start ?? 0), 'text');
+        }
+    });
+    findings.sort((a, b) => a.line - b.line || a.text.localeCompare(b.text));
+    return findings;
+}

package/dist/audit/scan/recognize.d.ts

@@ -0,0 +1,25 @@
+/**
+ * AST-agnostic recognition heuristics + small source helpers shared by both
+ * walkers. The crux of B1 (which calls are translation calls) lives here so the
+ * TypeScript and Svelte walkers stay thin.
+ */
+import type { ExtractedKey, KeyUsageSite, UsageScan } from './types.js';
+export declare function isFactoryName(name: string): boolean;
+export declare function isRenderMethod(name: string): boolean;
+export declare function isProbeMethod(name: string): boolean;
+export declare function isKeyMethod(name: string): boolean;
+/** File-local identifiers bound to a translate function, split render vs probe. */
+export interface Bindings {
+    render: Set<string>;
+    probe: Set<string>;
+}
+export declare function createBindings(extra?: string[]): Bindings;
+export declare function createScan(): UsageScan;
+/** Route one call's extracted keys into the scan; an empty extraction is an opaque site. */
+export declare function recordKeyCall(scan: UsageScan, extractions: ExtractedKey[], site: KeyUsageSite, isProbe: boolean): void;
+/** Combine per-file scans into one. */
+export declare function mergeScans(scans: UsageScan[]): UsageScan;
+/** A fast 1-based line lookup from a character offset, precomputed once per file. */
+export declare function makeLineAt(code: string): (offset: number) => number;
+/** The trimmed text of a 1-based line, for report context. */
+export declare function makeContextAt(code: string): (line: number) => string;

package/dist/audit/scan/recognize.js

@@ -0,0 +1,110 @@
+/**
+ * AST-agnostic recognition heuristics + small source helpers shared by both
+ * walkers. The crux of B1 (which calls are translation calls) lives here so the
+ * TypeScript and Svelte walkers stay thin.
+ */
+// A factory hook whose result is (or yields) a translate function: the global
+// `useI18n` / `useTranslate`, plus the per-package re-exports consumers make
+// (`useBlocksI18n`, `useTableI18n`, `useFooTranslate`). Matching by this naming
+// convention is what lets the scanner discover arbitrarily-named local aliases.
+const FACTORY_RE = /^use([A-Z]\w*)?(I18n|Translate)$/;
+export function isFactoryName(name) {
+    return FACTORY_RE.test(name);
+}
+const RENDER_METHODS = new Set(['t', 'plural', 'translate']);
+const PROBE_METHODS = new Set(['exists']);
+export function isRenderMethod(name) {
+    return RENDER_METHODS.has(name);
+}
+export function isProbeMethod(name) {
+    return PROBE_METHODS.has(name);
+}
+export function isKeyMethod(name) {
+    return RENDER_METHODS.has(name) || PROBE_METHODS.has(name);
+}
+/** Bare identifiers that are always translation render-calls, even without a binding. */
+const DEFAULT_RENDER_IDENTIFIERS = ['t', '$t'];
+export function createBindings(extra = []) {
+    return { render: new Set([...DEFAULT_RENDER_IDENTIFIERS, ...extra]), probe: new Set() };
+}
+export function createScan() {
+    return {
+        staticKeys: new Map(),
+        probeKeys: new Set(),
+        dynamicPrefixes: [],
+        opaqueSites: [],
+        literalPool: new Set()
+    };
+}
+/** Route one call's extracted keys into the scan; an empty extraction is an opaque site. */
+export function recordKeyCall(scan, extractions, site, isProbe) {
+    if (extractions.length === 0) {
+        scan.opaqueSites.push(site);
+        return;
+    }
+    for (const extracted of extractions) {
+        if (extracted.kind === 'static') {
+            if (isProbe) {
+                scan.probeKeys.add(extracted.value);
+            }
+            else {
+                const sites = scan.staticKeys.get(extracted.value);
+                if (sites)
+                    sites.push(site);
+                else
+                    scan.staticKeys.set(extracted.value, [site]);
+            }
+        }
+        else if (extracted.kind === 'prefix') {
+            scan.dynamicPrefixes.push({ prefix: extracted.prefix, site });
+        }
+        else {
+            scan.opaqueSites.push(site);
+        }
+    }
+}
+/** Combine per-file scans into one. */
+export function mergeScans(scans) {
+    const merged = createScan();
+    for (const scan of scans) {
+        for (const [key, sites] of scan.staticKeys) {
+            const existing = merged.staticKeys.get(key);
+            if (existing)
+                existing.push(...sites);
+            else
+                merged.staticKeys.set(key, [...sites]);
+        }
+        for (const key of scan.probeKeys)
+            merged.probeKeys.add(key);
+        merged.dynamicPrefixes.push(...scan.dynamicPrefixes);
+        merged.opaqueSites.push(...scan.opaqueSites);
+        for (const literal of scan.literalPool)
+            merged.literalPool.add(literal);
+    }
+    return merged;
+}
+/** A fast 1-based line lookup from a character offset, precomputed once per file. */
+export function makeLineAt(code) {
+    const starts = [0];
+    for (let i = 0; i < code.length; i++) {
+        if (code[i] === '\n')
+            starts.push(i + 1);
+    }
+    return (offset) => {
+        let lo = 0;
+        let hi = starts.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi + 1) >> 1;
+            if (starts[mid] <= offset)
+                lo = mid;
+            else
+                hi = mid - 1;
+        }
+        return lo + 1;
+    };
+}
+/** The trimmed text of a 1-based line, for report context. */
+export function makeContextAt(code) {
+    const lines = code.split('\n');
+    return (line) => (lines[line - 1] ?? '').trim();
+}

package/dist/audit/scan/scanner.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Source-scanner entry: dispatch by extension to the Svelte or TypeScript walker,
+ * and a multi-file helper that merges per-file scans while surfacing (never
+ * swallowing) files that failed to parse.
+ */
+import type { ScanOptions, UsageScan } from './types.js';
+/** Scan one source's text for translation-key usage. */
+export declare function scanSource(code: string, file: string, options?: ScanOptions): Promise<UsageScan>;
+export interface ScanSourcesResult {
+    scan: UsageScan;
+    /** Files that could not be parsed — reported, not silently dropped. */
+    errors: Array<{
+        file: string;
+        message: string;
+    }>;
+}
+/** Scan many sources concurrently and merge them; parse failures become `errors`. */
+export declare function scanSources(files: Array<{
+    file: string;
+    code: string;
+}>, options?: ScanOptions): Promise<ScanSourcesResult>;

package/dist/audit/scan/scanner.js

@@ -0,0 +1,26 @@
+/**
+ * Source-scanner entry: dispatch by extension to the Svelte or TypeScript walker,
+ * and a multi-file helper that merges per-file scans while surfacing (never
+ * swallowing) files that failed to parse.
+ */
+import { mergeScans } from './recognize.js';
+import { scanSvelte } from './svelte-walker.js';
+import { scanTs } from './ts-walker.js';
+/** Scan one source's text for translation-key usage. */
+export function scanSource(code, file, options = {}) {
+    return file.endsWith('.svelte') ? scanSvelte(code, file, options) : scanTs(code, file, options);
+}
+/** Scan many sources concurrently and merge them; parse failures become `errors`. */
+export async function scanSources(files, options = {}) {
+    const errors = [];
+    const scans = [];
+    await Promise.all(files.map(async ({ file, code }) => {
+        try {
+            scans.push(await scanSource(code, file, options));
+        }
+        catch (error) {
+            errors.push({ file, message: error instanceof Error ? error.message : String(error) });
+        }
+    }));
+    return { scan: mergeScans(scans), errors };
+}

package/dist/audit/scan/svelte-ast.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Shared Svelte-AST plumbing for the usage walker and the hardcoded-string lint:
+ * the lazily-imported `parse`, a permissive `unknown`-based node accessor set, and
+ * one iterative cycle-safe DFS. Kept dependency-light — `svelte/compiler` loads
+ * only when a `.svelte` source is actually scanned.
+ */
+type SvelteParse = typeof import('svelte/compiler')['parse'];
+export declare function loadParse(): Promise<SvelteParse>;
+export interface AstNode {
+    type: string;
+    start?: number;
+    [key: string]: unknown;
+}
+export declare const asNode: (value: unknown) => AstNode | undefined;
+export declare const asNodes: (value: unknown) => AstNode[];
+export declare const asString: (value: unknown) => string | undefined;
+/** A TemplateElement's text. `.value` is a plain `{ raw, cooked }` (no `.type`). */
+export declare const cookedOf: (quasi: AstNode | undefined) => string | undefined;
+/** Iterative DFS over the whole AST; skips non-structural keys and guards cycles. */
+export declare function walkAst(root: unknown, visit: (node: AstNode) => void): void;
+export {};

package/dist/audit/scan/svelte-ast.js

@@ -0,0 +1,61 @@
+/**
+ * Shared Svelte-AST plumbing for the usage walker and the hardcoded-string lint:
+ * the lazily-imported `parse`, a permissive `unknown`-based node accessor set, and
+ * one iterative cycle-safe DFS. Kept dependency-light — `svelte/compiler` loads
+ * only when a `.svelte` source is actually scanned.
+ */
+let parsePromise;
+export async function loadParse() {
+    if (!parsePromise) {
+        parsePromise = (async () => {
+            try {
+                return (await import('svelte/compiler')).parse;
+            }
+            catch {
+                throw new Error('@urbicon-ui/i18n/audit needs the "svelte" peer to scan .svelte sources — install it.');
+            }
+        })();
+    }
+    return parsePromise;
+}
+export const asNode = (value) => value && typeof value === 'object' && typeof value.type === 'string'
+    ? value
+    : undefined;
+export const asNodes = (value) => Array.isArray(value) ? value.flatMap((item) => asNode(item) ?? []) : [];
+export const asString = (value) => typeof value === 'string' ? value : undefined;
+/** A TemplateElement's text. `.value` is a plain `{ raw, cooked }` (no `.type`). */
+export const cookedOf = (quasi) => {
+    const value = quasi?.value;
+    return asString(value?.cooked) ?? asString(value?.raw);
+};
+/** Iterative DFS over the whole AST; skips non-structural keys and guards cycles. */
+export function walkAst(root, visit) {
+    const seen = new WeakSet();
+    const stack = [root];
+    while (stack.length) {
+        const current = stack.pop();
+        if (!current || typeof current !== 'object' || seen.has(current))
+            continue;
+        seen.add(current);
+        if (Array.isArray(current)) {
+            for (const item of current)
+                stack.push(item);
+            continue;
+        }
+        const node = current;
+        if (typeof node.type === 'string')
+            visit(node);
+        for (const key in node) {
+            if (key === 'type' ||
+                key === 'loc' ||
+                key === 'parent' ||
+                key === 'metadata' ||
+                key === 'name_loc') {
+                continue;
+            }
+            const child = node[key];
+            if (child && typeof child === 'object')
+                stack.push(child);
+        }
+    }
+}

package/dist/audit/scan/svelte-walker.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Svelte usage walker. `svelte/compiler.parse` (lazily imported) yields one AST
+ * whose Root holds the module/instance scripts (estree) *and* the template, so a
+ * single iterative walk reaches every translate call — script-level and inside
+ * markup expressions — with original-source offsets for accurate line numbers.
+ *
+ * On top of the estree handling (mirroring the TypeScript walker) it understands
+ * the `<T key="…">` component, the markup form of a translation render-call.
+ */
+import type { ScanOptions, UsageScan } from './types.js';
+export declare function scanSvelte(code: string, file: string, options?: ScanOptions): Promise<UsageScan>;