@svelte-vitals/core 0.55.1 → 0.55.3

package/dist/{json-TIGneC1p.d.ts → json-DmLgFEwV.d.ts}

@@ -46,6 +46,15 @@ interface EachBlockFact {
   line: number;
   /** Set when the block's key expression is its index binding or a trivial coercion of it — `(i)`, `(String(i))`, `(Number(i))`, `` (`${i}`) ``, `(i.toString())`, `(i + '')` — correctness/each-index-key. */
   indexKey?: boolean;
+  /**
+   * The import the block iterates, set on an unkeyed or index-keyed block over an imported binding
+   * (`xs`, or `ns.xs` of `import * as ns`) the component only reads. Core cannot see the module
+   * behind it; a collector that can drops the block when that export is a constant list.
+   */
+  importedList?: {
+    source: string;
+    imported: string;
+  };
 }
 /** An `$effect(...)` / `$effect.pre(...)` call in a component's instance script. */
 interface EffectFact {
@@ -172,6 +181,8 @@ interface AriaElementFact {
   /** Set when the element also carries a spread attribute — its full attribute set is
    *  unknowable, so required-prop presence checks must treat it as satisfied (a11y/required-aria-props). */
   hasSpread?: true;
+  /** Set when the element carries a `use:` action, which may set `role` at runtime (svelte-dnd-action's handles do). */
+  hasAction?: true;
 }
 /**
  * Every element in a component with its literal attribute names — the input for the rules that
@@ -238,12 +249,15 @@ interface ComponentFacts {
    * architecture/route-component-import). `type` marks a declaration that contributes **no runtime
    * value binding** — either `import type …`, or one whose every specifier is inline-typed
    * (`import { type A } from …`). A specifier-less side-effect import is not marked: it still loads
-   * the module. Optional, so existing external constructors of `ComponentFacts` are unaffected.
+   * the module. `named` marks a value declaration binding only named exports — no default,
+   * `default as`, or namespace — so it cannot render an imported component. Both optional, so
+   * existing external constructors of `ComponentFacts` are unaffected.
    */
   importSpans: {
     source: string;
     line: number;
     type?: true;
+    named?: true;
   }[];
   /** Value `import * as X from '<bare pkg>'` namespace imports (type-only excluded) — performance/namespace-import. */
   namespaceImports: {
@@ -374,6 +388,71 @@ declare function emptyComponentFacts(file: string): ComponentFacts;
  */
 declare function collectComponentFacts(rt: Runtime, cwd: string): Promise<ComponentFacts[]>;
 //#endregion
+//#region src/head.d.ts
+/**
+ * A normalized head tag. The mode-independent boundary (design §8): the static
+ * SourceHeadProvider (CLI, via the runtime-abstracted `HeadProvider` below) and
+ * the rendered collector (`@svelte-vitals/vite`, build-time Node) both emit
+ * these, so rules never need to know which mode produced them.
+ */
+interface HeadTag {
+  kind: 'title' | 'meta' | 'link' | 'jsonld' | 'script';
+  /** <meta name="...">. */
+  name?: string;
+  /** <meta property="..."> (e.g. og:image). */
+  property?: string;
+  /** <link rel="...">. */
+  rel?: string;
+  /** <link as="..."> keyword (e.g. 'font') when statically literal; undefined when absent or dynamically bound. */
+  as?: string;
+  /** True when a <link> has an `as` attribute at all (literal or dynamic). Distinguishes "no as" from "dynamic as". */
+  hasAs?: boolean;
+  /** True when a <link> has a `crossorigin` attribute (presence only; value is irrelevant to the checks). */
+  hasCrossorigin?: boolean;
+  /** True when a <meta name="robots"> literal content contains `noindex`/`none`. Undefined when dynamic or absent. */
+  noindex?: boolean;
+  /** Literal `<script type="application/ld+json">` content, set only when the script is static. Undefined when dynamic. */
+  jsonld?: string;
+  /** Literal visible text of a static <title> or <meta name="description"> content, set only when static. Undefined when dynamic. */
+  text?: string;
+  /** Literal `hreflang` of a `<link rel="alternate">` (e.g. 'en', 'en-US', 'x-default'). Undefined when dynamic/absent. */
+  hreflang?: string;
+  /** Literal href (link) / src (script) URL when static — used for third-party origin analysis (performance/preconnect). */
+  href?: string;
+  /** True for a render-blocking `<script src>` in <head> (no defer/async/module) (performance/render-blocking-script). */
+  blocking?: boolean;
+  /** Rendered only in the browser, by a component loaded with `import()` (static mode): absent from a server-rendered route's HTML. */
+  clientOnly?: true;
+  /** Where this tag was set relative to the route. Never 'none' (absence = no tag). */
+  presence: Exclude<Presence, 'none'>;
+  /** Whether the tag's value is static/dynamic/absent (design §4). */
+  value: Value;
+  /** Source file the tag came from (static mode); unset on a rendered head. */
+  file?: string;
+}
+/** Whether a `<link>`'s `rel` holds `token`: `rel` is a set of space-separated keywords (`dns-prefetch preconnect`). */
+declare function hasRel(tag: {
+  rel?: string;
+}, token: string): boolean;
+/** Resolved effective head for a single route (design §8). */
+interface ResolvedHead {
+  /** Route path, e.g. '/blog/[slug]'. */
+  route: string;
+  /** Which provider produced this. */
+  source: 'static' | 'rendered';
+  /** Effective head tags after layout-chain composition. */
+  tags: HeadTag[];
+  /** Representative source file for the route (used for issue locations). */
+  file: string;
+}
+/**
+ * Whether a `type` attribute (undefined = absent) makes a `<script>` a classic,
+ * render-blocking-capable script. Per the HTML spec, absent and the literal empty string are
+ * classic; any other value is ASCII-whitespace-stripped and must match a JavaScript MIME type —
+ * so a whitespace-only `type` is a data block, not a classic script.
+ */
+declare function isClassicScriptType(type: string | undefined): boolean;
+//#endregion
 //#region src/types.d.ts
 type Severity = 'critical' | 'warning' | 'info';
 /** Where a head tag is set, relative to the route being evaluated (design §4). */
@@ -414,6 +493,13 @@ interface KitAlias {
    *   is how Kit stops the plain key from swallowing the nested specifiers.
    */
   match: 'prefix' | 'contents' | 'exact';
+  /** Appended after the matched rest of a `contents` specifier: the text after `*` in an exports pattern target (`./src/*.js`). */
+  suffix?: string;
+  /**
+   * The directory the entry's targets belong to, when it is wider than `replacement`: a workspace
+   * package's directory, so relative imports between its files resolve above the project root.
+   */
+  root?: string;
 }
 /** Project-wide facts precomputed by the runtime layer for project-scope rules (design §10). */
 interface Project {
@@ -447,6 +533,8 @@ interface Project {
     value?: string;
     file: string;
   };
+  /** `kit.router.type: 'hash'` in `svelte.config.{js,ts}`: SvelteKit then never server-renders or prerenders a page. */
+  kitHashRouter?: true;
   /**
    * The project's compiled SvelteKit alias entries, in Kit's own order (`$lib` first), read from
    * `svelte.config.{js,ts}`. Absent means no config was read — resolution then falls back to
@@ -454,6 +542,18 @@ interface Project {
    * list is never empty: `$lib` is always prepended.
    */
   kitAliases?: KitAlias[];
+  /**
+   * `kitAliases` plus the workspace packages the app's package.json declares, which component
+   * resolution (a route's composition, and each-key's imported lists) follows. Absent when the app
+   * declares none. Rules that resolve imports read `kitAliases`.
+   */
+  componentAliases?: KitAlias[];
+  /**
+   * `componentAliases` (else `kitAliases`) plus the Svelte packages installed in `node_modules` that
+   * the app declares. Only the `<head>`/heading walk reads it, so the a11y composition and each-key
+   * stay on `componentAliases`. Absent when no such package is installed.
+   */
+  headAliases?: KitAlias[];
   /**
    * Whether `src/app.html` opens with `<!doctype html>` (a11y/doctype). Set from the same read
    * as `htmlLang`; absent when the file wasn't read (missing or unreadable) — the rule stays
@@ -467,6 +567,13 @@ interface Project {
   }[];
   /** Distinct lowercased tag names inside `app.html`'s `<body>` (a11y/required-element's presence set; static mode). */
   appHtmlBodyTags?: string[];
+  /**
+   * The shell's own literal `<title>`, `<meta name|property>` (except charset/viewport) and
+   * `<link rel="canonical">`, rendered on every route beside `%sveltekit.head%` (static mode).
+   */
+  appHtmlHeadTags?: Omit<HeadTag, 'presence' | 'file'>[];
+  /** HTML comments inside the shell's `<head>` (`<!--seo-head-->`), which a `transformPageChunk` hook may replace with tags. */
+  appHtmlHeadComments?: string[];
 }
 declare const defaultProject: Project;
 /** A concrete, agent-actionable remediation for a finding (design §10, issue #18). */
@@ -601,65 +708,6 @@ declare function formatMarkdownReport(results: Result[], config: Config, meta: {
   version: string;
 }): string;
 //#endregion
-//#region src/head.d.ts
-/**
- * A normalized head tag. The mode-independent boundary (design §8): the static
- * SourceHeadProvider (CLI, via the runtime-abstracted `HeadProvider` below) and
- * the rendered collector (`@svelte-vitals/vite`, build-time Node) both emit
- * these, so rules never need to know which mode produced them.
- */
-interface HeadTag {
-  kind: 'title' | 'meta' | 'link' | 'jsonld' | 'script';
-  /** <meta name="...">. */
-  name?: string;
-  /** <meta property="..."> (e.g. og:image). */
-  property?: string;
-  /** <link rel="...">. */
-  rel?: string;
-  /** <link as="..."> keyword (e.g. 'font') when statically literal; undefined when absent or dynamically bound. */
-  as?: string;
-  /** True when a <link> has an `as` attribute at all (literal or dynamic). Distinguishes "no as" from "dynamic as". */
-  hasAs?: boolean;
-  /** True when a <link> has a `crossorigin` attribute (presence only; value is irrelevant to the checks). */
-  hasCrossorigin?: boolean;
-  /** True when a <meta name="robots"> literal content contains `noindex`/`none`. Undefined when dynamic or absent. */
-  noindex?: boolean;
-  /** Literal `<script type="application/ld+json">` content, set only when the script is static. Undefined when dynamic. */
-  jsonld?: string;
-  /** Literal visible text of a static <title> or <meta name="description"> content, set only when static. Undefined when dynamic. */
-  text?: string;
-  /** Literal `hreflang` of a `<link rel="alternate">` (e.g. 'en', 'en-US', 'x-default'). Undefined when dynamic/absent. */
-  hreflang?: string;
-  /** Literal href (link) / src (script) URL when static — used for third-party origin analysis (performance/preconnect). */
-  href?: string;
-  /** True for a render-blocking `<script src>` in <head> (no defer/async/module) (performance/render-blocking-script). */
-  blocking?: boolean;
-  /** Where this tag was set relative to the route. Never 'none' (absence = no tag). */
-  presence: Exclude<Presence, 'none'>;
-  /** Whether the tag's value is static/dynamic/absent (design §4). */
-  value: Value;
-  /** Source file the tag came from (static mode); unset on a rendered head. */
-  file?: string;
-}
-/** Resolved effective head for a single route (design §8). */
-interface ResolvedHead {
-  /** Route path, e.g. '/blog/[slug]'. */
-  route: string;
-  /** Which provider produced this. */
-  source: 'static' | 'rendered';
-  /** Effective head tags after layout-chain composition. */
-  tags: HeadTag[];
-  /** Representative source file for the route (used for issue locations). */
-  file: string;
-}
-/**
- * Whether a `type` attribute (undefined = absent) makes a `<script>` a classic,
- * render-blocking-capable script. Per the HTML spec, absent and the literal empty string are
- * classic; any other value is ASCII-whitespace-stripped and must match a JavaScript MIME type —
- * so a whitespace-only `type` is a data block, not a classic script.
- */
-declare function isClassicScriptType(type: string | undefined): boolean;
-//#endregion
 //#region src/images.d.ts
 /**
  * A normalized <img> occurrence — the mode-independent boundary for Performance
@@ -674,52 +722,23 @@ interface ImageInfo {
   hasAlt: boolean;
   /** True when the <img> has a literal `loading="lazy"` (performance/lcp-image). Dynamic/spread → false. */
   lazy: boolean;
-  /** True when the <img> has a `srcset` attribute (performance/responsive-image). */
+  /** True when the <img>, or a `<source>` of its `<picture>`, has a `srcset` attribute (performance/responsive-image). */
   hasSrcset: boolean;
+  /** True when the <img>'s src is known to be an SVG (`isSvgSrc`; performance/responsive-image). */
+  svg?: boolean;
   /** 1-based source line, or 0 if unknown. */
   line: number;
   /** Source file the <img> came from. */
   file: string;
 }
+/** A `.svg` path (query and fragment ignored) or an inline `data:image/svg+xml` URI. */
+declare function isSvgSrc(src: string): boolean;
 /** Resolved <img> elements for a single route (page + layout chain). */
 interface ResolvedImages {
   route: string;
   images: ImageInfo[];
 }
 //#endregion
-//#region src/headings.d.ts
-/**
- * A normalized page-body heading occurrence — the mode-independent boundary for
- * the heading-hierarchy rule (mirrors images.ts). Both providers collect these
- * so seo/single-h1 never needs to know which mode produced them.
- */
-interface HeadingInfo {
-  /** Heading level 1–6 (the `n` in <hn>). */
-  level: number;
-  /** 1-based source line, or 0 if unknown (rendered mode does not track lines). */
-  line: number;
-  /** Source file the heading came from. */
-  file: string;
-}
-/** Resolved page-body headings for a single route (page + layout chain). */
-interface ResolvedHeadings {
-  route: string;
-  headings: HeadingInfo[];
-  /**
-   * Headings found in child components rendered (transitively) by this route's
-   * chain files — source mode only; absent in rendered mode. Kept separate from
-   * `headings` because their position in document order is unknown: safe for
-   * counting (seo/single-h1), unusable for outline order (seo/heading-level-skip).
-   */
-  componentHeadings?: HeadingInfo[];
-  /**
-   * This route renders a `<svelte:element>` that may be a heading whose level is not
-   * statically determinable (`this={`h${n}`}`, an identifier, …) — source mode only.
-   * Counting stays as-is; only the "no <h1> anywhere" claim becomes unsafe to make.
-   */
-  dynamicHeading?: boolean;
-}
-//#endregion
 //#region src/a11y.d.ts
 /** One step of a template branch address: which exclusive block, and which arm of it. */
 interface BranchStep {
@@ -727,6 +746,10 @@ interface BranchStep {
   group: number;
   /** branch index within the group (if: 0..n consequent→else; await: 0=pending,1=then,2=catch) */
   branch: number;
+  /** A heading renders here whichever arm is taken: every arm of the block has one, a prop the use passes decides the arm, or the place's own conditions select it. */
+  always?: true;
+  /** The body of an `{#each}` (headings only): it may render any number of times, or none. */
+  repeat?: true;
 }
 /** Where a folded occurrence sits, for the finding location. */
 interface A11yOccurrenceInfo {
@@ -871,6 +894,56 @@ declare function isTopFragment(id: string): boolean;
  */
 declare function stripTextDirective(fragment: string): string;
 //#endregion
+//#region src/headings.d.ts
+/**
+ * A normalized page-body heading occurrence — the mode-independent boundary for
+ * the heading-hierarchy rule (mirrors images.ts). Both providers collect these
+ * so seo/single-h1 never needs to know which mode produced them.
+ */
+interface HeadingInfo {
+  /** Heading level: 1–6 (the `n` in <hn>), an ARIA heading's `aria-level`, or 0 when the source does not determine it (source mode). */
+  level: number;
+  /** 1-based source line, or 0 if unknown (rendered mode does not track lines). */
+  line: number;
+  /** Source file the heading came from. */
+  file: string;
+  /**
+   * The `{#if}`/`{#await}`/`<svelte:boundary>` arms it sits in (source mode; absent when
+   * unconditional), including those of the component usages and layout `{@render children()}`
+   * above it. Group numbers are route-wide: each file instance has its own range.
+   */
+  path?: BranchStep[];
+  /**
+   * Its place in document order (source mode): the source offset of each placement from the route's
+   * outermost file down — a layout's `{@render children()}`, a component's tag, a snippet's
+   * `{@render}` — and last its own. Compared element by element (`documentOrder`); rendered-mode
+   * headings carry none and arrive in order.
+   */
+  order?: number[];
+  /** A `role="heading"` element: it holds its outline level for seo/heading-level-skip, but is not an `<h1>` for seo/single-h1. */
+  aria?: true;
+}
+/** Resolved page-body headings for a single route (page + layout chain). */
+interface ResolvedHeadings {
+  route: string;
+  headings: HeadingInfo[];
+  /**
+   * Headings found in child components rendered (transitively) by this route's
+   * chain files — source mode only; absent in rendered mode. Their `order` places
+   * them among `headings`.
+   */
+  componentHeadings?: HeadingInfo[];
+  /**
+   * This route may render a heading whose level is not statically determinable: a
+   * `<svelte:element>` (`this={`h${n}`}`, an identifier, …), or a component that cannot be
+   * followed but is given a literal `h1` element prop (`<Heading tag="h1">`) — source mode only.
+   * Counting stays as-is; only the "no <h1> anywhere" claim becomes unsafe to make.
+   */
+  dynamicHeading?: boolean;
+  /** `dynamicHeading`, but from a component loaded with `import()` — source-mode collection folds it in only on routes never server-rendered. */
+  clientOnlyHeading?: boolean;
+}
+//#endregion
 //#region src/kit-module.d.ts
 /**
  * Facts parsed from one SvelteKit route/hooks file for the SSR shared-state rules
@@ -912,6 +985,13 @@ interface KitModuleFacts {
     resolved: string;
     line: number;
   }[];
+  /** The targets of the `.set()`/`.update()` writes recorded in `importedStateWrites` from a handler, for the collector to drop those that reach a persistence client. */
+  storeWriteTargets?: {
+    name: string;
+    imported: string;
+    resolved: string;
+    line: number;
+  }[];
   /** Value imports whose specifier resolves to a repo-local `.svelte.ts`/`.svelte.js` runes module (security/shared-state-import). */
   runesModuleImports: {
     source: string;
@@ -925,7 +1005,7 @@ interface KitModuleFacts {
     line: number;
     inHandler: boolean;
   }[];
-  /** Browser-global reads in server-executed positions — top level, handler bodies, the `init` hook (correctness/server-browser-global). Empty when the file itself exports `ssr = false`. */
+  /** Browser-global reads in server-executed positions — top level, handler bodies, the `init` hook (correctness/server-browser-global). Empty when the file itself exports a literal `ssr = false`. */
   browserGlobalRefs: {
     name: string;
     line: number;
@@ -933,14 +1013,46 @@ interface KitModuleFacts {
   }[];
   /** Root-relative `redirect()` literals in this Kit module (correctness/base-path-navigation). */
   basePathLinks: BasePathLinkFact[];
-  /** Set when this file disables SSR via `export const ssr = false` (inline or same-file alias export) — the declaration's line (seo/ssr-disabled). */
+  /** Set when this file disables SSR via `export const ssr = false` or `= dev` (inline or same-file alias export) — the declaration's line (seo/ssr-disabled). */
   ssrDisabled?: {
     line: number;
   };
+  /** Set when this file exports `ssr` as anything but a literal `false` (`true`, a computed value, a re-export) — it may turn SSR back on under a layout's `ssr = false` (see `appSsrDisabled`, `routeNeverSsr`). */
+  ssrEnabled?: true;
+  /** Set when this file exports `ssr` as the literal `true` (inline or same-file alias export); implies `ssrEnabled`. */
+  ssrTrue?: true;
   /** Set when this file disables client-side rendering via `export const csr = false` (inline or same-file alias export). With no client runtime, a universal load only runs during SSR — performance/load-waterfall's browser-waterfall premise doesn't hold. */
   csrDisabled?: {
     line: number;
   };
+  /** Set when this file exports `csr` as anything but `false` — it may turn CSR back on under a layout's `csr = false` (see `universalNeverCsr`). */
+  csrEnabled?: true;
+  /** Set when the exported `load` redirects or throws `error()` on every call — every path through its body reaches a `redirect()`/`error()` before any `return`, directly or through a same-file top-level function that always does (see `loadNeverRenders` in kit-module-parse.ts). A `+page` module carrying it means the route never renders its own page. */
+  loadNeverRenders?: true;
+  /** Set when the exported `load` redirects or errors on every call once `if (building)` (from `$app/environment`) is read false, as on every request; the page renders only if its route is prerendered (see `prerenderExported`). */
+  loadNeverRendersOutsideBuild?: true;
+  /** The module exports `prerender`, in any form. */
+  prerenderExported?: true;
+  /** The request paths the exported `handle` of a hooks file answers before calling `resolve` (see `handleAnsweredPaths` in kit-module-parse.ts): a route they cover never renders. */
+  answeredPaths?: {
+    op: 'eq' | 'starts';
+    v: string;
+  }[];
+  /** The string literals a `transformPageChunk` the exported `handle` passes to `resolve` replaces in the page HTML (`html.replace('<!--seo-head-->', …)`). */
+  pageChunkTokens?: string[];
+  /** The imported flag a load's leading guard reads (`if (!FLAG) redirect(…)`): `collectKitModuleFacts` sets `loadNeverRenders` when that export is the literal `false`. */
+  pendingFlagGuard?: {
+    resolved: string;
+    name: string;
+    member?: string;
+  };
+  /** The imported factory `export const load = factory(…)` calls: `collectKitModuleFacts` sets `loadNeverRenders` when the function it returns redirects or errors on every call. */
+  pendingLoadFactory?: {
+    resolved: string;
+    name: string;
+  };
+  /** Set when the exported `load` sends a request without a session away before rendering (see `loadGatesOnLocals` in kit-module-parse.ts); every route under a `+layout` carrying it is behind a login. */
+  loadGated?: true;
   /** Sequential-await analysis of the exported `load` function (performance/load-waterfall, performance/sequential-awaits): 1-based lines of await sites that depend on an earlier await's result, and of sites independent of all earlier awaits. Set only when at least one list is non-empty. */
   loadWaterfalls?: {
     dependentLines: number[];
@@ -953,6 +1065,25 @@ interface KitModuleFacts {
   /** Set when the file could not be READ — an environment problem, not a malformed module. */
   readFailed?: true;
 }
+/** The rule-context fields the per-route SSR resolution reads. */
+type SsrScope = Pick<RuleContext, 'kitModules' | 'components' | 'sourceFiles'> & {
+  project?: Pick<Project, 'kitHashRouter'>;
+};
+/**
+ * Whether a `+page` file's route never renders because a layout above it redirects or errors in its
+ * `load` on every call (`loadNeverRenders`). Not the root layout: one that sent every request away
+ * would leave the app nothing to serve, so that reading is more likely wrong than the app, and acting
+ * on it would silence every route.
+ */
+declare function layoutNeverRenders(file: string, scope: SsrScope): boolean;
+/**
+ * Whether a `+page` file's route never renders because its own `load` redirects or errors on every
+ * request, a build-time `if (building)` aside (`loadNeverRendersOutsideBuild`), and nothing on its chain
+ * exports `prerender`, so the build never renders it either.
+ */
+declare function pageRendersOnlyWhenBuilding(file: string, scope: SsrScope): boolean;
+/** Whether a `+page`/`+layout` file (module or component) belongs to a route that is never server-rendered. */
+declare function routeNeverSsr(file: string, scope: SsrScope): boolean;
 //#endregion
 //#region src/config-apply.d.ts
 /** The severity a setting selects: `'off'`, an explicit severity, or undefined (leave the built-in). */
@@ -1282,8 +1413,13 @@ declare function buildJsonReport(results: Result[], config: Config, meta: {
   version: string;
 }, ruleIds?: readonly string[], examined?: Record<string, Record<string, number>>, skipped?: JsonReport['skipped']): JsonReport;
 /** Render results as the documented JSON report string (design §7). */
-declare function formatJsonReport(results: Result[], config: Config, meta: {
+declare function formatJsonReport(...args: Parameters<typeof formatJsonReportChunks>): string;
+/**
+ * `formatJsonReport`'s text in pieces, one route at a time: a large prerendered site's report is
+ * longer than the longest string V8 can hold.
+ */
+declare function formatJsonReportChunks(results: Result[], config: Config, meta: {
   version: string;
-}, ruleIds?: readonly string[], examined?: Record<string, Record<string, number>>, skipped?: JsonReport['skipped']): string;
+}, ruleIds?: readonly string[], examined?: Record<string, Record<string, number>>, skipped?: JsonReport['skipped']): Generator<string>;
 //#endregion
-export { formatMarkdownReport as $, A11yOccurrenceInfo as A, OrphanEffectFact as At, decodeFragmentId as B, compileOverrides as C, Value as Ct, withFailedRulesOff as D, ComponentFacts as Dt, settingSeverity as E, defineConfig as Et, IDREF_ATTRS as F, skippedFileWarnings as Ft, stripTextDirective as G, isTopFragment as H, LandmarkInput as I, Runtime as It, ImageInfo as J, HeadingInfo as K, NAMING_ATTRS as L, withReadLimit as Lt, ANCESTRY_DEPENDENT_TAGS as M, SuppressionDirective as Mt, ASIDE_DEMOTING_TAGS as N, collectComponentFacts as Nt, withIndexableOff as O, EachBlockFact as Ot, BranchStep as P, emptyComponentFacts as Pt, isClassicScriptType as Q, ResolvedA11y as R, SEARCH_RESULT_RULES as S, TreatDynamicAs as St, selectRules as T, defaultProject as Tt, resolveLandmark as U, foldOccurrences as V, splitTokens as W, HeadTag as X, ResolvedImages as Y, ResolvedHead as Z, isPlainObject as _, RuleOverride as _t, HealthResult as a, hasFailureAtOrAbove as at, validateRuleSetting as b, Scope as bt, ScoreResult as c, Category as ct, Rule as d, Fix as dt, formatGithubReport as et, RuleContext as f, KitAlias as ft, RuleOptionsSpec as g, RuleOptions as gt, RuleOptionSpec as h, Result as ht, formatJsonReport as i, effectiveSeverity as it, A11ySkipCause as j, SourceSpan as jt, KitModuleFacts as k, EffectFact as kt, computeHealth as l, Config as lt, isPenalized as m, Project as mt, RuleEvidence as n, Summary as nt, ScoreModel as o, summarize as ot, docsUrlFor as p, Presence as pt, ResolvedHeadings as q, buildJsonReport as r, classify as rt, ScoreOptions as s, CATEGORIES as st, JsonReport as t, Classification as tt, computeScore as u, Detection as ut, resolveRuleOptions as v, RuleSetting as vt, formatFailedRuleWarning as w, defaultConfig as wt, CompiledOverride as x, Severity as xt, shouldSkipRangeCheck as y, RuleSettingObject as yt, SECTIONING_TAGS as z };
+export { ResolvedImages as $, KitModuleFacts as A, ResolvedHead as At, BranchStep as B, emptyComponentFacts as Bt, SEARCH_RESULT_RULES as C, Severity as Ct, settingSeverity as D, defaultProject as Dt, selectRules as E, defaultConfig as Et, ResolvedHeadings as F, EffectFact as Ft, SECTIONING_TAGS as G, LandmarkInput as H, Runtime as Ht, A11yOccurrenceInfo as I, OrphanEffectFact as It, isTopFragment as J, decodeFragmentId as K, A11ySkipCause as L, SourceSpan as Lt, pageRendersOnlyWhenBuilding as M, isClassicScriptType as Mt, routeNeverSsr as N, ComponentFacts as Nt, withFailedRulesOff as O, defineConfig as Ot, HeadingInfo as P, EachBlockFact as Pt, ImageInfo as Q, ANCESTRY_DEPENDENT_TAGS as R, SuppressionDirective as Rt, CompiledOverride as S, Scope as St, formatFailedRuleWarning as T, Value as Tt, NAMING_ATTRS as U, withReadLimit as Ut, IDREF_ATTRS as V, skippedFileWarnings as Vt, ResolvedA11y as W, splitTokens as X, resolveLandmark as Y, stripTextDirective as Z, RuleOptionsSpec as _, Result as _t, formatJsonReportChunks as a, classify as at, shouldSkipRangeCheck as b, RuleSetting as bt, ScoreOptions as c, summarize as ct, computeScore as d, Config as dt, isSvgSrc as et, Rule as f, Detection as ft, RuleOptionSpec as g, Project as gt, isPenalized as h, Presence as ht, formatJsonReport as i, Summary as it, layoutNeverRenders as j, hasRel as jt, withIndexableOff as k, HeadTag as kt, ScoreResult as l, CATEGORIES as lt, docsUrlFor as m, KitAlias as mt, RuleEvidence as n, formatGithubReport as nt, HealthResult as o, effectiveSeverity as ot, RuleContext as p, Fix as pt, foldOccurrences as q, buildJsonReport as r, Classification as rt, ScoreModel as s, hasFailureAtOrAbove as st, JsonReport as t, formatMarkdownReport as tt, computeHealth as u, Category as ut, isPlainObject as v, RuleOptions as vt, compileOverrides as w, TreatDynamicAs as wt, validateRuleSetting as x, RuleSettingObject as xt, resolveRuleOptions as y, RuleOverride as yt, ASIDE_DEMOTING_TAGS as z, collectComponentFacts as zt };