miniread 1.14.0 → 1.16.0

package/dist/transforms/remove-redundant-else/remove-redundant-else-transform.d.ts

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

package/dist/transforms/remove-redundant-else/remove-redundant-else-transform.js

@@ -0,0 +1,61 @@
+import { createRequire } from "node:module";
+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;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+export const removeRedundantElseTransform = {
+    id: "remove-redundant-else",
+    description: "Removes redundant else blocks after return/throw/break/continue",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            traverse(fileInfo.ast, {
+                IfStatement(path) {
+                    nodesVisited++;
+                    const { consequent, alternate } = path.node;
+                    if (!alternate)
+                        return;
+                    let interrupts = false;
+                    if (isInterrupting(consequent)) {
+                        interrupts = true;
+                    }
+                    else if (consequent.type === "BlockStatement" &&
+                        consequent.body.length > 0) {
+                        const last = consequent.body.at(-1);
+                        if (isInterrupting(last)) {
+                            interrupts = true;
+                        }
+                    }
+                    if (interrupts) {
+                        // Remove alternate
+                        // eslint-disable-next-line unicorn/no-null
+                        path.node.alternate = null;
+                        // Insert alternate content after
+                        path.insertAfter(alternate);
+                        transformationsApplied++;
+                    }
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};
+function isInterrupting(node) {
+    return (
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+    (t.isReturnStatement(node) ||
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+        t.isThrowStatement(node) ||
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+        t.isBreakStatement(node) ||
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+        t.isContinueStatement(node)));
+}

package/dist/transforms/rename-char-code-at/rename-char-code-at-transform.d.ts

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

package/dist/transforms/rename-char-code-at/rename-char-code-at-transform.js

@@ -0,0 +1,70 @@
+import { createRequire } from "node:module";
+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;
+export const renameCharCodeAtTransform = {
+    id: "rename-char-code-at",
+    description: "Renames variables used in charCodeAt calls (str.charCodeAt(index))",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            const processedBindings = new Set();
+            traverse(fileInfo.ast, {
+                CallExpression(path) {
+                    nodesVisited++;
+                    const node = path.node;
+                    if (node.callee.type !== "MemberExpression")
+                        return;
+                    const callee = node.callee;
+                    if (callee.computed)
+                        return;
+                    if (callee.property.type !== "Identifier")
+                        return;
+                    if (callee.property.name !== "charCodeAt")
+                        return;
+                    // Rename object (str)
+                    if (callee.object.type === "Identifier") {
+                        const currentName = callee.object.name;
+                        const binding = path.scope.getBinding(currentName);
+                        if (binding &&
+                            !processedBindings.has(binding) &&
+                            !isStableRenamed(currentName)) {
+                            processedBindings.add(binding);
+                            group.add({
+                                scope: binding.scope,
+                                currentName,
+                                baseName: "str",
+                            });
+                        }
+                    }
+                    // Rename first argument (index)
+                    if (node.arguments.length > 0) {
+                        const firstArgument = node.arguments[0];
+                        if (firstArgument?.type === "Identifier") {
+                            const currentName = firstArgument.name;
+                            const binding = path.scope.getBinding(currentName);
+                            if (binding &&
+                                !processedBindings.has(binding) &&
+                                !isStableRenamed(currentName)) {
+                                processedBindings.add(binding);
+                                group.add({
+                                    scope: binding.scope,
+                                    currentName,
+                                    baseName: "index",
+                                });
+                            }
+                        }
+                    }
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/transform-registry.js

@@ -3,6 +3,7 @@ import { expandSpecialNumberLiteralsTransform } from "./expand-special-number-li
 import { expandSequenceExpressionsV4Transform } from "./expand-sequence-expressions-v4/expand-sequence-expressions-v4-transform.js";
 import { expandSequenceExpressionsV5Transform } from "./expand-sequence-expressions-v5/expand-sequence-expressions-v5-transform.js";
 import { expandUndefinedLiteralsTransform } from "./expand-undefined-literals/expand-undefined-literals-transform.js";
+import { removeRedundantElseTransform } from "./remove-redundant-else/remove-redundant-else-transform.js";
 import { renameCatchParametersTransform } from "./rename-catch-parameters/rename-catch-parameters-transform.js";
 import { renameComparisonFlagsTransform } from "./rename-comparison-flags/rename-comparison-flags-transform.js";
 import { renameDestructuredAliasesTransform } from "./rename-destructured-aliases/rename-destructured-aliases-transform.js";
@@ -17,13 +18,16 @@ import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-i
 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 { splitVariableDeclarationsTransform } from "./split-variable-declarations/split-variable-declarations-transform.js";
+import { renameCharCodeAtTransform } from "./rename-char-code-at/rename-char-code-at-transform.js";
 import { renameParametersToMatchPropertiesTransform } from "./rename-parameters-to-match-properties/rename-parameters-to-match-properties-transform.js";
 export const transformRegistry = {
+    [renameCharCodeAtTransform.id]: renameCharCodeAtTransform,
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
     [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
     [expandSequenceExpressionsV4Transform.id]: expandSequenceExpressionsV4Transform,
     [expandSequenceExpressionsV5Transform.id]: expandSequenceExpressionsV5Transform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
+    [removeRedundantElseTransform.id]: removeRedundantElseTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
     [renameComparisonFlagsTransform.id]: renameComparisonFlagsTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,

package/package.json

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

package/transform-manifest.json

@@ -191,6 +191,26 @@
       "evaluatedAt": "2026-01-23T08:17:45.579Z",
       "notes": "Auto-added by evaluation script."
     },
+    {
+      "id": "remove-redundant-else",
+      "description": "Removes redundant else blocks after return/throw/break/continue",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T18:15:00.000Z",
+      "notes": "Added manually; improves readability by reducing nesting."
+    },
+    {
+      "id": "rename-char-code-at",
+      "description": "Renames variables used in charCodeAt calls (str.charCodeAt(index))",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T18:00:00.000Z",
+      "notes": "Measured with baseline none: 0.00%. Renames variables used in charCodeAt to improve readability."
+    },
     {
       "id": "rename-parameters-to-match-properties",
       "description": "Renames parameters that are assigned to object properties of the same name",