svelte-shaker 0.17.0 → 0.18.1

package/README.md

@@ -49,19 +49,17 @@ npm i -D svelte-shaker   # requires svelte@^5
 
 Nothing else to install. The plugin picks its engine automatically (see
 [Options](#options)): if a **native (napi) Rust** binary loads it runs there —
-parsing with rsvelte in process, fastest, no size ceiling; otherwise a small/medium
-app runs on the **WASM Rust engine** (parsing with **rsvelte** from
-`@rsvelte/compiler`, a bundled WASM dependency — no peer, no platform-specific
-binary) and a large app on the **JS engine** with **svelte/compiler**. `engine` and
-`parser` let you pin the choice.
+parsing with rsvelte in process, by far the fastest; otherwise the shake runs on the
+**JS engine** with **svelte/compiler**, which needs no prebuilt binary and always
+works. Both shake **byte-identically**, so the fallback costs only build time.
+`engine` and `parser` let you pin the choice.
 
 ## Usage (Vite)
 
 Add the plugin **before** `svelte()`. By default it runs only in `vite build` —
 dev/HMR is a pass-through (opt into dev shaking with the `dev` option, see
 [Options](#options)). The engine is chosen automatically (native Rust if a binary
-loads, else WASM Rust for small/medium or JS for large), and every path falls back
-cleanly (see [Options](#options)).
+loads, else JS), and every path falls back cleanly (see [Options](#options)).
 
 ```ts
 // vite.config.ts
@@ -87,7 +85,7 @@ through your plugin's `resolveId`/`load` hooks; the unused-prop fold / constant
 fold / value-set narrowing shake only needs the `transform` swap. The
 environment-free engine and the in-browser playground parse with svelte/compiler
 — the Vite plugin's rsvelte selection is a plugin concern (it loads a Node-only
-WASM module); the engine takes an optional `parse` argument if you want to swap it.
+module); the engine takes an optional `parse` argument if you want to swap it.
 
 ### Options
 
@@ -107,9 +105,9 @@ shaker({
   verbose: false, // true = per-file size breakdown after the build
 
   // Engine is auto-selected; set these only to pin.
-  engine: 'auto', // 'auto' (native Rust if it loads, else WASM if <=~300, else JS) | 'js' | 'rust'
-  parser: undefined, // JS/WASM parse only (native always uses in-process rsvelte);
-  // default follows the engine (WASM->rsvelte, JS->svelte); set 'rsvelte' | 'svelte' to pin
+  engine: 'auto', // 'auto' (native Rust if it loads, else JS) | 'js' | 'rust'
+  parser: undefined, // JS engine only (native always uses in-process rsvelte);
+  // defaults to svelte/compiler; set 'rsvelte' to pin rsvelte instead
 
   dev: false, // default off: dev is a pass-through. 'incremental' (re-parse only
   // changed files) | 'coarse' (re-analyze everything) opts in; never monomorphizes
@@ -120,33 +118,25 @@ That list is exhaustive: any other key **fails the build**, naming the key and t
 options that do exist. A typo would otherwise be ignored — and a misspelled
 `preserve` ships the component you meant to protect, over-shaken.
 
-- **`engine`** — which engine runs the shake. There are two Rust engines (the same
-  analysis behind two frontends) plus the JS engine. The **native (napi)** engine
-  parses with rsvelte **in process** and keeps the ASTs Rust-side, so no
-  whole-program AST crosses a boundary — fastest, no size ceiling — but it ships as
-  a per-platform prebuilt binary that may not exist for every install. The **WASM**
-  engine is the same Rust engine, but the whole-program AST must cross the JS↔WASM
-  boundary as JSON (tens of MB past a few hundred components), so it only wins for
-  small/medium apps; the **JS** engine needs no boundary crossing, so it wins for a
-  large app when the native binary isn't available. **`'auto'`** (default) uses the
-  native engine if a binary loads (no size gate), else the WASM engine for a
-  small/medium app or the JS engine for a large one. **`'rust'`** forces a Rust
-  engine — native if it loads, else WASM (throwing if `@rsvelte/compiler` can't load
-  for the WASM fallback); **`'js'`** forces the JS engine. All three are
+- **`engine`** — which engine runs the shake. There are two. The **native (napi
+  Rust)** engine parses with rsvelte **in process** and keeps the ASTs Rust-side, so
+  no whole-program AST crosses a boundary — by far the fastest — but it ships as a
+  per-platform prebuilt binary that may not exist for every install. The **JS**
+  engine needs no prebuilt binary and always works. **`'auto'`** (default) uses the
+  native engine if a binary loads, else the JS engine. **`'rust'`** forces the native
+  engine, throwing if it can't be loaded; **`'js'`** forces the JS engine. Both are
   differentially tested to shake **byte-identically**, so this is **speed-only** — it
   never changes what ships.
-- **`parser`** — how the **JS / WASM** engines parse `.svelte`. It does **not** apply
-  to the native engine, which always parses with rsvelte in process. The default
-  **follows the engine**: **rsvelte** on the WASM engine (its AST crosses into Rust
-  directly), **svelte/compiler** on the JS engine (where rsvelte's parse is ~2× slower
-  with no downstream benefit). The choice is **soundness-neutral** — the engine reads
-  only UTF-16 `start`/`end`, so both parsers are differentially tested to produce
+- **`parser`** — how the **JS** engine parses `.svelte`. It does **not** apply to the
+  native engine, which always parses with rsvelte in process. It defaults to
+  **svelte/compiler**, because on the JS engine rsvelte's parse is ~2× slower with no
+  downstream benefit. The choice is **soundness-neutral** — the engine reads only
+  UTF-16 `start`/`end`, so both parsers are differentially tested to produce
   **byte-identical** output, never changing what renders. `parser: 'svelte'` also
   forces the native engine **off** (it can't honor svelte/compiler), so the shake uses
-  a JS/WASM engine with svelte/compiler. When rsvelte is the resolved JS-side parser
-  (`parser: 'rsvelte'`, or the WASM engine's default) and `@rsvelte/compiler` can't
-  load, the plugin **throws** rather than silently swapping (so the same source can't
-  shake differently on another machine); `parser: 'svelte'` is the explicit opt-out.
+  the JS engine. With an explicit `parser: 'rsvelte'` that `@rsvelte/compiler` can't
+  satisfy, the plugin **throws** rather than silently swapping (so the same source
+  can't shake differently on another machine); `parser: 'svelte'` is the opt-out.
 - **`monomorphize`** — the one shaking knob, **on** by default. A measured
   net-win gate only specializes a component when that strictly shrinks the whole
   program, so monomorphization **never bloats**: whatever the knobs are set to,

package/dist/crawl-dRCzCERA.d.ts

@@ -0,0 +1,43 @@
+import { d as ParseCache, n as ComponentId, t as AnalyzeInput, u as Parse } from "./ir-BDouNmBm.js";
+//#region src/crawl.d.ts
+type Resolve = (source: string, importer: ComponentId) => Promise<ComponentId | null> | ComponentId | null;
+type ReadFile = (id: ComponentId) => Promise<string> | string;
+interface ImportInfo {
+  value: string;
+  local: string;
+  /** `default` for a default import, the exported name for a named import, or
+   * `*` for a namespace import. */
+  imported: string;
+}
+/**
+ * The three per-file facts the crawl needs to resolve edges — import specifiers,
+ * rendered `<Local>` tag names, and `<ns.X>` member tag names. `null` when the file
+ * has no instance script (nothing to attribute), matching the crawl's skip.
+ */
+interface CrawlFacts {
+  imports: ImportInfo[];
+  renderedTags: Set<string>;
+  memberTags: Set<string>;
+}
+/**
+ * Source of {@link CrawlFacts} for one `(id, code)`. The default is a JS parse +
+ * extraction ({@link jsCrawlFacts}); the native engine passes a provider backed by
+ * `ShakeSession` facts, so the crawl resolves the SAME edges without the JS parse.
+ */
+type FactsProvider = (id: ComponentId, code: string) => CrawlFacts | null;
+/**
+ * The Shell-side resolution + IO layer (docs/RUST-MIGRATION.md §2.1): BFS-crawl
+ * the component graph from `entries`, resolving every import edge and reading
+ * every reachable `.svelte` file up front, into a batched {@link AnalyzeInput}.
+ *
+ * This is the half that STAYS in JS — it owns `this.resolve` / file IO for Vite
+ * ecosystem compat (docs ARCHITECTURE §5/§9) — so the engine ({@link
+ * analyzeInput}) consumes its output with no callback across the boundary.  The
+ * traversal mirrors the old crawl exactly: direct default-`.svelte` children and
+ * the barrel children a file actually RENDERS are followed (an unrendered barrel
+ * import is never crawled — its `<Comp/>` site cannot exist, so it cannot taint a
+ * value set), keeping the produced model set — and thus the output — identical.
+ */
+declare function buildAnalyzeInput(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, parseCache?: ParseCache, parse?: Parse, escaped?: ComponentId[], factsProvider?: FactsProvider): Promise<AnalyzeInput>;
+//#endregion
+export { Resolve as n, buildAnalyzeInput as r, ReadFile as t };

package/dist/{dev-only.d.ts → dev-only-vMKGdavE.d.ts}

@@ -1,4 +1,5 @@
-import type { ComponentId } from './ir.js';
+import { n as ComponentId } from "./ir-BDouNmBm.js";
+//#region src/dev-only.d.ts
 /**
  * Files treated as DEV-ONLY by default: colocated tests, mocks, and Storybook
  * stories — files that never ship, so their call sites must not count toward the
@@ -7,9 +8,9 @@ import type { ComponentId } from './ir.js';
  * not for narrowing app coverage, and the shipped-file-matching failure mode).
  * Passing `devOnly` REPLACES this list; `devOnly: []` counts every file.
  */
-export declare const DEFAULT_DEV_ONLY: readonly string[];
+declare const DEFAULT_DEV_ONLY: readonly string[];
 /** Predicate over an ABSOLUTE path: `true` when the file is dev-only (discounted by a scan). */
-export type DevOnlyFilter = (file: ComponentId) => boolean;
+type DevOnlyFilter = (file: ComponentId) => boolean;
 /**
  * Compile dev-only `patterns` into a {@link DevOnlyFilter}.  Each candidate path is
  * matched (with `picomatch`) as its `base`-relative, posix-normalized form, so the
@@ -20,4 +21,6 @@ export type DevOnlyFilter = (file: ComponentId) => boolean;
  * Defaults to {@link DEFAULT_DEV_ONLY}; an empty `patterns` array matches nothing, so
  * `devOnly: []` counts every file (the pre-`devOnly` behavior).
  */
-export declare function compileDevOnly(base: string, patterns?: readonly string[]): DevOnlyFilter;
+declare function compileDevOnly(base: string, patterns?: readonly string[]): DevOnlyFilter;
+//#endregion
+export { DevOnlyFilter as n, compileDevOnly as r, DEFAULT_DEV_ONLY as t };

package/dist/index.d.ts

@@ -1,15 +1,163 @@
-import { type ReadFile, type Resolve } from './analyze.js';
-import { type Parse } from './parse.js';
-import { type MonomorphizeOptions, type MonomorphizeResult, type OwnSize } from './mono.js';
-import type { ComponentId } from './ir.js';
-export type { ComponentId, AnalyzeInput, InputFile, ResolvedEdge, EdgeKind, EditResult, } from './ir.js';
-export type { Resolve, ReadFile, ResolveSync, ReadFileSync } from './analyze.js';
-export type { Parse, Root } from './parse.js';
-export { analyze, analyzeInput, buildAnalyzeInput, buildAnalyzeInputSync, deadSpansForPlans, findNeverPassedProps, } from './analyze.js';
-export type { UnpassedProp } from './analyze.js';
-export { DevShaker, type DevMode, type DevShakerChange } from './engine.js';
-export { transformAll, transformAllWithMono } from './transform.js';
-export { monomorphize, DEFAULT_MONO_OPTIONS, type MonomorphizeOptions, type MonomorphizeResult, type OwnSize, type Variant, type CallSiteBinding, } from './mono.js';
+import { a as EditResult, c as ResolvedEdge, f as Root, i as EdgeKind, l as AnyNode, n as ComponentId, o as InputFile, r as ComponentPlan, s as Literal, t as AnalyzeInput, u as Parse } from "./ir-BDouNmBm.js";
+import { n as Resolve, r as buildAnalyzeInput, t as ReadFile } from "./crawl-dRCzCERA.js";
+import { i as OwnSize, n as MonomorphizeOptions, r as MonomorphizeResult, t as DEFAULT_MONO_OPTIONS } from "./mono-gDUeXt7W.js";
+//#region src/model.d.ts
+/**
+ * The set of input names a child component can ever OBSERVE at runtime (reverse
+ * analysis).  In runes there is no `$$props`/`$$restProps`, so a
+ * component reads an input only through its `$props()` destructure:
+ *  - `{ kind: 'names' }` — a clean, rest-free ObjectPattern `$props()` (or no
+ *    `$props()` at all, giving the empty set): the child can observe EXACTLY
+ *    these declared external names, so a call-site input NOT in the set can
+ *    never be seen and is safe to drop;
+ *  - `{ kind: 'all' }` — anything we cannot pin down: a `...rest` (captures
+ *    undeclared inputs), an Identifier/Array binding (`let p = $props()`),
+ *    more than one `$props()` call, `$props()` outside a `let <pat> = …`
+ *    declarator, or a component that observes slotted content outside `$props()`
+ *    — a legacy `<slot>` element or a `$$slots` read (both legal in runes mode).
+ *    Then any input might be observed, so nothing is dropped.
+ */
+type ReachableInputs = {
+  kind: "all";
+} | {
+  kind: "names";
+  names: Set<string>;
+};
+/** One declared prop in a `$props()` destructuring. */
+interface PropDecl {
+  /** The EXTERNAL prop name — the destructure KEY (`prop` in `prop: alias`).
+   * Call sites pass this name, so value sets / dropping key off it. */
+  name: string;
+  /**
+   * The LOCAL binding name the entry introduces in the body — the destructure
+   * VALUE (`alias` in `prop: alias`, or the bare name for a shorthand `prop`),
+   * or `null` when the entry binds a NESTED pattern (`prop: { x }`) rather than a
+   * single identifier.  Body and template references use THIS name, not {@link
+   * name}, so folding/substitution must look props up by it (`prop` and its alias
+   * `alias` can even be different entities — e.g. a same-named import).  A `null`
+   * local is never foldable: there is no single identifier to substitute or drop.
+   */
+  local: string | null;
+  /** The `Property` node inside the `ObjectPattern` (for surgical removal). */
+  property: AnyNode;
+  /** Default value expression, if `name = <default>`. */
+  defaultExpr?: AnyNode | undefined;
+}
+/** Everything we learn from parsing one component, reused by the transform. */
+interface FileModel {
+  id: ComponentId;
+  code: string;
+  ast: Root;
+  /**
+   * Tag name a call site renders -> resolved child component id.  Holds every
+   * attributable edge into this file: a bare local for a direct `.svelte`
+   * default or a simple barrel/named import (`Sub`), and a dotted member for a
+   * namespace render (`ns.Sub`).  {@link collectChildCalls} keys `<Tag .../>`
+   * sites off this map, so every kind feeds the child's value set.
+   */
+  imports: Map<string, ComponentId>;
+  /** Declared props, or `null` if the component has no `$props()` pattern. */
+  props: PropDecl[] | null;
+  /** The `let { ... } = $props()` declaration + its pattern, for editing. */
+  propsDeclaration?: AnyNode | undefined;
+  propsPattern?: AnyNode | undefined;
+  hasRestProp: boolean;
+  /**
+   * The inputs this component can observe.  Drives the reverse pass:
+   * a call site of THIS component may drop an input outside {@link
+   * ReachableInputs}.  Computed syntactically from the `$props()` shape.
+   */
+  reachableInputs: ReachableInputs;
+  /**
+   * EXTERNAL names of props this component DECLARES but never READS (unread
+   * declared props): destructured out of a clean `$props()` yet with zero
+   * value-position reference to their local binding anywhere in the instance
+   * script or template.  Such a
+   * prop is invisible to the child, so its call-site attribute is dead and — when
+   * safe — the declaration can be dropped.  Source-only (independent of the call
+   * sites), so it is computed ONCE here, never inside the fixpoint; the transform
+   * gates its use on the component's plan not being bailed.
+   */
+  unreadDeclaredProps: Set<string>;
+  /**
+   * Every `<Child .../>` instance THIS component renders, with the child it
+   * resolves to and the AST node (so the fixpoint can test whether the site
+   * falls inside a dead `{#if}` span of this component — docs §2.1).
+   */
+  childCalls: ChildCall[];
+  /**
+   * Names this component binds OUTSIDE the `$props()` pattern — local `let` /
+   * `function` declarations in the instance script, and every template-scope
+   * binder (`{#each … as ctx, i}`, destructure patterns, `{#snippet name(p)}`,
+   * `{#await … then v}` / `{:catch e}`, `let:` directives).  A declared prop
+   * whose name collides with any of these is a DIFFERENT entity inside that
+   * scope, so folding/substituting/dropping it would corrupt the binding (and
+   * often produce invalid Svelte).  We therefore never fold such a prop.
+   */
+  shadowedNames: Set<string>;
+  /**
+   * Names that appear as a `{@debug …}` argument.  Svelte requires those to be
+   * bare identifiers, so substituting a folded literal there is invalid and
+   * dropping the prop dangles the reference — we never fold a prop named here.
+   */
+  debugNames: Set<string>;
+  /**
+   * Names the component WRITES TO — reassigns (`p = …`, `p += …`), mutates with
+   * `++`/`--`, destructure-assigns (`({ p } = obj)`), or two-way `bind:`s.  A
+   * written prop is not a constant even when every call site passes the same
+   * literal: the write changes it at runtime, so folding it would substitute the
+   * literal into the write's target (`"a" = …`, `0++`, `bind:value={"a"}`) —
+   * invalid Svelte — and, more importantly, silently change what renders after
+   * the write.  We never fold such a prop, exactly like a shadowed one.
+   */
+  writtenNames: Set<string>;
+  /**
+   * Owner-local bindings that are provably a single primitive CONSTANT, keyed by
+   * the LOCAL name a forwarded call-site expression references (docs §13.1
+   * interprocedural pass-through).  Merged into the owner's fold env so that
+   * `<Child {count}/>` — where `count` is an unmutated `let count = $state(0)` or
+   * a `const count = 0` — folds in the child exactly as a call-site literal would,
+   * feeding BOTH constant fold and value-set narrowing.  A static property of the
+   * source (independent of the fixpoint's plans), so it is computed ONCE here.
+   * See {@link computeScriptConstEnv} for the (conservative) admission rules.
+   */
+  scriptConstEnv: ReadonlyMap<string, Literal>;
+  /**
+   * Resolved ids of CHILD components this file leaks as a value (escape, docs
+   * §4.1) — e.g. `<svelte:component this={Child}>`.  `analyze` unions these
+   * across the program and bails every escaped component completely, since its
+   * prop profile can no longer be observed from `<Child .../>` sites alone.
+   */
+  escapedComponents: Set<ComponentId>;
+  /** Reasons this whole component must be left untouched. */
+  bailReasons: string[];
+}
+/** One `<Child .../>` instance rendered by a component. */
+interface ChildCall {
+  childId: ComponentId;
+  node: AnyNode;
+}
+//#endregion
+//#region src/analyze.d.ts
+interface AnalyzeResult {
+  models: Map<ComponentId, FileModel>;
+  plans: Map<ComponentId, ComponentPlan>;
+}
+/**
+ * Crawl the component graph from `entries` and compute a plan per component,
+ * iterating to a whole-program fixpoint (docs §2.1).
+ *
+ * The crucial cascade: a `<Child/>` that lives inside a branch we fold away must
+ * NOT count toward the child's prop profile.  Excluding it can shrink the
+ * child's value sets and enable more folding, which can fold away yet more
+ * branches.  So we parse every component once, then alternate between
+ *   (a) collecting call sites that are NOT inside a current dead span, and
+ *   (b) recomputing plans (and hence dead spans) from that usage,
+ * until the plans stop changing.
+ */
+declare function analyze(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, escaped?: ComponentId[]): Promise<AnalyzeResult>;
+//#endregion
+//#region src/index.d.ts
 /**
  * Whole-program shake: crawl the component graph from `entry`, decide what to
  * fold, and return the shaken source for every reachable `.svelte` file.
@@ -20,21 +168,21 @@ export { monomorphize, DEFAULT_MONO_OPTIONS, type MonomorphizeOptions, type Mono
  * Node callers use `fsResolve` / `fs.readFileSync` from `svelte-shaker/node`.
  * See docs/ARCHITECTURE.md §5 — this is the Engine; the Shell owns resolution.
  */
-export declare function svelteShaker(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, parse?: Parse, escaped?: ComponentId[]): Promise<Record<ComponentId, string>>;
+declare function svelteShaker(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, parse?: Parse, escaped?: ComponentId[]): Promise<Record<ComponentId, string>>;
 /** The full output of a shake including monomorphization specialization. */
-export interface ShakeResult {
-    /**
-     * Whole-program output: shaken source per `.svelte` file.  With monomorphization OFF this is
-     * byte-for-byte identical to {@link svelteShaker}; with monomorphization ON, owner files
-     * whose call sites were specialized have those sites rewritten to import a
-     * variant via `variantSpecifier(variantId)`.
-     */
-    files: Record<ComponentId, string>;
-    /** monomorphization specialized variants + call-site bindings (empty when monomorphization is off). */
-    mono: MonomorphizeResult;
+interface ShakeResult {
+  /**
+   * Whole-program output: shaken source per `.svelte` file.  With monomorphization OFF this is
+   * byte-for-byte identical to {@link svelteShaker}; with monomorphization ON, owner files
+   * whose call sites were specialized have those sites rewritten to import a
+   * variant via `variantSpecifier(variantId)`.
+   */
+  files: Record<ComponentId, string>;
+  /** monomorphization specialized variants + call-site bindings (empty when monomorphization is off). */
+  mono: MonomorphizeResult;
 }
 /** Build the module specifier a rewritten call site imports a variant from. */
-export type VariantSpecifier = (variantId: string) => string;
+type VariantSpecifier = (variantId: string) => string;
 /**
  * Whole-program shake WITH optional monomorphization (docs §3 "monomorphization").
  *
@@ -45,4 +193,6 @@ export type VariantSpecifier = (variantId: string) => string;
  * specialized and `files` equals the unused-prop fold / constant fold / value-set narrowing output exactly — a strict
  * superset of the default behavior, so existing consumers are unaffected.
  */
-export declare function svelteShakerWithMono(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono?: MonomorphizeOptions, variantSpecifier?: VariantSpecifier, parse?: Parse, escaped?: ComponentId[], ownSize?: OwnSize): Promise<ShakeResult>;
+declare function svelteShakerWithMono(entries: ComponentId | ComponentId[], resolve: Resolve, readFile: ReadFile, mono?: MonomorphizeOptions, variantSpecifier?: VariantSpecifier, parse?: Parse, escaped?: ComponentId[], ownSize?: OwnSize): Promise<ShakeResult>;
+//#endregion
+export { type AnalyzeInput, type ComponentId, DEFAULT_MONO_OPTIONS, type EdgeKind, type EditResult, type InputFile, type MonomorphizeOptions, type OwnSize, type Parse, type ReadFile, type Resolve, type ResolvedEdge, type Root, ShakeResult, VariantSpecifier, analyze, buildAnalyzeInput, svelteShaker, svelteShakerWithMono };

package/dist/index.js

@@ -1,74 +1 @@
-import { analyze, analyzeInput, buildAnalyzeInput, } from './analyze.js';
-import {} from './parse.js';
-import { transformAll, transformAllWithMono } from './transform.js';
-import { monomorphize, DEFAULT_MONO_OPTIONS, } from './mono.js';
-import { shakeWithRevertCascade } from './revert-cascade.js';
-export { analyze, analyzeInput, buildAnalyzeInput, buildAnalyzeInputSync, deadSpansForPlans, findNeverPassedProps, } from './analyze.js';
-export { DevShaker } from './engine.js';
-export { transformAll, transformAllWithMono } from './transform.js';
-export { monomorphize, DEFAULT_MONO_OPTIONS, } from './mono.js';
-/**
- * Whole-program shake: crawl the component graph from `entry`, decide what to
- * fold, and return the shaken source for every reachable `.svelte` file.
- *
- * `resolve` / `readFile` are injected so the engine stays environment-free —
- * it has NO `node:*` imports, so it runs unchanged in the browser (the
- * playground passes an in-memory file map). A Vite plugin passes `this.resolve`;
- * Node callers use `fsResolve` / `fs.readFileSync` from `svelte-shaker/node`.
- * See docs/ARCHITECTURE.md §5 — this is the Engine; the Shell owns resolution.
- */
-export async function svelteShaker(entries, resolve, readFile, parse, escaped = []) {
-    const { models, plans } = await analyzeWith(entries, resolve, readFile, parse, escaped);
-    return shakeWithRevertCascade(models, plans, (p) => transformAll(models, p));
-}
-/**
- * Crawl + analyze with an optional non-default parser ({@link Parse}).  When
- * `parse` is given (the Vite plugin's `parser: 'rsvelte'` path), each file is
- * parsed ONCE into a shared cache during the crawl and that cache is reused by the
- * analysis — so the alternate parser drives the whole engine with no second parse.
- * When omitted, this is exactly `analyze(entries, resolve, readFile)` (the default
- * svelte/compiler path, byte-for-byte unchanged).
- */
-async function analyzeWith(entries, resolve, readFile, parse, escaped = []) {
-    if (!parse)
-        return analyze(entries, resolve, readFile, escaped);
-    const cache = new Map();
-    const input = await buildAnalyzeInput(entries, resolve, readFile, cache, parse, escaped);
-    return analyzeInput(input, cache);
-}
-/**
- * Whole-program shake WITH optional monomorphization (docs §3 "monomorphization").
- *
- * `mono` carries the specialized variants (id -> residual source) and the call
- * sites bound to them; `files` is the wired owner source.  The Shell resolves
- * `variantSpecifier(id)` to a virtual module whose source is
- * `mono.variants.get(id)!.code`.  With `mono.enabled` false (default) nothing is
- * specialized and `files` equals the unused-prop fold / constant fold / value-set narrowing output exactly — a strict
- * superset of the default behavior, so existing consumers are unaffected.
- */
-export async function svelteShakerWithMono(entries, resolve, readFile, mono = DEFAULT_MONO_OPTIONS, variantSpecifier = (id) => id, parse, escaped = [], ownSize) {
-    const { models, plans } = await analyzeWith(entries, resolve, readFile, parse, escaped);
-    // The cascade may re-run the transform with force-bailed plans, so recompute
-    // monomorphization inside it: a bailed component must not be specialized either.
-    // `lastResult` captures the mono result of the final (converged or no-op) pass.
-    // On the no-op fallback the emitted owner files are the untouched originals —
-    // they import no variant — so any variants `lastResult` still lists are simply
-    // never requested.
-    let lastResult;
-    const files = shakeWithRevertCascade(models, plans, (p) => {
-        // Thread the shake entries through so the net-win gate can compute module
-        // reachability from them (docs §3 monomorphization, §13.2).
-        lastResult = monomorphize(models, p, mono, entries, ownSize);
-        // With no bindings the wired pass and the base pass are identical, so reuse
-        // the plain transform to keep the default path byte-for-byte unchanged.
-        return lastResult.bindings.length === 0
-            ? transformAll(models, p)
-            : transformAllWithMono(models, p, lastResult.bindings.map((b) => ({
-                owner: b.owner,
-                node: b.node,
-                variantId: b.variantId,
-                foldedProps: b.foldedProps,
-            })), variantSpecifier);
-    });
-    return { files, mono: lastResult };
-}
+import{c as e,i as t,n,o as r,t as i}from"./src-5VY_edrh.js";export{t as DEFAULT_MONO_OPTIONS,r as analyze,e as buildAnalyzeInput,i as svelteShaker,n as svelteShakerWithMono};