svelte-shaker 0.5.2 → 0.7.0

package/dist/transform.js

@@ -0,0 +1,825 @@
+import MagicString from 'magic-string';
+import { walk } from './parse.js';
+import { remapToLocalNames } from './analyze.js';
+import { decideChain, inSpans } from './dead.js';
+import { evaluate } from './eval.js';
+import { shakeCss } from './css.js';
+/**
+ * Apply every plan to every component and return the shaken source per file.
+ *
+ * Two phases over a shared set of MagicStrings so that a parent's call-site
+ * attributes are removed using each child's *actually dropped* props (not just
+ * what the plan proposed): a prop only leaves the public signature when every
+ * reference to it could be folded or substituted away.
+ */
+export function transformAll(models, plans) {
+    return emit(models, runBasePhases(models, plans));
+}
+/**
+ * Phases 1–2, shared by {@link transformAll} and {@link transformAllWithMono}:
+ * fold each component body and drop its folded props (phase 1), then strip the
+ * now-pointless attribute at every call site of a dropped prop (phase 2).
+ * Returns the per-file MagicStrings, ready for the optional L2 phase 3.
+ */
+function runBasePhases(models, plans) {
+    const strings = new Map();
+    const dropped = new Map();
+    /** Regions phase 1 edited per component — phase 2 must not edit inside them. */
+    const editedSpans = new Map();
+    // Phase 1 — component bodies: fold dead branches, drop folded props.
+    for (const model of models.values()) {
+        const s = new MagicString(model.code);
+        strings.set(model.id, s);
+        const plan = plans.get(model.id);
+        if (plan.bail) {
+            dropped.set(model.id, new Set());
+            continue;
+        }
+        const result = transformBody(model, plan, s);
+        dropped.set(model.id, result.dropped);
+        editedSpans.set(model.id, result.dead);
+    }
+    // Phase 2 — call sites: remove attributes for props the child actually dropped,
+    // skipping any call site phase 1 folded away (its attributes went with it).
+    for (const model of models.values()) {
+        removeCallSiteAttributes(model, dropped, strings.get(model.id), editedSpans.get(model.id) ?? []);
+    }
+    return strings;
+}
+/** Stringify every model's MagicString into the output record. */
+function emit(models, strings) {
+    const out = {};
+    for (const model of models.values())
+        out[model.id] = strings.get(model.id).toString();
+    return out;
+}
+/**
+ * Like {@link transformAll}, but additionally rewrites the L2-bound call sites in
+ * each owner to import a specialized variant from a virtual module.  The base
+ * phases are unchanged (so files with no binding are byte-identical to
+ * {@link transformAll}); phase 3 only edits regions phase 2 never touches — a
+ * bound `<Child …>` tag's NAME, and the frozen-prop attributes (which are
+ * disjoint from the dropped-prop attributes phase 2 removes, because a frozen
+ * prop is by construction NOT in the child's app-wide `constFold`).
+ *
+ * `variantImport(variantId)` maps a variant id to the module specifier the
+ * rewritten `import` should reference (the Shell supplies the virtual id).
+ */
+export function transformAllWithMono(models, plans, bindings, variantImport) {
+    const strings = runBasePhases(models, plans);
+    // Phase 3 — L2: rewrite each bound `<Child …>` site to a specialized variant.
+    rewriteBoundCallSites(models, bindings, variantImport, strings);
+    return emit(models, strings);
+}
+/**
+ * Inject one `import` per (owner, variant) and rewrite each bound site's tag name
+ * to the imported local, removing the frozen-prop attributes.  A fresh local name
+ * `<Child>__shaker_v<n>` is derived from the original tag and the variant index so
+ * distinct variants of the same child never collide within one owner.
+ */
+function rewriteBoundCallSites(models, bindings, variantImport, strings) {
+    // Group bindings by owner; within an owner, assign each variant id a fresh
+    // local import name and remember the imports to inject.
+    const byOwner = new Map();
+    for (const b of bindings) {
+        const list = byOwner.get(b.owner);
+        if (list)
+            list.push(b);
+        else
+            byOwner.set(b.owner, [b]);
+    }
+    for (const [ownerId, list] of byOwner) {
+        const model = models.get(ownerId);
+        const s = strings.get(ownerId);
+        if (!model || !s)
+            continue;
+        const localFor = new Map(); // variantId -> local import name
+        const importsToAdd = [];
+        let counter = 0;
+        for (const b of list) {
+            const original = b.node.name ?? 'Cmp';
+            let local = localFor.get(b.variantId);
+            if (local === undefined) {
+                local = `${original}__shaker_v${counter++}`;
+                localFor.set(b.variantId, local);
+                importsToAdd.push({ local, spec: variantImport(b.variantId) });
+            }
+            rewriteOneSite(model.code, b.node, local, b.foldedProps, s);
+        }
+        if (importsToAdd.length > 0)
+            injectImports(model, importsToAdd, s);
+    }
+}
+/** Rewrite a single `<Child …>` open (and matching close) tag name + strip frozen attrs. */
+function rewriteOneSite(code, node, local, frozen, s) {
+    const name = node.name;
+    if (!name)
+        return;
+    // The open tag name sits right after `<` at the node start.
+    const openNameStart = node.start + 1;
+    if (code.slice(openNameStart, openNameStart + name.length) === name)
+        s.overwrite(openNameStart, openNameStart + name.length, local);
+    // A non-self-closing component has a `</Name>` whose name we must also rewrite.
+    // Find the LAST occurrence of `</name` before node.end (close tags cannot nest
+    // for the same element, and the last one is this element's own).
+    const closeMarker = `</${name}`;
+    const closeIdx = code.lastIndexOf(closeMarker, node.end);
+    if (closeIdx >= node.start) {
+        const from = closeIdx + 2; // skip `</`
+        s.overwrite(from, from + name.length, local);
+    }
+    // Remove the frozen-prop attributes (the variant hard-codes them).  Only
+    // static `Attribute`s are frozen (mono required `!dynamic`), so this never
+    // drops a side-effecting expression.
+    for (const attr of node.attributes ?? []) {
+        if (attr.type !== 'Attribute' || !attr.name || !frozen.has(attr.name))
+            continue;
+        removeAttrWithSpace(code, attr, s);
+    }
+}
+/** Delete an attribute's span plus one preceding space/tab, keeping the tag tidy. */
+function removeAttrWithSpace(code, attr, s) {
+    let start = attr.start;
+    if (code[start - 1] === ' ' || code[start - 1] === '\t')
+        start -= 1;
+    s.remove(start, attr.end);
+}
+/**
+ * Append the variant imports to the owner's instance `<script>` (or prepend a
+ * fresh `<script>` block when the component has none).  Appending after the last
+ * existing statement keeps the original imports intact and positions stable.
+ */
+function injectImports(model, imports, s) {
+    const lines = imports
+        .map((i) => `  import ${i.local} from ${JSON.stringify(i.spec)};`)
+        .join('\n');
+    const instance = model.ast.instance;
+    const body = instance?.content?.body ?? [];
+    if (instance && body.length > 0) {
+        const last = body[body.length - 1];
+        s.appendLeft(last.end, `\n${lines}`);
+        return;
+    }
+    if (instance && instance.content) {
+        // Empty `<script>`: insert at the program start.
+        s.appendLeft(instance.content.start, `\n${lines}\n`);
+        return;
+    }
+    // No instance script at all: prepend a fresh one before everything.
+    s.prepend(`<script>\n${lines}\n</script>\n`);
+}
+function transformBody(model, plan, s) {
+    const dead = [];
+    const dropped = shakeBody(model, plan.constFold, plan.narrow, plan, s, dead);
+    return { dropped, dead };
+}
+/**
+ * Slim one component's body against the given fold (`env`) and narrow (`setEnv`)
+ * environments, editing `s` in place, and return the set of props that left the
+ * `$props()` signature.  Factored out of {@link transformBody} so L2
+ * monomorphization (see `mono.ts`) can re-run the SAME pipeline with an augmented
+ * `env` (a call site's extra literal props) on a fresh MagicString — guaranteeing
+ * a specialized residual is produced by exactly the audited L0/L1/L1.5 machinery,
+ * never a parallel code path.  `cssPlan` carries the value sets CSS removal reads
+ * (its `constFold`/`narrow` are overridden by `env`/`setEnv` before use).
+ */
+export function shakeBody(model, env, setEnv, cssPlan, s, 
+/**
+ * If provided, receives every region this body EDITED (dead `{#if}`/ternary arms
+ * removed, and collapse spans overwritten whole).  Phase 2 (call-site attribute
+ * removal) needs these so it never edits inside a region we already changed — a
+ * `<Child dropped={…}/>` sitting in a folded-away branch would otherwise produce
+ * an overlapping MagicString edit ("Cannot split a chunk that has already been
+ * edited").  Mono (L2) does not pass it; it edits fresh strings.
+ */
+outDead) {
+    // Nothing to fold (L1) and nothing to narrow (L1.5): no branch/prop edits.
+    // CSS removal still depends only on the value sets the plan carries, so a
+    // component with no foldable/narrowable prop produces an empty class set
+    // bound and removes nothing — leave it untouched entirely.
+    if (env.size === 0 && setEnv.size === 0)
+        return new Set();
+    const code = model.code;
+    // `env`/`setEnv` arrive keyed by the EXTERNAL prop name (that is what the plan
+    // and the L2 call-site shapes carry).  Every body/template reference, however,
+    // uses the prop's LOCAL binding name (`prop: alias` -> `alias`), and the two can
+    // even be different entities (a same-named import).  Remap ONCE to local-keyed
+    // maps for every name-matched pass below (branch folding, ternaries, reference
+    // substitution, CSS); the `$props()` signature drop keeps the external names.
+    const localEnv = remapToLocalNames(env, model);
+    const localSetEnv = remapToLocalNames(setEnv, model);
+    // (1) Fold `{#if <const>}` blocks (L1) and narrow if/else-if chains against
+    // the known value sets (L1.5); remember every region we deleted/unwrapped.
+    const dead = [];
+    foldIfBlocks(model.ast.fragment, localEnv, localSetEnv, code, s, dead);
+    // (1b) Fold template ternaries `{cond ? a : b}` whose `cond` is a provable
+    // constant down to the taken arm.  This runs BEFORE substitution: the taken
+    // arm is re-emitted verbatim and the whole ternary span is marked dead, so the
+    // substitution pass below leaves identifiers inside it alone (a sub-range
+    // overwrite inside an already-overwritten span would conflict in MagicString).
+    // Mirrors the `{#if}` "collapse to a kept fragment verbatim" handling.
+    foldTernaries(model.ast.fragment, localEnv, code, s, dead);
+    // (2) Substitute any surviving references to a folded prop with its literal.
+    // Narrowed (set) props are genuinely dynamic and are NOT substituted; we only
+    // walk `localEnv` (constFold). Substitution still reaches references inside KEPT
+    // narrowed arms because those arms are left as original text (only dead arms
+    // are removed), so a constFold prop used inside a surviving arm is handled.
+    const refs = collectPropRefs(model, localEnv, dead);
+    for (const [name, value] of localEnv) {
+        const lit = literalSource(value);
+        for (const ref of refs.get(name) ?? [])
+            s.overwrite(ref.start, ref.end, ref.head + lit + ref.tail);
+    }
+    // (3) Drop only the folded (constFold) props from the `$props()` signature.
+    // Narrowed props stay in the signature — they are still used/dynamic.  The drop
+    // matches the destructure KEYS, so it keeps the EXTERNAL names (which is also
+    // what phase 2's call-site attribute removal consumes).
+    const droppable = new Set(env.keys()); // every surviving ref is an expression position
+    dropProps(model, droppable, s);
+    // (4) CSS rule removal (docs §3 "L1.5", "CSS (shaker 独自の価値)"): drop
+    // `<style>` rules targeting a class the component can provably never produce
+    // given the value sets.  Sound and independent of the branch edits above:
+    // it only reads the possible class set and removes rules no element can match.
+    // Svelte's own unused-CSS pruning still runs afterwards on what remains.
+    //
+    // CSS removal reads the value sets through the plan; rebuild a plan view whose
+    // `constFold`/`narrow` are the ENVIRONMENTS we actually folded with (for L2 a
+    // call site's extra literals shrink the possible class set further), reusing
+    // `cssPlan` for everything else (id, valueSets of untouched props).
+    // CSS matches the value-set maps against TEMPLATE identifiers (`class={alias}`),
+    // so it too reads the LOCAL-keyed environments.
+    const cssView = {
+        ...cssPlan,
+        constFold: localEnv,
+        narrow: localSetEnv,
+    };
+    shakeCss(model, cssView, s);
+    if (outDead)
+        outDead.push(...dead);
+    return droppable;
+}
+/**
+ * Fold `{#if}` blocks and narrow if/else-if chains in one pass.  Each chain's
+ * decision comes from the shared {@link decideChain} (same predicate the
+ * analysis fixpoint uses); here we turn that decision into MagicString edits.
+ * `dead` accumulates the deleted regions so later passes skip them.
+ *
+ * The walk threads each chain's parent fragment (for sibling lookup) and whether
+ * it sits in a preserved-whitespace context (`<pre>`/`<textarea>` ancestor, or a
+ * component-level `<svelte:options preserveWhitespace>`).  {@link applyChain}
+ * needs both to keep the RENDERED whitespace unchanged when a chain disappears:
+ * Svelte trims a whitespace-only text node at a fragment edge but keeps one
+ * between two rendering nodes, so naively deleting a chain that separated two
+ * nodes (or splicing in an arm whose own edge whitespace was trimmed) would lose
+ * or gain a space.
+ */
+function foldIfBlocks(fragment, env, setEnv, code, s, dead) {
+    walk(fragment, { parent: null, preserve: hasPreserveWhitespaceOption(fragment) }, {
+        _(node, { state, next }) {
+            if (node.type !== 'IfBlock') {
+                // Descend, recording this node as the children's parent and whether it
+                // opens a preserved-whitespace context for them.
+                next({ parent: node, preserve: state.preserve || isPreserveElement(node) });
+                return;
+            }
+            // `elseif` IfBlocks are the *continuation* of a chain we already own from
+            // its head; skip them so we never edit the same chain twice. Also skip any
+            // block already inside a region we removed (a dead arm we descended into).
+            if (node.elseif || inSpans(node, dead))
+                return;
+            const decision = decideChain(node, env, setEnv);
+            applyChain(decision, env, code, s, dead, {
+                parent: state.parent,
+                // `state.parent` is the Fragment that holds this chain (the walk sets a
+                // node as its children's parent), so its `nodes` are the chain's siblings.
+                index: state.parent?.nodes?.indexOf(node) ?? -1,
+                preserve: state.preserve,
+            });
+            if (decision.recurse)
+                next({ parent: node, preserve: state.preserve }); // kept head: descend for nested blocks
+            // otherwise the subtree is gone or re-emitted verbatim — do not recurse.
+        },
+    });
+}
+/** Realize one {@link decideChain} decision as MagicString edits, keeping the
+ * rendered whitespace at the chain's seam unchanged (see {@link foldIfBlocks}). */
+function applyChain(decision, env, code, s, dead, ctx) {
+    if (decision.kept) {
+        // The chain collapses to a single surviving fragment, re-emitted verbatim.
+        // Because we overwrite the whole chain span in one shot, the later
+        // substitution pass cannot reach folded-prop references *inside* the kept
+        // fragment (a sub-range edit in an overwritten span conflicts), and those
+        // props are about to be dropped from the signature — so we must substitute
+        // them into the emitted text HERE, or they would become dangling
+        // references.  {@link substitutedSlice} does exactly that.
+        let text = fragmentSource(decision.kept, env, code);
+        // The arm's own leading/trailing whitespace runs were block-fragment edges
+        // (trimmed) in the original, but become INNER once spliced into the parent
+        // fragment — keeping them would GAIN a space.  Strip them.  Under preserved
+        // whitespace nothing was trimmed, so splice verbatim.
+        if (!ctx.preserve)
+            text = text.replace(/^\s+|\s+$/g, '');
+        // A kept arm that is empty or pure whitespace renders nothing, exactly like a
+        // full chain removal — route through the same seam handling so a separating
+        // space is neither lost nor spuriously kept.
+        if (text === '' && !ctx.preserve) {
+            removeChain([decision.span], decision.span, code, s, dead, ctx);
+            return;
+        }
+        s.overwrite(decision.span[0], decision.span[1], text);
+        dead.push(decision.span);
+        return;
+    }
+    // The chain renders nothing (no surviving arm): delete it, compensating the
+    // seam so a space that separated two siblings is not lost.
+    if (isFullRemoval(decision)) {
+        removeChain(decision.removed, decision.span, code, s, dead, ctx);
+        return;
+    }
+    // Otherwise the `{#if}` structure is kept (head survives, or a `{:else if}` is
+    // promoted): the chain still renders in place, so the outer seam is unchanged —
+    // only delete the dead regions.  `removed` ranges and `headerRewrite` are
+    // disjoint (the prefix ends exactly where the promoted header begins).
+    for (const [a, b] of decision.removed) {
+        s.remove(a, b);
+        dead.push([a, b]);
+    }
+    // If a `{:else if}` was promoted to the new head, rewrite its header.
+    if (decision.headerRewrite) {
+        const { from, to, text } = decision.headerRewrite;
+        s.overwrite(from, to, text);
+    }
+}
+/** True when a chain folds away entirely (its whole span is the only removal). */
+function isFullRemoval(decision) {
+    return (decision.kept === undefined &&
+        decision.removed.length === 1 &&
+        decision.removed[0][0] === decision.span[0] &&
+        decision.removed[0][1] === decision.span[1]);
+}
+/**
+ * Delete a chain that renders nothing, compensating the seam so the RENDERED
+ * whitespace is unchanged.  When the chain separated two rendering siblings via
+ * a whitespace-only text node, plain deletion would let that node fall to a
+ * fragment edge and be trimmed — losing a space.  In that one case we overwrite
+ * the whole `L + chain + R` span with `{" "}`: an ExpressionTag is never
+ * edge-trimmed, so it renders exactly one space wherever it lands, matching the
+ * original.  Otherwise plain deletion already preserves space presence (only the
+ * run LENGTH can differ, which the SSR oracle normalizes).  Never compensate
+ * under preserved whitespace — there plain deletion is byte-exact.
+ */
+function removeChain(removed, span, code, s, dead, ctx) {
+    if (!ctx.preserve && ctx.parent?.nodes && ctx.index >= 0) {
+        const seam = analyzeSeam(ctx.parent.nodes, ctx.index, span, code, dead);
+        if (seam) {
+            s.overwrite(seam[0], seam[1], '{" "}');
+            dead.push(seam);
+            return;
+        }
+    }
+    for (const [a, b] of removed) {
+        s.remove(a, b);
+        dead.push([a, b]);
+    }
+}
+/**
+ * Decide whether removing the chain at `siblings[index]` would lose a separating
+ * space, and if so return the `[from, to]` span (covering the adjacent
+ * whitespace-only text siblings plus the chain) to overwrite with `{" "}`.
+ *
+ * Svelte renders a whitespace-only text node as a single space iff it sits
+ * between two rendering nodes (element / text / expression tag / block — a
+ * comment is transparent and counts as a fragment edge), and trims it at a
+ * fragment edge.  With `L`/`R` the chain's adjacent whitespace siblings and
+ * `P`/`N` whether a rendering sibling lies just beyond them:
+ *   origSpace  = (L && P) || (R && N)          // a space rendered originally
+ *   afterSpace = P && N && (L || R)            // … survives plain deletion
+ * A space is lost exactly when `origSpace && !afterSpace`.  A sibling already
+ * consumed by an earlier compensation is treated as absent so two adjacent dead
+ * chains never produce overlapping edits.
+ */
+function analyzeSeam(siblings, index, span, code, dead) {
+    const live = (node) => !!node && !inSpans(node, dead);
+    const left = siblings[index - 1];
+    const right = siblings[index + 1];
+    const L = live(left) && isWhitespaceText(left, code) ? left : undefined;
+    const R = live(right) && isWhitespaceText(right, code) ? right : undefined;
+    const pIdx = L ? index - 2 : index - 1;
+    const nIdx = R ? index + 2 : index + 1;
+    const P = pIdx >= 0 && isRenderingSibling(siblings[pIdx], code);
+    const N = nIdx < siblings.length && isRenderingSibling(siblings[nIdx], code);
+    const origSpace = (!!L && P) || (!!R && N);
+    const afterSpace = P && N && (!!L || !!R);
+    if (!origSpace || afterSpace)
+        return undefined;
+    return [L ? L.start : span[0], R ? R.end : span[1]];
+}
+/** A text node whose source is entirely whitespace. */
+function isWhitespaceText(node, code) {
+    return node.type === 'Text' && /^\s*$/.test(code.slice(node.start, node.end));
+}
+/**
+ * A sibling that adjacent whitespace can "lean on" so it renders a space.  A
+ * whitespace-only text node is not one (it is the seam whitespace itself), and a
+ * `Comment` is transparent to SSR — it acts as a fragment edge for trimming, so
+ * it is not a rendering neighbour either.
+ */
+function isRenderingSibling(node, code) {
+    return node.type !== 'Comment' && !isWhitespaceText(node, code);
+}
+/** An element inside which Svelte preserves whitespace verbatim. */
+function isPreserveElement(node) {
+    return node.type === 'RegularElement' && (node.name === 'pre' || node.name === 'textarea');
+}
+/** Does the component opt into preserved whitespace via `<svelte:options>`? */
+function hasPreserveWhitespaceOption(fragment) {
+    let preserve = false;
+    walk(fragment, null, {
+        SvelteOptions(node) {
+            for (const a of node.attributes ?? []) {
+                if (a.type !== 'Attribute' || a.name !== 'preserveWhitespace')
+                    continue;
+                // `preserveWhitespace` (boolean shorthand) or `={true}` opts in; only an
+                // explicit `={false}` opts out.  Any other (invalid) form is treated as
+                // opting in, since svelte:options requires a static value.
+                preserve = !isExplicitFalse(a.value);
+            }
+        },
+    });
+    return preserve;
+}
+/** True when an attribute value is the literal `{false}` (or `false`). */
+function isExplicitFalse(value) {
+    if (value === false)
+        return true;
+    const parts = (Array.isArray(value) ? value : [value]);
+    return parts.some((p) => p?.type === 'ExpressionTag' &&
+        p.expression?.type === 'Literal' &&
+        p.expression.value === false);
+}
+/**
+ * Fold template ternaries `{cond ? a : b}` to their taken arm when `cond` is a
+ * provable constant under `env` (constFold).  Only the outer-most foldable
+ * ternary in any nesting is rewritten: its taken arm is re-emitted verbatim and
+ * its whole span recorded in `dead`, so neither the substitution pass nor an
+ * inner fold touches it again (a sub-range edit inside an overwritten span would
+ * conflict in MagicString).
+ *
+ * Soundness: a JS conditional only ever evaluates the taken arm at runtime, so
+ * dropping the untaken arm is observation-preserving even if that arm had side
+ * effects — they would never have run.  We fold only when `evaluate` *proves*
+ * the test (no guessing), and we leave value-set (`narrow`) props alone since
+ * those are genuinely dynamic.
+ */
+function foldTernaries(fragment, env, code, s, dead) {
+    if (env.size === 0)
+        return; // ternaries fold only against known constants
+    walk(fragment, null, {
+        ConditionalExpression(node, { next }) {
+            // Skip ternaries inside an already-removed/overwritten region (e.g. a dead
+            // `{#if}` arm, or an outer ternary we just folded): editing them would
+            // conflict, and they no longer appear in the output anyway.
+            if (inSpans(node, dead))
+                return;
+            const test = evaluate(node.test, env);
+            if (!test.known) {
+                next(); // test not provable: keep this ternary, but inner ones may fold
+                return;
+            }
+            const taken = test.value ? node.consequent : node.alternate;
+            // A taken arm always exists for a well-formed ConditionalExpression; guard
+            // defensively so a malformed tree never produces a bad slice.
+            if (!taken) {
+                next();
+                return;
+            }
+            // Emit the taken arm verbatim, but with any folded-prop references inside
+            // it already substituted: those props get dropped from the signature, so a
+            // raw slice would dangle (see {@link substitutedSlice}).
+            s.overwrite(node.start, node.end, substitutedSlice(taken.start, taken.end, [taken], env, code));
+            dead.push([node.start, node.end]); // emitted verbatim -> off-limits, no recurse
+        },
+    });
+}
+function fragmentSource(fragment, env, code) {
+    const nodes = fragment?.nodes ?? [];
+    if (nodes.length === 0)
+        return '';
+    return substitutedSlice(nodes[0].start, nodes[nodes.length - 1].end, nodes, env, code);
+}
+/**
+ * The source for `[from, to)` with every folded-prop (constFold) reference
+ * inside `roots` replaced by its literal.  Used when re-emitting a kept `{#if}`
+ * arm or ternary arm verbatim: the whole span is overwritten in one shot, so the
+ * normal substitution pass cannot reach references inside it, yet those props
+ * are about to leave the `$props()` signature.  Substituting here keeps the
+ * emitted text self-contained (no dangling identifier) and observably identical
+ * — every reference is replaced by the exact constant it was proven to equal.
+ */
+function substitutedSlice(from, to, roots, env, code) {
+    if (env.size === 0)
+        return code.slice(from, to);
+    // Collect every folded-prop edit in source order (shorthand-aware, see
+    // {@link collectFoldRefs}); each is an `[start,end)` overwrite with wrapping.
+    const refs = [];
+    for (const root of roots) {
+        collectFoldRefs(root, env, code, (name, ref) => refs.push({ ...ref, name }));
+    }
+    if (refs.length === 0)
+        return code.slice(from, to);
+    refs.sort((a, b) => a.start - b.start);
+    let out = '';
+    let cursor = from;
+    for (const ref of refs) {
+        out += code.slice(cursor, ref.start);
+        out += ref.head + literalSource(env.get(ref.name)) + ref.tail;
+        cursor = ref.end;
+    }
+    out += code.slice(cursor, to);
+    return out;
+}
+/** Find every folded-prop reference in `model`, outside dead spans, by name. */
+function collectPropRefs(model, env, dead) {
+    const refs = new Map();
+    const scan = (root) => {
+        if (!root)
+            return;
+        collectFoldRefs(root, env, model.code, (name, ref, node) => {
+            if (inSpans(node, dead) || node === model.propsPattern)
+                return;
+            (refs.get(name) ?? setDefault(refs, name)).push(ref);
+        });
+    };
+    scan(model.ast.instance); // only the instance script can reference props
+    scan(model.ast.fragment);
+    return refs;
+}
+/**
+ * Walk `root` and `emit` an edit for every folded-prop reference — both plain
+ * expression reads AND the shorthand positions {@link foldRefFor} expands, plus
+ * `style:NAME` shorthands (which have no expression node and so are invisible to
+ * an identifier walk).  `emit` receives the originating node so callers can
+ * filter by position (e.g. skip dead spans).  Shared by the live substitution
+ * pass and the verbatim re-emit ({@link substitutedSlice}) so both fold
+ * shorthands identically.
+ */
+function collectFoldRefs(root, env, code, emit) {
+    walk(root, { parent: null, grandparent: null }, {
+        _(node, { state, next }) {
+            // `style:NAME` shorthand carries no expression node (its `value` is the
+            // boolean `true` marker), so an identifier walk never sees it; expand it
+            // to `style:NAME={lit}` or the dropped prop would dangle.  Trim trailing
+            // whitespace from the span: some parsers (rsvelte) fold the gap before the
+            // next attribute into the directive's `end`, and overwriting that gap
+            // would glue the expansion onto the next attribute.
+            if (node.type === 'StyleDirective' &&
+                node.value === true &&
+                node.name &&
+                env.has(node.name)) {
+                let end = node.end;
+                while (end > node.start && isSpace(code[end - 1]))
+                    end -= 1;
+                const src = code.slice(node.start, end); // `style:NAME`
+                emit(node.name, { start: node.start, end, head: `${src}={`, tail: '}' }, node);
+            }
+            else if (node.type === 'Identifier' &&
+                node.name &&
+                env.has(node.name) &&
+                !isNonReference(node, state.parent)) {
+                emit(node.name, foldRefFor(node, state.parent, state.grandparent, code), node);
+            }
+            next({ parent: node, grandparent: state.parent });
+        },
+    });
+}
+/**
+ * The edit to substitute a folded prop at the given identifier.  A plain
+ * expression read overwrites just the identifier (no wrapping).  A SHORTHAND
+ * syntactic position is expanded to the explicit `name={value}` the long form
+ * uses, because overwriting the bare identifier there corrupts the syntax:
+ *
+ *   class:compact   ->  class:compact={false}   (`class:false` is a *different* class)
+ *   {compact}       ->  compact={false}         (`{false}` is a reserved word)
+ *
+ * The full forms (`class:compact={compact}`, `compact={compact}`) already place
+ * the identifier inside an expression slot, so they fall through to the plain
+ * overwrite and are unaffected.
+ */
+function foldRefFor(node, parent, grandparent, code) {
+    // `class:NAME` shorthand: the identifier sits in the directive-name slot, right
+    // after the `:` (the long form puts it inside `={…}`, where the char is `{`).
+    if (parent?.type === 'ClassDirective' &&
+        parent.expression === node &&
+        code[node.start - 1] === ':') {
+        const name = code.slice(node.start, node.end);
+        return { start: node.start, end: node.end, head: `${name}={`, tail: '}' };
+    }
+    // `{NAME}` attribute shorthand: the braces belong to the Attribute, not the
+    // ExpressionTag, so overwrite the whole attribute (`{NAME}` -> `NAME={lit}`).
+    if (parent?.type === 'ExpressionTag' &&
+        grandparent?.type === 'Attribute' &&
+        grandparent.name &&
+        code[grandparent.start] === '{') {
+        return {
+            start: grandparent.start,
+            end: grandparent.end,
+            head: `${grandparent.name}={`,
+            tail: '}',
+        };
+    }
+    // Object shorthand `{ NAME }`: a `Property` with `shorthand: true` whose single
+    // identifier is BOTH key and value.  A plain replace yields `{ "lit" }` (invalid);
+    // expand to `NAME: lit`.
+    if (parent?.type === 'Property' && parent.shorthand === true && parent.value === node) {
+        const name = code.slice(node.start, node.end);
+        return { start: node.start, end: node.end, head: `${name}: `, tail: '' };
+    }
+    return { start: node.start, end: node.end, head: '', tail: '' };
+}
+/** True when an Identifier is a property key / member name, not a value read. */
+function isNonReference(node, parent) {
+    if (!parent)
+        return false;
+    if (parent.type === 'MemberExpression' && parent.property === node && !parent.computed)
+        return true;
+    if (parent.type === 'Property' &&
+        parent.key === node &&
+        !parent.computed &&
+        parent.shorthand !== true)
+        return true;
+    // TS type-member name (`interface Props { NAME?: T }` / a `{ NAME: T }` type
+    // literal / a method signature). The key is a member NAME in a type position,
+    // never a value read of a prop, so folding a same-named prop's literal into it
+    // would corrupt the type (`width?: number` -> `36?: number`). Type text is erased
+    // at compile, so the old behavior was byte-wrong but not a runtime fault — still,
+    // the type member must keep its name. (`computed` keys `[expr]` ARE value reads.)
+    if ((parent.type === 'TSPropertySignature' || parent.type === 'TSMethodSignature') &&
+        parent.key === node &&
+        !parent.computed)
+        return true;
+    // Import / export specifier slots are MODULE-EXPORT names, never a read of a
+    // local prop value (`import { count as store }` -> `count` is the module's
+    // export, not our prop).  Substituting a literal there is invalid syntax, so
+    // exclude every specifier identifier position defensively.
+    if (parent.type === 'ImportSpecifier' ||
+        parent.type === 'ImportDefaultSpecifier' ||
+        parent.type === 'ImportNamespaceSpecifier' ||
+        parent.type === 'ExportSpecifier')
+        return true;
+    // Declaration sites are excluded via the shadowing guard in analyze.ts, so
+    // anything reaching here in an expression slot is a genuine value read.
+    return false;
+}
+function dropProps(model, drop, s) {
+    if (!model.props || drop.size === 0)
+        return;
+    const remaining = model.props.filter((p) => !drop.has(p.name));
+    if (remaining.length === 0 && !model.hasRestProp && model.propsDeclaration) {
+        removeWholeLine(model.code, model.propsDeclaration, s); // signature is now empty
+        return;
+    }
+    const properties = model.propsPattern?.properties ?? [];
+    // Remove each MAXIMAL RUN of consecutive dropped properties as a single range so
+    // the separating commas tile cleanly.  A per-property removal mishandles a
+    // trailing comma on the last property and overlaps on consecutive drops, leaving
+    // a dangling `,` (invalid `$props()` destructuring).
+    const droppedNodes = new Set(model.props.filter((p) => drop.has(p.name)).map((p) => p.property));
+    let i = 0;
+    while (i < properties.length) {
+        if (!droppedNodes.has(properties[i])) {
+            i++;
+            continue;
+        }
+        let hi = i;
+        while (hi + 1 < properties.length && droppedNodes.has(properties[hi + 1]))
+            hi++;
+        removePropertyRun(model.code, properties, i, hi, s);
+        i = hi + 1;
+    }
+    // Type members live in the disjoint `}: { … }` annotation; remove them per-prop.
+    if (model.propsPattern) {
+        for (const decl of model.props) {
+            if (drop.has(decl.name))
+                removeTypeMember(model.propsPattern, decl.name, s);
+        }
+    }
+}
+/**
+ * Delete the run of dropped destructuring properties `properties[lo..hi]` together,
+ * absorbing the commas/whitespace so the result stays valid.  When a surviving
+ * property follows the run we eat forward to it; otherwise the run reaches the end,
+ * so we eat any trailing comma and reach back to the previous surviving property's
+ * separator (leaving it with no dangling comma).
+ */
+function removePropertyRun(code, properties, lo, hi, s) {
+    const first = properties[lo];
+    const last = properties[hi];
+    const keptAfter = properties[hi + 1];
+    if (keptAfter) {
+        s.remove(first.start, keptAfter.start); // run + commas + ws up to the next survivor
+        return;
+    }
+    // Run reaches the end of the pattern: include a trailing comma after the last
+    // dropped property if present (so it does not dangle), but NOT the whitespace
+    // before `}` when there is none — keep `{ a }` from becoming `{ a}`.  Then drop
+    // back to the previous survivor's separator.
+    let end = last.end;
+    let j = end;
+    while (j < code.length && /\s/.test(code[j]))
+        j++;
+    if (code[j] === ',')
+        end = j + 1;
+    const keptBefore = properties[lo - 1];
+    s.remove(keptBefore ? keptBefore.end : first.start, end);
+}
+function removeTypeMember(pattern, name, s) {
+    const members = pattern.typeAnnotation?.typeAnnotation?.members ?? [];
+    const i = members.findIndex((m) => m.key?.type === 'Identifier' && m.key.name === name);
+    if (i === -1)
+        return;
+    const member = members[i];
+    const next = members[i + 1];
+    const prev = members[i - 1];
+    // Members are separated by `;` or `,`; eat one separator with the member.
+    if (next)
+        s.remove(member.start, next.start);
+    else if (prev)
+        s.remove(prev.end, member.end);
+    else
+        s.remove(member.start, member.end);
+}
+function removeCallSiteAttributes(model, dropped, s, editedSpans) {
+    walk(model.ast.fragment, null, {
+        Component(node, { next }) {
+            // This `<Child/>` sits inside a branch phase 1 already removed/overwrote;
+            // its source (attributes included) is gone, so editing it now would overlap
+            // that edit ("Cannot split a chunk that has already been edited").  Skip the
+            // whole subtree — every nested call site is in the same dead region.
+            if (editedSpans.length > 0 && inSpans(node, editedSpans))
+                return;
+            const childId = node.name ? model.imports.get(node.name) : undefined;
+            const drop = childId ? dropped.get(childId) : undefined;
+            if (drop && drop.size > 0) {
+                for (const attr of node.attributes ?? []) {
+                    if (attr.type !== 'Attribute' || !attr.name || !drop.has(attr.name))
+                        continue;
+                    if (!isSideEffectFree(attr.value))
+                        continue;
+                    removeAttrWithSpace(model.code, attr, s);
+                }
+            }
+            next();
+        },
+    });
+}
+/** A call-site attribute is safe to delete only if its value has no side effects. */
+function isSideEffectFree(value) {
+    if (value === true || value == null)
+        return true;
+    const parts = (Array.isArray(value) ? value : [value]);
+    return parts.every((part) => {
+        if (part.type === 'Text')
+            return true;
+        if (part.type === 'ExpressionTag')
+            return part.expression?.type === 'Literal';
+        return false;
+    });
+}
+/**
+ * Remove the (now prop-less) `$props()` declaration.  When it is alone on its
+ * line — the realistic case for every `.svelte` file — eat the whole line so no
+ * blank indentation is left behind.  But if it shares its line with other code
+ * (e.g. a hand-minified `let {x}=$props();</script>`), remove ONLY the
+ * declaration (plus a trailing `;`) so we never swallow adjacent source.
+ */
+function removeWholeLine(code, node, s) {
+    let lineStart = node.start;
+    while (lineStart > 0 && code[lineStart - 1] !== '\n')
+        lineStart -= 1;
+    let lineEnd = node.end;
+    while (lineEnd < code.length && code[lineEnd] !== '\n')
+        lineEnd += 1;
+    const prefix = code.slice(lineStart, node.start);
+    const suffix = code.slice(node.end, lineEnd);
+    if (/^\s*$/.test(prefix) && /^\s*;?\s*$/.test(suffix)) {
+        // Alone on the line: remove the line and its trailing newline.
+        s.remove(lineStart, lineEnd < code.length ? lineEnd + 1 : lineEnd);
+    }
+    else {
+        // Shares the line: remove just the declaration (+ a trailing semicolon).
+        s.remove(node.start, code[node.end] === ';' ? node.end + 1 : node.end);
+    }
+}
+function setDefault(map, key) {
+    const arr = [];
+    map.set(key, arr);
+    return arr;
+}
+function isSpace(ch) {
+    return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
+}
+function literalSource(value) {
+    if (value === undefined)
+        return 'undefined';
+    return JSON.stringify(value);
+}