svelte_preprocess_helpers.ts

Builds a map of statically resolvable const bindings from a Svelte AST.

Scans top-level const variable declarations in both instance and module scripts. For each declarator with a plain Identifier pattern and a statically evaluable initializer, adds the binding to the map. Processes declarations in source order so that chained references resolve: const a = 'x'; const b = a; maps b to 'x'.

Skips destructuring patterns, let/var declarations, and declarations whose initializers reference dynamic values.

A single branch in a conditional chain extracted from nested ternary expressions.

Escapes text for safe embedding in Svelte template markup.

Uses a single-pass regex replacement to avoid corruption that occurs with sequential .replace() calls (where the second replace matches characters introduced by the first).

Escapes four characters: - { → {'{'} and } → {'}'} — prevents Svelte expression interpretation - < → < — prevents HTML/Svelte tag interpretation - & → & — prevents HTML entity interpretation

The & escaping is necessary because runtime MdzNodeView.svelte renders text with {node.content} (a Svelte expression), which auto-escapes & to &. The preprocessor emits raw template text where & is NOT auto-escaped, so manual escaping is required to match the runtime behavior.

Recursively evaluates an expression AST node to a static string value.

Handles string Literal, TemplateLiteral (including interpolations when all expressions resolve), BinaryExpression with +, and Identifier lookup via an optional bindings map built by build_static_bindings. Returns null for dynamic expressions, non-string literals, or unsupported node types.

Extracts a static string value from a Svelte attribute value AST node.

Handles three forms: - Boolean true (bare attribute like inline) -- returns null. - Array with a single Text node (quoted attribute like content="text") -- returns the text data. - ExpressionTag (expression like content={'text'}) -- delegates to evaluate_static_expr.

Returns null for null literals, mixed arrays, dynamic expressions, and non-string values.

Finds an attribute by name on a component AST node.

Iterates the node's attributes array and returns the first Attribute node whose name matches. Skips SpreadAttribute, directive, and other node types.

Finds the position to insert new import statements within a script block.

Returns the end position of the last ImportDeclaration, or the start of the script body content if no imports exist.

Generates indented import statement lines from an import map.

Default imports produce import Name from 'path'; lines. Named imports are grouped by path into import {a, b} from 'path'; lines.

Handles errors during Svelte preprocessing with configurable behavior.

Checks if an identifier with the given name appears anywhere in an AST subtree.

Recursively walks all object and array properties of the tree, matching ESTree Identifier nodes ({type: 'Identifier', name}). Nodes in the skip set are excluded from traversal — used to skip ImportDeclaration nodes so the import's own specifier identifier doesn't false-positive.

Skips Identifier nodes in non-reference positions defined by NON_REFERENCE_FIELDS — for example, obj.Mdz (non-computed member property), { Mdz: value } (non-computed object key), and statement labels.

Safe for Svelte template ASTs: Component.name is a plain string property (not an Identifier node), so <Mdz> tags do not produce false matches.

Import metadata for a single import specifier.

Removes an ImportDeclaration from source using MagicString.

Consumes leading whitespace (tabs/spaces) and trailing newline to avoid leaving blank lines.

Removes a specifier from a multi-specifier import declaration by reconstructing the statement without the removed specifier.

Overwrites the entire declaration range to avoid character-level comma surgery.

Handles: - import Mdz, {other} from '...' → import {other} from '...' - import {default as Mdz, other} from '...' → import {other} from '...' - import {Mdz, other} from '...' → import {other} from '...'

Removes a single-declarator VariableDeclaration from source using MagicString.

Consumes leading whitespace (tabs/spaces) and trailing newline to avoid leaving blank lines. Only safe for single-declarator statements (const x = 'val';); callers must verify node.declarations.length === 1 before calling.

Resolves local names that import from specified source paths.

Scans ImportDeclaration nodes in both the instance and module scripts. Handles default, named, and aliased imports. Skips namespace imports and import type declarations (both whole-declaration and per-specifier). Returns import node references alongside names to support import removal.

Information about a resolved component import.

Extracts a chain of conditional expressions where all leaf values are static strings.

Handles nested ternaries like a ? 'x' : b ? 'y' : 'z' by iteratively walking the right-recursive ConditionalExpression chain. At each level, evaluates the consequent via evaluate_static_expr and continues into the alternate if it is another ConditionalExpression. The final alternate is the else branch.

Returns null if the attribute value is not an ExpressionTag containing a ConditionalExpression, if any leaf fails to resolve to a static string, or if the chain exceeds 10 branches (safety limit).

A 2-branch result covers the simple ternary case (a ? 'x' : 'y').