@svelte-vitals/core 0.55.2 → 0.55.3

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { $ as formatGithubReport, Q as formatMarkdownReport, St as Value, Tt as defineConfig, _t as RuleSetting, at as summarize, bt as Severity, ct as Config, ft as Presence, gt as RuleOverride, ht as RuleOptions, it as hasFailureAtOrAbove, lt as Detection, mt as Result, n as RuleEvidence, o as ScoreModel, ot as CATEGORIES, st as Category, t as JsonReport, tt as Summary, ut as Fix, vt as RuleSettingObject, xt as TreatDynamicAs } from "./json-BQf9Qb2D.js";
+import { Ct as Severity, Ot as defineConfig, Tt as Value, _t as Result, bt as RuleSetting, ct as summarize, dt as Config, ft as Detection, ht as Presence, it as Summary, lt as CATEGORIES, n as RuleEvidence, nt as formatGithubReport, pt as Fix, s as ScoreModel, st as hasFailureAtOrAbove, t as JsonReport, tt as formatMarkdownReport, ut as Category, vt as RuleOptions, wt as TreatDynamicAs, xt as RuleSettingObject, yt as RuleOverride } from "./json-DmLgFEwV.js";
 export { CATEGORIES, type Category, type Config, type Detection, type Fix, type JsonReport, type Presence, type Result, type RuleEvidence, type RuleOptions, type RuleOverride, type RuleSetting, type RuleSettingObject, type ScoreModel, type Severity, type Summary, type TreatDynamicAs, type Value, defineConfig, formatGithubReport, formatMarkdownReport, hasFailureAtOrAbove, summarize };

package/dist/index.js

@@ -1,2 +1 @@
-import { Or as CATEGORIES, Tr as summarize, c as formatGithubReport, jr as defineConfig, t as formatMarkdownReport, wr as hasFailureAtOrAbove } from "./markdown-DgHBAvYl.js";
-export { CATEGORIES, defineConfig, formatGithubReport, formatMarkdownReport, hasFailureAtOrAbove, summarize };
+export { Lr as CATEGORIES, Br as defineConfig, l as formatGithubReport, t as formatMarkdownReport, Nr as hasFailureAtOrAbove, Pr as summarize } from "./markdown-CsQNXeWj.js";

package/dist/internal.d.ts

@@ -1,12 +1,16 @@
-import { $ as formatGithubReport, A as routeNeverSsr, At as EachBlockFact, B as NAMING_ATTRS, C as compileOverrides, Ct as defaultConfig, D as withFailedRulesOff, Dt as ResolvedHead, E as settingSeverity, Et as HeadTag, F as ANCESTRY_DEPENDENT_TAGS, Ft as collectComponentFacts, G as isTopFragment, H as SECTIONING_TAGS, I as ASIDE_DEMOTING_TAGS, It as emptyComponentFacts, J as stripTextDirective, K as resolveLandmark, L as BranchStep, Lt as skippedFileWarnings, M as ResolvedHeadings, Mt as OrphanEffectFact, N as A11yOccurrenceInfo, Nt as SourceSpan, O as withIndexableOff, Ot as isClassicScriptType, P as A11ySkipCause, Pt as SuppressionDirective, Q as formatMarkdownReport, R as IDREF_ATTRS, Rt as Runtime, S as SEARCH_RESULT_RULES, St as Value, T as selectRules, U as decodeFragmentId, V as ResolvedA11y, W as foldOccurrences, X as ResolvedImages, Y as ImageInfo, Z as isSvgSrc, _ as isPlainObject, a as HealthResult, at as summarize, b as validateRuleSetting, bt as Severity, c as ScoreResult, ct as Config, d as Rule, dt as KitAlias, et as Classification, f as RuleContext, g as RuleOptionsSpec, h as RuleOptionSpec, i as formatJsonReport, it as hasFailureAtOrAbove, j as HeadingInfo, jt as EffectFact, k as KitModuleFacts, kt as ComponentFacts, l as computeHealth, m as isPenalized, mt as Result, nt as classify, p as docsUrlFor, pt as Project, q as splitTokens, r as buildJsonReport, rt as effectiveSeverity, s as ScoreOptions, st as Category, t as JsonReport, u as computeScore, ut as Fix, v as resolveRuleOptions, w as formatFailedRuleWarning, wt as defaultProject, x as CompiledOverride, y as shouldSkipRangeCheck, yt as Scope, z as LandmarkInput, zt as withReadLimit } from "./json-BQf9Qb2D.js";
+import { $ as ResolvedImages, A as KitModuleFacts, At as ResolvedHead, B as BranchStep, Bt as emptyComponentFacts, C as SEARCH_RESULT_RULES, Ct as Severity, D as settingSeverity, Dt as defaultProject, E as selectRules, Et as defaultConfig, F as ResolvedHeadings, Ft as EffectFact, G as SECTIONING_TAGS, H as LandmarkInput, Ht as Runtime, I as A11yOccurrenceInfo, It as OrphanEffectFact, J as isTopFragment, K as decodeFragmentId, L as A11ySkipCause, Lt as SourceSpan, M as pageRendersOnlyWhenBuilding, Mt as isClassicScriptType, N as routeNeverSsr, Nt as ComponentFacts, O as withFailedRulesOff, P as HeadingInfo, Pt as EachBlockFact, Q as ImageInfo, R as ANCESTRY_DEPENDENT_TAGS, Rt as SuppressionDirective, S as CompiledOverride, St as Scope, T as formatFailedRuleWarning, Tt as Value, U as NAMING_ATTRS, Ut as withReadLimit, V as IDREF_ATTRS, Vt as skippedFileWarnings, W as ResolvedA11y, X as splitTokens, Y as resolveLandmark, Z as stripTextDirective, _ as RuleOptionsSpec, _t as Result, a as formatJsonReportChunks, at as classify, b as shouldSkipRangeCheck, c as ScoreOptions, ct as summarize, d as computeScore, dt as Config, et as isSvgSrc, f as Rule, g as RuleOptionSpec, gt as Project, h as isPenalized, i as formatJsonReport, j as layoutNeverRenders, jt as hasRel, k as withIndexableOff, kt as HeadTag, l as ScoreResult, m as docsUrlFor, mt as KitAlias, nt as formatGithubReport, o as HealthResult, ot as effectiveSeverity, p as RuleContext, pt as Fix, q as foldOccurrences, r as buildJsonReport, rt as Classification, st as hasFailureAtOrAbove, t as JsonReport, tt as formatMarkdownReport, u as computeHealth, ut as Category, v as isPlainObject, w as compileOverrides, x as validateRuleSetting, y as resolveRuleOptions, z as ASIDE_DEMOTING_TAGS, zt as collectComponentFacts } from "./json-DmLgFEwV.js";
 import { AST } from "svelte/compiler";
 //#region src/component-parse.d.ts
-type Node$1 = any;
+type Node$2 = any;
+/** A component's script `const` lists that nothing in its scripts or template can change. */
+export declare function collectComponentConstantLists(ast: Node$2, opts?: {
+  sets?: boolean;
+}): Set<string>;
 /**
  * Export names of a module's constant lists — `export const X = [ … ]`, or a local one exported by
  * name — that the module itself never writes (correctness/each-key, correctness/each-index-key).
  */
-export declare function collectConstantListExports(program: Node$1): Set<string>;
+export declare function collectConstantListExports(program: Node$2): Set<string>;
 /** What the per-file parsers produce — `ComponentFacts` minus `file`, with `suppressions` always present. */
 type ParsedFacts = Omit<ComponentFacts, 'file' | 'suppressions'> & {
   suppressions: SuppressionDirective[];
@@ -18,8 +22,472 @@ type ParsedFacts = Omit<ComponentFacts, 'file' | 'suppressions'> & {
  */
 export declare function parseComponentFacts(source: string, filename: string): ParsedFacts;
 //#endregion
+//#region ../../node_modules/.pnpm/@types+estree@1.0.9/node_modules/@types/estree/index.d.ts
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+interface BaseNodeWithoutComments {
+  // Every leaf interface that extends BaseNode must specify a type property.
+  // The type property should be a string literal. For example, Identifier
+  // has: `type: "Identifier"`
+  type: string;
+  loc?: SourceLocation | null | undefined;
+  range?: [number, number] | undefined;
+}
+interface BaseNode extends BaseNodeWithoutComments {
+  leadingComments?: Comment[] | undefined;
+  trailingComments?: Comment[] | undefined;
+}
+interface Comment extends BaseNodeWithoutComments {
+  type: "Line" | "Block";
+  value: string;
+}
+interface SourceLocation {
+  source?: string | null | undefined;
+  start: Position;
+  end: Position;
+}
+interface Position {
+  /** >= 1 */
+  line: number;
+  /** >= 0 */
+  column: number;
+}
+interface BaseFunction extends BaseNode {
+  params: Pattern[];
+  generator?: boolean | undefined;
+  async?: boolean | undefined;
+  // The body is either BlockStatement or Expression because arrow functions
+  // can have a body that's either. FunctionDeclarations and
+  // FunctionExpressions have only BlockStatement bodies.
+  body: BlockStatement | Expression;
+}
+type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+interface BaseStatement extends BaseNode {}
+interface EmptyStatement extends BaseStatement {
+  type: "EmptyStatement";
+}
+interface BlockStatement extends BaseStatement {
+  type: "BlockStatement";
+  body: Statement[];
+  innerComments?: Comment[] | undefined;
+}
+interface StaticBlock extends Omit<BlockStatement, "type"> {
+  type: "StaticBlock";
+}
+interface ExpressionStatement extends BaseStatement {
+  type: "ExpressionStatement";
+  expression: Expression;
+}
+interface IfStatement extends BaseStatement {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate?: Statement | null | undefined;
+}
+interface LabeledStatement extends BaseStatement {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+interface BreakStatement extends BaseStatement {
+  type: "BreakStatement";
+  label?: Identifier | null | undefined;
+}
+interface ContinueStatement extends BaseStatement {
+  type: "ContinueStatement";
+  label?: Identifier | null | undefined;
+}
+interface WithStatement extends BaseStatement {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+}
+interface SwitchStatement extends BaseStatement {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: SwitchCase[];
+}
+interface ReturnStatement extends BaseStatement {
+  type: "ReturnStatement";
+  argument?: Expression | null | undefined;
+}
+interface ThrowStatement extends BaseStatement {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+interface TryStatement extends BaseStatement {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler?: CatchClause | null | undefined;
+  finalizer?: BlockStatement | null | undefined;
+}
+interface WhileStatement extends BaseStatement {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+}
+interface DoWhileStatement extends BaseStatement {
+  type: "DoWhileStatement";
+  body: Statement;
+  test: Expression;
+}
+interface ForStatement extends BaseStatement {
+  type: "ForStatement";
+  init?: VariableDeclaration | Expression | null | undefined;
+  test?: Expression | null | undefined;
+  update?: Expression | null | undefined;
+  body: Statement;
+}
+interface BaseForXStatement extends BaseStatement {
+  left: VariableDeclaration | Pattern;
+  right: Expression;
+  body: Statement;
+}
+interface ForInStatement extends BaseForXStatement {
+  type: "ForInStatement";
+}
+interface DebuggerStatement extends BaseStatement {
+  type: "DebuggerStatement";
+}
+type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+interface BaseDeclaration extends BaseStatement {}
+interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+  type: "FunctionDeclaration";
+  /** It is null when a function declaration is a part of the `export default function` statement */
+  id: Identifier | null;
+  body: BlockStatement;
+}
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+  id: Identifier;
+}
+interface VariableDeclaration extends BaseDeclaration {
+  type: "VariableDeclaration";
+  declarations: VariableDeclarator[];
+  kind: "var" | "let" | "const" | "using" | "await using";
+}
+interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: Pattern;
+  init?: Expression | null | undefined;
+}
+interface ExpressionMap {
+  ArrayExpression: ArrayExpression;
+  ArrowFunctionExpression: ArrowFunctionExpression;
+  AssignmentExpression: AssignmentExpression;
+  AwaitExpression: AwaitExpression;
+  BinaryExpression: BinaryExpression;
+  CallExpression: CallExpression;
+  ChainExpression: ChainExpression;
+  ClassExpression: ClassExpression;
+  ConditionalExpression: ConditionalExpression;
+  FunctionExpression: FunctionExpression;
+  Identifier: Identifier;
+  ImportExpression: ImportExpression;
+  Literal: Literal;
+  LogicalExpression: LogicalExpression;
+  MemberExpression: MemberExpression;
+  MetaProperty: MetaProperty;
+  NewExpression: NewExpression;
+  ObjectExpression: ObjectExpression;
+  SequenceExpression: SequenceExpression;
+  TaggedTemplateExpression: TaggedTemplateExpression;
+  TemplateLiteral: TemplateLiteral;
+  ThisExpression: ThisExpression;
+  UnaryExpression: UnaryExpression;
+  UpdateExpression: UpdateExpression;
+  YieldExpression: YieldExpression;
+}
+type Expression = ExpressionMap[keyof ExpressionMap];
+interface BaseExpression extends BaseNode {}
+type ChainElement = SimpleCallExpression | MemberExpression;
+interface ChainExpression extends BaseExpression {
+  type: "ChainExpression";
+  expression: ChainElement;
+}
+interface ThisExpression extends BaseExpression {
+  type: "ThisExpression";
+}
+interface ArrayExpression extends BaseExpression {
+  type: "ArrayExpression";
+  elements: Array<Expression | SpreadElement | null>;
+}
+interface ObjectExpression extends BaseExpression {
+  type: "ObjectExpression";
+  properties: Array<Property | SpreadElement>;
+}
+interface PrivateIdentifier extends BaseNode {
+  type: "PrivateIdentifier";
+  name: string;
+}
+interface Property extends BaseNode {
+  type: "Property";
+  key: Expression;
+  value: Expression | Pattern; // Could be an AssignmentProperty
+  kind: "init" | "get" | "set";
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+}
+interface PropertyDefinition extends BaseNode {
+  type: "PropertyDefinition";
+  key: Expression | PrivateIdentifier;
+  value?: Expression | null | undefined;
+  computed: boolean;
+  static: boolean;
+}
+interface FunctionExpression extends BaseFunction, BaseExpression {
+  id?: Identifier | null | undefined;
+  type: "FunctionExpression";
+  body: BlockStatement;
+}
+interface SequenceExpression extends BaseExpression {
+  type: "SequenceExpression";
+  expressions: Expression[];
+}
+interface UnaryExpression extends BaseExpression {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  prefix: true;
+  argument: Expression;
+}
+interface BinaryExpression extends BaseExpression {
+  type: "BinaryExpression";
+  operator: BinaryOperator;
+  left: Expression | PrivateIdentifier;
+  right: Expression;
+}
+interface AssignmentExpression extends BaseExpression {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: Pattern | MemberExpression;
+  right: Expression;
+}
+interface UpdateExpression extends BaseExpression {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  argument: Expression;
+  prefix: boolean;
+}
+interface LogicalExpression extends BaseExpression {
+  type: "LogicalExpression";
+  operator: LogicalOperator;
+  left: Expression;
+  right: Expression;
+}
+interface ConditionalExpression extends BaseExpression {
+  type: "ConditionalExpression";
+  test: Expression;
+  alternate: Expression;
+  consequent: Expression;
+}
+interface BaseCallExpression extends BaseExpression {
+  callee: Expression | Super;
+  arguments: Array<Expression | SpreadElement>;
+}
+type CallExpression = SimpleCallExpression | NewExpression;
+interface SimpleCallExpression extends BaseCallExpression {
+  type: "CallExpression";
+  optional: boolean;
+}
+interface NewExpression extends BaseCallExpression {
+  type: "NewExpression";
+}
+interface MemberExpression extends BaseExpression, BasePattern {
+  type: "MemberExpression";
+  object: Expression | Super;
+  property: Expression | PrivateIdentifier;
+  computed: boolean;
+  optional: boolean;
+}
+type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+interface BasePattern extends BaseNode {}
+interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test?: Expression | null | undefined;
+  consequent: Statement[];
+}
+interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Pattern | null;
+  body: BlockStatement;
+}
+interface Identifier extends BaseNode, BaseExpression, BasePattern {
+  type: "Identifier";
+  name: string;
+}
+type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+interface SimpleLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value: string | boolean | number | null;
+  raw?: string | undefined;
+}
+interface RegExpLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: RegExp | null | undefined;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  raw?: string | undefined;
+}
+interface BigIntLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: bigint | null | undefined;
+  bigint: string;
+  raw?: string | undefined;
+}
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+type LogicalOperator = "||" | "&&" | "??";
+type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+type UpdateOperator = "++" | "--";
+interface ForOfStatement extends BaseForXStatement {
+  type: "ForOfStatement";
+  await: boolean;
+}
+interface Super extends BaseNode {
+  type: "Super";
+}
+interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  body: BlockStatement | Expression;
+}
+interface YieldExpression extends BaseExpression {
+  type: "YieldExpression";
+  argument?: Expression | null | undefined;
+  delegate: boolean;
+}
+interface TemplateLiteral extends BaseExpression {
+  type: "TemplateLiteral";
+  quasis: TemplateElement[];
+  expressions: Expression[];
+}
+interface TaggedTemplateExpression extends BaseExpression {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  quasi: TemplateLiteral;
+}
+interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  tail: boolean;
+  value: {
+    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+    cooked?: string | null | undefined;
+    raw: string;
+  };
+}
+interface AssignmentProperty extends Property {
+  value: Pattern;
+  kind: "init";
+  method: boolean; // false
+}
+interface ObjectPattern extends BasePattern {
+  type: "ObjectPattern";
+  properties: Array<AssignmentProperty | RestElement>;
+}
+interface ArrayPattern extends BasePattern {
+  type: "ArrayPattern";
+  elements: Array<Pattern | null>;
+}
+interface RestElement extends BasePattern {
+  type: "RestElement";
+  argument: Pattern;
+}
+interface AssignmentPattern extends BasePattern {
+  type: "AssignmentPattern";
+  left: Pattern;
+  right: Expression;
+}
+interface BaseClass extends BaseNode {
+  superClass?: Expression | null | undefined;
+  body: ClassBody;
+}
+interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+interface MethodDefinition extends BaseNode {
+  type: "MethodDefinition";
+  key: Expression | PrivateIdentifier;
+  value: FunctionExpression;
+  kind: "constructor" | "method" | "get" | "set";
+  computed: boolean;
+  static: boolean;
+}
+interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+  type: "ClassDeclaration";
+  /** It is null when a class declaration is a part of the `export default class` statement */
+  id: Identifier | null;
+}
+interface ClassDeclaration extends MaybeNamedClassDeclaration {
+  id: Identifier;
+}
+interface ClassExpression extends BaseClass, BaseExpression {
+  type: "ClassExpression";
+  id?: Identifier | null | undefined;
+}
+interface MetaProperty extends BaseExpression {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+interface ImportExpression extends BaseExpression {
+  type: "ImportExpression";
+  source: Expression;
+  options?: Expression | null | undefined;
+}
+interface AwaitExpression extends BaseExpression {
+  type: "AwaitExpression";
+  argument: Expression;
+}
+//#endregion
 //#region src/module-ast.d.ts
-type Node = any;
+type Node$1 = any;
+interface TSSatisfiesExpression {
+  type: 'TSSatisfiesExpression';
+  start: number;
+  end: number;
+  expression: TsExpression;
+}
+interface TSAsExpression {
+  type: 'TSAsExpression';
+  start: number;
+  end: number;
+  expression: TsExpression;
+}
+interface TSNonNullExpression {
+  type: 'TSNonNullExpression';
+  start: number;
+  end: number;
+  expression: TsExpression;
+}
+/** An estree `Expression`, optionally wrapped in one or more of the three TS wrappers above. */
+type TsExpression = Expression | TSSatisfiesExpression | TSAsExpression | TSNonNullExpression;
+/** Unwrap TS wrapper expressions (`x satisfies T`, `x as T`, `x!`) to the underlying expression. Shared with the Kit-module and Vite-config parsers. */
+export declare function unwrapTs(expr: TsExpression): Expression;
+export declare function unwrapTs(expr: TsExpression | undefined): Expression | undefined;
+/** Generic ESTree walk over a `<script>` program: visit every node with a `.type`. */
+export declare function walkEstree(node: Node$1, visit: (n: Node$1) => void): void;
 /**
  * Inline `svelte-vitals-disable-next-line` directives (issue #92). A plain text scan, not an
  * AST walk, so `<script>` (`//`) and template (`<!-- -->`) comments are covered uniformly. The
@@ -37,7 +505,7 @@ export declare function collectSuppressions(source: string): SuppressionDirectiv
  * runes-module facts (correctness/orphan-effect) and the Kit-module facts (the security kit-module rules).
  */
 type ParsedModule = {
-  program: Node | undefined;
+  program: Node$1 | undefined;
   wrapped: string;
 };
 export declare function parseModuleProgram(source: string, filename: string): ParsedModule;
@@ -82,6 +550,9 @@ export declare function unknownDirectiveIds(index: DirectiveIndex, rules: readon
 export declare function collectSourceFiles(rt: Runtime, cwd: string): Promise<string[]>;
 //#endregion
 //#region src/kit-module-parse.d.ts
+type Node = any;
+/** `parseFalseExports` over a parsed module. */
+export declare function collectFalseExports(program: Node): Set<string>;
 /**
  * Resolve an import specifier to a path relative to the analyzed project's root (the
  * cwd svelte-vitals runs from — not necessarily a repo root; in a monorepo the project
@@ -155,6 +626,8 @@ export declare function resolveKitAliases(viteConfig: {
  * which leaves the specifier unresolved as before.
  */
 export declare function withPackageImports(aliases: KitAlias[] | undefined, packageJsonSource: string | undefined): KitAlias[] | undefined;
+/** Whether `kit.router.type` is the literal `'hash'` in a config whose value is known. */
+export declare function findKitHashRouterInSvelteConfig(source: string): boolean;
 /**
  * The project's effective `kit.paths.base`, following SvelteKit's precedence: the `sveltekit()`
  * plugin config when it carries one, otherwise `svelte.config`. `file` is the config the base
@@ -222,7 +695,7 @@ export declare function withInstalledPackages(aliases: KitAlias[] | undefined, p
  * the text scan's imprecision cannot reach it. A file that does not parse is already a hard failure,
  * which the retry can only improve on.
  */
-export declare function parseSvelte(source: string, filename: string): AST.Root;
+export declare function parseSvelte(raw: string, filename: string): AST.Root;
 /** A template fragment's child node relevant to value classification: literal text or a `{expr}`. */
 type TextOrExpr = AST.Text | AST.ExpressionTag;
 /**
@@ -265,8 +738,11 @@ export declare const ROBOTS_SOURCE_PATHS: readonly ["static/robots.txt", "src/ro
 /** Locations that satisfy the sitemap.xml project rule (seo/sitemap-xml). */
 export declare const SITEMAP_SOURCE_PATHS: readonly ["static/sitemap.xml", "src/routes/sitemap.xml/+server.ts", "src/routes/sitemap.xml/+server.js"];
 /** The `+server` endpoints above, wherever (group) directories nest them — filter with `servesRootFile`. */
-export declare const ROOT_FILE_ENDPOINT_GLOB = "src/routes/**/{robots.txt,sitemap.xml}/+server.{ts,js}";
-/** Whether a `+server` endpoint serves `/<file>`: (group) directories add no URL segment. */
+export declare const ROOT_FILE_ENDPOINT_GLOB = "src/routes/**/{robots.txt,sitemap*.xml}/+server.{ts,js}";
+/**
+ * Whether a `+server` endpoint serves `/<file>`: (group) directories add no URL segment, and an optional
+ * parameter in the name (`sitemap[[page]].xml`) still answers the bare name.
+ */
 export declare function servesRootFile(rel: string, file: 'robots.txt' | 'sitemap.xml'): boolean;
 /** Vite's own config resolution order — only the first existing file is the one Vite loads. */
 export declare const VITE_CONFIG_FILES: readonly ["vite.config.js", "vite.config.mjs", "vite.config.ts", "vite.config.cjs", "vite.config.mts", "vite.config.cts"];
@@ -700,8 +1176,8 @@ export declare const performanceMinifyDisabled: Rule;
 /**
  * performance/load-waterfall — dependent await chains in universal loads. Server loads are exempt:
  * a dependent chain cannot be parallelized, and on the server there is no better
- * placement to suggest. csr = false files are exempt too — without a client
- * runtime the universal load only runs during SSR.
+ * placement to suggest. Loads on a route with `csr = false` (its own or a layout's) are exempt
+ * too — without a client runtime the universal load only runs during SSR.
  */
 export declare const performanceLoadWaterfall: Rule;
 //#endregion
@@ -1037,4 +1513,4 @@ export declare function formatHtmlReport(results: Result[], config: Config, meta
   coreVersion?: string;
 }): string;
 //#endregion
-export { type A11yOccurrenceInfo, type A11ySkipCause, ANCESTRY_DEPENDENT_TAGS, ASIDE_DEMOTING_TAGS, type AppSnapshot, type BranchStep, type Classification, type CompiledOverride, type ComponentFacts, type ConsoleReportOptions, type DirectiveIndex, type EachBlockFact, type EffectFact, type FailedRule, type HeadTag, type HeadingInfo, type HealthResult, IDREF_ATTRS, type ImageInfo, type KitAlias, type KitModuleFacts, type LandmarkInput, NAMING_ATTRS, type OrphanEffectFact, type Palette, type Project, type ResolvedA11y, type ResolvedHead, type ResolvedHeadings, type ResolvedImages, type RouteBadge, type Rule, type RuleContext, type RuleOptionSpec, type RuleOptionsSpec, type Runtime, SEARCH_RESULT_RULES, SECTIONING_TAGS, type Scope, type ScoreOptions, type ScoreResult, type SourceSpan, type SuppressionDirective, type WorkspacePackage, buildJsonReport, classify, collectComponentFacts, compileOverrides, computeHealth, computeScore, decodeFragmentId, defaultConfig, defaultProject, docsUrlFor, effectiveSeverity, emptyComponentFacts, foldOccurrences, formatFailedRuleWarning, formatGithubReport, formatJsonReport, formatMarkdownReport, hasFailureAtOrAbove, isClassicScriptType, isPenalized, isPlainObject, isSvgSrc, isTopFragment, resolveLandmark, resolveRuleOptions, routeNeverSsr, selectRules, settingSeverity, shouldSkipRangeCheck, skippedFileWarnings, splitTokens, stripTextDirective, summarize, validateRuleSetting, withFailedRulesOff, withIndexableOff, withReadLimit };
+export { type A11yOccurrenceInfo, type A11ySkipCause, ANCESTRY_DEPENDENT_TAGS, ASIDE_DEMOTING_TAGS, type AppSnapshot, type BranchStep, type Classification, type CompiledOverride, type ComponentFacts, type ConsoleReportOptions, type DirectiveIndex, type EachBlockFact, type EffectFact, type FailedRule, type HeadTag, type HeadingInfo, type HealthResult, IDREF_ATTRS, type ImageInfo, type KitAlias, type KitModuleFacts, type LandmarkInput, NAMING_ATTRS, type OrphanEffectFact, type Palette, type Project, type ResolvedA11y, type ResolvedHead, type ResolvedHeadings, type ResolvedImages, type RouteBadge, type Rule, type RuleContext, type RuleOptionSpec, type RuleOptionsSpec, type Runtime, SEARCH_RESULT_RULES, SECTIONING_TAGS, type Scope, type ScoreOptions, type ScoreResult, type SourceSpan, type SuppressionDirective, type WorkspacePackage, buildJsonReport, classify, collectComponentFacts, compileOverrides, computeHealth, computeScore, decodeFragmentId, defaultConfig, defaultProject, docsUrlFor, effectiveSeverity, emptyComponentFacts, foldOccurrences, formatFailedRuleWarning, formatGithubReport, formatJsonReport, formatJsonReportChunks, formatMarkdownReport, hasFailureAtOrAbove, hasRel, isClassicScriptType, isPenalized, isPlainObject, isSvgSrc, isTopFragment, layoutNeverRenders, pageRendersOnlyWhenBuilding, resolveLandmark, resolveRuleOptions, routeNeverSsr, selectRules, settingSeverity, shouldSkipRangeCheck, skippedFileWarnings, splitTokens, stripTextDirective, summarize, validateRuleSetting, withFailedRulesOff, withIndexableOff, withReadLimit };