miniread 1.19.0 → 1.21.0

package/README.md

@@ -55,6 +55,7 @@ Use `miniread` when you need readable JavaScript/TypeScript from minified input
 
 ```bash
 pnpm install
+pnpm run download-sources  # Downloads Claude Code versions for evaluation
 pnpm run build
 node bin/miniread --help
 ```

package/dist/transforms/_generated/manifest.js

@@ -129,6 +129,10 @@ const manifestData = {
         evaluatedAt: "2026-01-23T10:29:23.279Z",
         notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
     },
+    "rename-typeof-variables": {
+        diffReductionImpact: 0,
+        recommended: true,
+    },
     "rename-use-reference-guards": {
         diffReductionImpact: 0,
         recommended: false,

package/dist/transforms/_generated/registry.js

@@ -21,6 +21,7 @@ import { renamePromiseExecutorParametersTransform } from "../rename-promise-exec
 import { renameReplaceChildParametersTransform } from "../rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameThisAliasesTransform } from "../rename-this-aliases/rename-this-aliases-transform.js";
 import { renameTimeoutIdsTransform } from "../rename-timeout-ids/rename-timeout-ids-transform.js";
+import { renameTypeofVariablesTransform } from "../rename-typeof-variables/rename-typeof-variables-transform.js";
 import { renameUseReferenceGuardsTransform } from "../rename-use-reference-guards/rename-use-reference-guards-transform.js";
 import { renameUseReferenceGuardsV2Transform } from "../rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js";
 import { simplifyBooleanNegationsTransform } from "../simplify-boolean-negations/simplify-boolean-negations-transform.js";
@@ -47,6 +48,7 @@ export const transformRegistry = {
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
+    [renameTypeofVariablesTransform.id]: renameTypeofVariablesTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffReductionImpact": 0.003690002076215948,
-        "notes": "Measured with baseline none: 0.37%."
+        "diffReductionImpact": 0.001470172462538888,
+        "notes": "Measured with baseline none: 0.15%."
     }
 }

package/dist/transforms/rename-typeof-variables/manifest.json

@@ -0,0 +1,4 @@
+{
+    "diffReductionImpact": 0,
+    "recommended": true
+}

package/dist/transforms/rename-typeof-variables/rename-typeof-variables-transform.d.ts

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

package/dist/transforms/rename-typeof-variables/rename-typeof-variables-transform.js

@@ -0,0 +1,132 @@
+import { createRequire } from "node:module";
+import { isArrayPattern, isAssignmentPattern, isClassDeclaration, isExportNamedDeclaration, isExportSpecifier, isFunctionDeclaration, isIdentifier, isObjectPattern, isObjectProperty, isRestElement, isVariableDeclaration, } from "@babel/types";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess, } from "../../core/types.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const BASE_NAME = "type";
+const addBindingNamesFromNode = (node, out) => {
+    const babelNode = node;
+    if (!babelNode)
+        return;
+    if (babelNode.type === "VoidPattern")
+        return;
+    if (isIdentifier(babelNode)) {
+        out.add(babelNode.name);
+        return;
+    }
+    if (isObjectPattern(babelNode)) {
+        for (const property of babelNode.properties) {
+            if (isRestElement(property)) {
+                addBindingNamesFromNode(property.argument, out);
+                continue;
+            }
+            if (!isObjectProperty(property))
+                continue;
+            addBindingNamesFromNode(property.value, out);
+        }
+        return;
+    }
+    if (isArrayPattern(babelNode)) {
+        for (const element of babelNode.elements) {
+            addBindingNamesFromNode(element, out);
+        }
+        return;
+    }
+    if (isRestElement(babelNode)) {
+        addBindingNamesFromNode(babelNode.argument, out);
+        return;
+    }
+    if (isAssignmentPattern(babelNode)) {
+        addBindingNamesFromNode(babelNode.left, out);
+    }
+};
+const collectExportedNames = (program) => {
+    const exportedNames = new Set();
+    for (const statement of program.body) {
+        if (!isExportNamedDeclaration(statement))
+            continue;
+        const declaration = statement.declaration;
+        if (declaration) {
+            if (isVariableDeclaration(declaration)) {
+                for (const declarator of declaration.declarations) {
+                    addBindingNamesFromNode(declarator.id, exportedNames);
+                }
+            }
+            else if (isFunctionDeclaration(declaration) ||
+                isClassDeclaration(declaration)) {
+                const id = declaration.id;
+                if (!id)
+                    continue;
+                exportedNames.add(id.name);
+            }
+        }
+        for (const specifier of statement.specifiers) {
+            if (!isExportSpecifier(specifier))
+                continue;
+            const local = specifier.local;
+            if (!isIdentifier(local))
+                continue;
+            exportedNames.add(local.name);
+        }
+    }
+    return exportedNames;
+};
+export const renameTypeofVariablesTransform = {
+    id: "rename-typeof-variables",
+    description: "Renames variables assigned from typeof expressions to $type (stable when unique) or type/type2/...",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            const exportedNames = collectExportedNames(fileInfo.ast.program);
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    const init = path.node.init;
+                    if (!init)
+                        return;
+                    if (init.type !== "UnaryExpression")
+                        return;
+                    if (init.operator !== "typeof")
+                        return;
+                    const currentName = id.name;
+                    // Skip already-stable names
+                    if (isStableRenamed(currentName))
+                        return;
+                    // Skip non-minified names (more than 1 character)
+                    if (currentName.length > 1)
+                        return;
+                    const binding = path.scope.getBinding(currentName);
+                    if (!binding)
+                        return;
+                    // Skip reassigned variables (name would be misleading)
+                    if (!binding.constant)
+                        return;
+                    // Skip exported names at program scope
+                    if (binding.scope.block.type === "Program" &&
+                        exportedNames.has(currentName)) {
+                        return;
+                    }
+                    group.add({
+                        scope: binding.scope,
+                        currentName,
+                        baseName: BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};

package/package.json

@@ -2,7 +2,7 @@
   "name": "miniread",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.19.0",
+  "version": "1.21.0",
   "description": "Transform minified JavaScript/TypeScript into a more readable form using deterministic AST-based transforms.",
   "repository": {
     "type": "git",
@@ -35,6 +35,7 @@
   ],
   "scripts": {
     "prepare": "git config core.hooksPath .githooks",
+    "download-sources": "node --experimental-strip-types scripts/download-sources.ts",
     "prepublishOnly": "pnpm run rebuild",
     "build": "node --experimental-strip-types scripts/generate-registry.ts && tsc -p tsconfig.app.json",
     "check": "pnpm -s run rebuild && node bin/miniread-evaluate -- --check",