svelte-shaker 0.15.2 → 0.15.3

package/dist/analyze.js

@@ -1,7 +1,7 @@
 import { parseCached, parseModuleProgram, walk, } from './parse.js';
-import { emptyPlan, } from './ir.js';
+import { emptyPlan, isFoldableValue, } from './ir.js';
 import { computeDeadSpans, inSpans } from './dead.js';
-import { evaluate, setVar, unwrapTsAssertions } from './eval.js';
+import { evaluate, literalValue, setVar, unwrapTsAssertions } from './eval.js';
 const isSvelte = (source) => source.endsWith('.svelte');
 /** Floor for the fixpoint iteration bound (see {@link fixpointIterationBound}). */
 const MIN_FIXPOINT_ITERATIONS = 10;
@@ -1488,7 +1488,7 @@ function literalAttrValue(value) {
             // `dynamic` flag itself must match — mono's `specializableShape` reads it.
             const expr = unwrapTsAssertions(part.expression);
             if (expr?.type === 'Literal')
-                return { known: true, value: expr.value };
+                return literalValue(expr);
         }
         return { known: false };
     }
@@ -1549,7 +1549,9 @@ function buildPlan(model, u, ownerEnv) {
             continue;
         // constant fold: a clean singleton value set is the foldable case.
         if (set.values.length === 1) {
-            plan.constFold.set(decl.name, set.values[0]);
+            const only = set.values[0];
+            if (isFoldableValue(only))
+                plan.constFold.set(decl.name, only);
             continue;
         }
         // value-set narrowing: >= 2 distinct literals with no dynamic/⊤ contribution is a fully
@@ -1633,8 +1635,13 @@ function literalDefault(expr) {
     expr = unwrapTsAssertions(expr) ?? undefined;
     if (!expr)
         return { known: true, value: undefined }; // omitted default -> undefined
+    // `literalValue` is the same gate `literalAttrValue` and `evaluate` use: a
+    // BigInt/RegExp default (no faithful source form) or a `null` that is really
+    // `1e999` surviving JSON transport must stay UNKNOWN here too, or a call site
+    // that merely omits the prop reintroduces the crash/misfold this default path
+    // exists to prevent.
     if (expr.type === 'Literal')
-        return { known: true, value: expr.value };
+        return literalValue(expr);
     if (expr.type === 'Identifier' && expr.name === 'undefined')
         return { known: true, value: undefined };
     return { known: false };

package/dist/eval.d.ts

@@ -31,6 +31,21 @@ export declare function unwrapTsAssertions(node: AnyNode | null | undefined): An
  * unknown on non-distributive ops), just without the interprocedural lattice.
  */
 export declare function evaluate(node: AnyNode | null | undefined, env: ReadonlyMap<string, Literal>): EvalResult;
+/**
+ * The `Literal` value of an ESTree `Literal` node, or unknown when the node
+ * carries a value outside that union.  This is the ONLY door through which a
+ * parsed value enters the engine, so it is where the union is enforced:
+ *
+ *  - **RegExp / BigInt literals** (`/x/g`, `1n`) hold a `RegExp` / `bigint` in
+ *    `value` — no faithful literal source form, and `JSON.stringify` throws on
+ *    the latter and flattens the former to `{}`.  Both carry a discriminator.
+ *  - **`value: null`** is ambiguous: an AST that reached us as JSON (the rsvelte
+ *    parser crosses a WASM boundary that way) cannot represent `Infinity`, so
+ *    `1e999` arrives indistinguishable from a genuine `null` except by `raw`.
+ *
+ * Anything unproven stays unknown, which costs one fold — never a wrong one.
+ */
+export declare function literalValue(node: AnyNode): EvalResult;
 /**
  * Sound set-aware predicate.  `constEnv` holds props collapsed to a single
  * literal (`constFold`); `setEnv` holds props whose reachable value set is known

package/dist/eval.js

@@ -37,7 +37,7 @@ export function evaluate(node, env) {
         return UNKNOWN;
     switch (node.type) {
         case 'Literal':
-            return { known: true, value: node.value };
+            return literalValue(node);
         case 'Identifier': {
             const name = node.name ?? '';
             if (name === 'undefined')
@@ -132,6 +132,30 @@ export function evaluate(node, env) {
             return UNKNOWN;
     }
 }
+/**
+ * The `Literal` value of an ESTree `Literal` node, or unknown when the node
+ * carries a value outside that union.  This is the ONLY door through which a
+ * parsed value enters the engine, so it is where the union is enforced:
+ *
+ *  - **RegExp / BigInt literals** (`/x/g`, `1n`) hold a `RegExp` / `bigint` in
+ *    `value` — no faithful literal source form, and `JSON.stringify` throws on
+ *    the latter and flattens the former to `{}`.  Both carry a discriminator.
+ *  - **`value: null`** is ambiguous: an AST that reached us as JSON (the rsvelte
+ *    parser crosses a WASM boundary that way) cannot represent `Infinity`, so
+ *    `1e999` arrives indistinguishable from a genuine `null` except by `raw`.
+ *
+ * Anything unproven stays unknown, which costs one fold — never a wrong one.
+ */
+export function literalValue(node) {
+    if (node.regex !== undefined || node.bigint !== undefined)
+        return UNKNOWN;
+    const v = node.value;
+    if (v === null)
+        return node.raw === 'null' ? { known: true, value: null } : UNKNOWN;
+    if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean')
+        return { known: true, value: v };
+    return UNKNOWN;
+}
 /**
  * Sound set-aware predicate.  `constEnv` holds props collapsed to a single
  * literal (`constFold`); `setEnv` holds props whose reachable value set is known

package/dist/ir.d.ts

@@ -131,4 +131,18 @@ export interface ComponentPlan {
      */
     valueSets: Map<string, PropValueSet>;
 }
+/**
+ * Whether a proven value may be SUBSTITUTED into the residual as a constant.
+ *
+ * Every member of {@link Literal} has a faithful source form except `-0`: the
+ * Svelte compiler constant-folds the expression it is spliced into and loses the
+ * sign of zero there (`{1 / n}` renders `-Infinity` with `n = -0` at runtime,
+ * but the folded `{1 / (-0)}` compiles to a literal `Infinity`).  Emitting it
+ * would therefore change what renders even though the value we proved is right,
+ * so a `-0`-valued prop is simply left alone — one missed fold, no risk.
+ *
+ * Narrowing is unaffected: a narrowed prop stays dynamic and is never
+ * substituted, and the comparisons it feeds use real JS semantics.
+ */
+export declare function isFoldableValue(value: Literal): boolean;
 export declare function emptyPlan(id: ComponentId): ComponentPlan;

package/dist/ir.js

@@ -3,6 +3,22 @@
 // See docs/ARCHITECTURE.md §5.1.  This is the M0 (walking-skeleton) subset:
 // only the pieces basic1 exercises, but shaped so later levels slot in.
 // ----------------------------------------------------------------------
+/**
+ * Whether a proven value may be SUBSTITUTED into the residual as a constant.
+ *
+ * Every member of {@link Literal} has a faithful source form except `-0`: the
+ * Svelte compiler constant-folds the expression it is spliced into and loses the
+ * sign of zero there (`{1 / n}` renders `-Infinity` with `n = -0` at runtime,
+ * but the folded `{1 / (-0)}` compiles to a literal `Infinity`).  Emitting it
+ * would therefore change what renders even though the value we proved is right,
+ * so a `-0`-valued prop is simply left alone — one missed fold, no risk.
+ *
+ * Narrowing is unaffected: a narrowed prop stays dynamic and is never
+ * substituted, and the comparisons it feeds use real JS semantics.
+ */
+export function isFoldableValue(value) {
+    return !Object.is(value, -0);
+}
 export function emptyPlan(id) {
     return {
         id,

package/dist/mono.d.ts

@@ -1,6 +1,6 @@
 import { type FileModel } from './analyze.js';
 import { type AnyNode } from './parse.js';
-import type { ComponentId, ComponentPlan, Literal } from './ir.js';
+import { type ComponentId, type ComponentPlan, type Literal } from './ir.js';
 /** Tuning knobs for monomorphization (docs §8.1, §13.2).  All have sound defaults. */
 export interface MonomorphizeOptions {
     /** Master switch.  Default OFF — every existing behavior is unchanged. */

package/dist/mono.js

@@ -60,6 +60,7 @@ import { inSpans } from './dead.js';
 import { shakeBody } from './transform.js';
 import { readCallSite, deadSpansForPlans, isFoldBlockedName, } from './analyze.js';
 import { parseSvelte, walk } from './parse.js';
+import { isFoldableValue } from './ir.js';
 export const DEFAULT_MONO_OPTIONS = {
     enabled: false,
     maxVariants: 8,
@@ -418,6 +419,8 @@ function specializableShape(node, child, plan) {
         // override — exactly the analysis's "safely explicit" condition.
         if (explicit.dynamic || !explicit.afterLastSpread)
             continue;
+        if (!isFoldableValue(explicit.value))
+            continue; // no safe source form — exactly as constant fold
         shape.set(name, explicit.value);
     }
     return shape;

package/dist/parse.d.ts

@@ -75,6 +75,13 @@ export interface AnyNode {
     kind?: string | undefined;
     /** ObjectExpression `Property` shorthand-method flag (`{ m() {} }`). */
     method?: boolean | undefined;
+    /** ESTree `Literal` discriminators, present only on a RegExp (`/x/g`) or
+     * BigInt (`1n`) literal — neither of which carries a foldable `value`. */
+    regex?: {
+        pattern: string;
+        flags: string;
+    } | undefined;
+    bigint?: string | undefined;
     value?: unknown;
 }
 export interface Root extends AnyNode {

package/dist/transform.js

@@ -1014,8 +1014,29 @@ function setDefault(map, key) {
 function isSpace(ch) {
     return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
 }
+/** Source text for a folded value, faithful for every member of {@link Literal}
+ * (the union {@link evaluate} admits).  Always an expression, so it drops into
+ * both substitution positions unchanged. */
 function literalSource(value) {
     if (value === undefined)
         return 'undefined';
+    if (typeof value === 'number')
+        return numberSource(value);
+    return JSON.stringify(value);
+}
+/**
+ * `JSON.stringify` flattens `Infinity`/`-Infinity`/`NaN` to `null`, so those get
+ * an explicit form.  Written as arithmetic rather than the `Infinity`/`NaN`
+ * globals because the substituted text lands in the CALLEE's scope, where a
+ * local of either name would silently capture it; `(0/0)` cannot be shadowed.
+ * (`-0`, the fourth lossy case, never reaches here — see `isFoldableValue`.)
+ */
+function numberSource(value) {
+    if (Number.isNaN(value))
+        return '(0/0)';
+    if (value === Infinity)
+        return '(1/0)';
+    if (value === -Infinity)
+        return '(-1/0)';
     return JSON.stringify(value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-shaker",
-  "version": "0.15.2",
+  "version": "0.15.3",
   "description": "Tree shaking for Svelte components",
   "keywords": [
     "dead-code-elimination",