miniread 1.2.0 → 1.3.0

package/dist/transforms/expand-special-number-literals/expand-special-number-literals-transform.d.ts

@@ -0,0 +1,2 @@
+import type { Transform } from "../../core/types.js";
+export declare const expandSpecialNumberLiteralsTransform: Transform;

package/dist/transforms/expand-special-number-literals/expand-special-number-literals-transform.js

@@ -0,0 +1,139 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const t = require("@babel/types");
+const directEvalCache = new WeakMap();
+const containsDirectEval = (container) => {
+    const cached = directEvalCache.get(container.node);
+    if (cached !== undefined)
+        return cached;
+    let found = false;
+    container.traverse({
+        CallExpression(callPath) {
+            if (callPath.node.callee.type !== "Identifier")
+                return;
+            if (callPath.node.callee.name !== "eval")
+                return;
+            // We only care about direct eval in sloppy mode because it can introduce `var`
+            // bindings into the current function scope (which could shadow `Infinity`/`NaN`
+            // and change the meaning of an identifier replacement).
+            //
+            // Note: Even if `eval` is lexically shadowed, we can't reliably prove statically
+            // that it's not bound to the built-in eval at runtime (e.g. `const eval =
+            // globalThis.eval`). Be conservative and treat any `eval(...)` call as direct.
+            found = true;
+            callPath.stop();
+        },
+        Function(functionPath) {
+            if (functionPath.node === container.node)
+                return;
+            functionPath.skip();
+        },
+    });
+    directEvalCache.set(container.node, found);
+    return found;
+};
+const isWithinWithStatement = (path) => {
+    return Boolean(path.findParent((p) => p.isWithStatement()));
+};
+const isWithinSloppyDirectEvalScope = (path) => {
+    for (let functionPath = path.getFunctionParent(); functionPath; functionPath = functionPath.getFunctionParent()) {
+        if (functionPath.isInStrictMode())
+            continue;
+        if (containsDirectEval(functionPath))
+            return true;
+    }
+    const programPath = path.scope.getProgramParent().path;
+    if (!programPath.isInStrictMode() && containsDirectEval(programPath)) {
+        return true;
+    }
+    return false;
+};
+const isDivisionByZero = (value) => {
+    return value === 0 || Object.is(value, -0);
+};
+export const expandSpecialNumberLiteralsTransform = {
+    id: "expand-special-number-literals",
+    description: "Expands 1/0 to Infinity, -1/0 (and 1/-0) to -Infinity, and 0/0 to NaN (when not shadowed)",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                BinaryExpression(path) {
+                    nodesVisited++;
+                    const { operator, left } = path.node;
+                    if (operator !== "/")
+                        return;
+                    // Babel types allow `PrivateName` as a BinaryExpression operand for `#x in obj`
+                    // brand checks (operator `in`). This guard is just to satisfy the type system.
+                    if (left.type === "PrivateName")
+                        return;
+                    const leftPath = path.get("left");
+                    const rightPath = path.get("right");
+                    // Avoid dropping side effects: `evaluate()` can be confident for expressions that
+                    // are not pure (e.g. `(foo(), 1) / 0`). Only rewrite when both sides are pure.
+                    if (!leftPath.isPure() || !rightPath.isPure())
+                        return;
+                    const leftEvaluation = leftPath.evaluate();
+                    if (!leftEvaluation.confident)
+                        return;
+                    if (typeof leftEvaluation.value !== "number")
+                        return;
+                    const leftValue = leftEvaluation.value;
+                    const rightEvaluation = rightPath.evaluate();
+                    if (!rightEvaluation.confident)
+                        return;
+                    if (typeof rightEvaluation.value !== "number")
+                        return;
+                    const rightValue = rightEvaluation.value;
+                    if (!isDivisionByZero(rightValue))
+                        return;
+                    const result = leftValue / rightValue;
+                    if (Number.isNaN(result)) {
+                        // `0/0` is unaffected by dynamic scope, but `NaN` can be shadowed via `with` and
+                        // sloppy direct `eval()` in this scope or any enclosing scope.
+                        if (isWithinWithStatement(path))
+                            return;
+                        if (isWithinSloppyDirectEvalScope(path))
+                            return;
+                        if (path.scope.hasBinding("NaN", true))
+                            return;
+                        path.replaceWith(t.identifier("NaN"));
+                        transformationsApplied++;
+                        return;
+                    }
+                    if (result === Infinity) {
+                        // `1/0` is unaffected by dynamic scope, but `Infinity` can be shadowed via `with` and
+                        // sloppy direct `eval()` in this scope or any enclosing scope.
+                        if (isWithinWithStatement(path))
+                            return;
+                        if (isWithinSloppyDirectEvalScope(path))
+                            return;
+                        if (path.scope.hasBinding("Infinity", true))
+                            return;
+                        path.replaceWith(t.identifier("Infinity"));
+                        transformationsApplied++;
+                        return;
+                    }
+                    if (result === -Infinity) {
+                        if (isWithinWithStatement(path))
+                            return;
+                        if (isWithinSloppyDirectEvalScope(path))
+                            return;
+                        if (path.scope.hasBinding("Infinity", true))
+                            return;
+                        path.replaceWith(t.unaryExpression("-", t.identifier("Infinity")));
+                        transformationsApplied++;
+                        return;
+                    }
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/transform-registry.js

@@ -2,6 +2,7 @@ import { expandBooleanLiteralsTransform } from "./expand-boolean-literals/expand
 import { expandReturnSequenceTransform } from "./expand-return-sequence/expand-return-sequence-transform.js";
 import { expandSequenceExpressionsTransform } from "./expand-sequence-expressions/expand-sequence-expressions-transform.js";
 import { expandSequenceExpressionsV2Transform } from "./expand-sequence-expressions-v2/expand-sequence-expressions-v2-transform.js";
+import { expandSpecialNumberLiteralsTransform } from "./expand-special-number-literals/expand-special-number-literals-transform.js";
 import { expandSequenceExpressionsV3Transform } from "./expand-sequence-expressions-v3/expand-sequence-expressions-v3-transform.js";
 import { expandThrowSequenceTransform } from "./expand-throw-sequence/expand-throw-sequence-transform.js";
 import { expandUndefinedLiteralsTransform } from "./expand-undefined-literals/expand-undefined-literals-transform.js";
@@ -18,6 +19,7 @@ export const transformRegistry = {
     [expandSequenceExpressionsTransform.id]: expandSequenceExpressionsTransform,
     [expandSequenceExpressionsV2Transform.id]: expandSequenceExpressionsV2Transform,
     [expandSequenceExpressionsV3Transform.id]: expandSequenceExpressionsV3Transform,
+    [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
     [expandThrowSequenceTransform.id]: expandThrowSequenceTransform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,

package/package.json

@@ -2,7 +2,7 @@
   "name": "miniread",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",

package/transform-manifest.json

@@ -139,6 +139,16 @@
       "recommended": true,
       "evaluatedAt": "2026-01-22T21:39:53.578Z",
       "notes": "Auto-added by evaluation script."
+    },
+    {
+      "id": "expand-special-number-literals",
+      "description": "Expands 1/0 to Infinity, -1/0 (and 1/-0) to -Infinity, and 0/0 to NaN (when not shadowed)",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T08:17:45.579Z",
+      "notes": "Auto-added by evaluation script."
     }
   ],
   "presetStats": {