miniread 1.15.0 → 1.17.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-charcode-variables/rename-charcode-variables-transform.d.ts

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

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

@@ -0,0 +1,67 @@
+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;
+const BASE_NAME = "charCode";
+/**
+ * Detects if the init is a call to .charCodeAt()
+ * e.g., `var a = str.charCodeAt(0)`
+ */
+const isCharCodeAtCall = (path) => {
+    const init = path.node.init;
+    if (init?.type !== "CallExpression")
+        return false;
+    const callee = init.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    const property = callee.property;
+    if (property.type !== "Identifier")
+        return false;
+    if (property.name !== "charCodeAt")
+        return false;
+    // If charCodeAt is accessed via computed property, skip
+    if (callee.computed)
+        return false;
+    return true;
+};
+export const renameCharcodeVariablesTransform = {
+    id: "rename-charcode-variables",
+    description: "Renames variables assigned from .charCodeAt() to $charCode or charCode/charCode2/...",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    // Skip already-stable names
+                    if (isStableRenamed(id.name))
+                        return;
+                    if (!isCharCodeAtCall(path))
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    // Skip if the variable is reassigned
+                    if (!binding.constant)
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName: BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-charcode-variables-v2/rename-charcode-variables-v2-transform.d.ts

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

package/dist/transforms/rename-charcode-variables-v2/rename-charcode-variables-v2-transform.js

@@ -0,0 +1,135 @@
+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;
+/**
+ * Capitalizes the first letter of a string.
+ */
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+const MAX_RECURSION_DEPTH = 5;
+/**
+ * Converts a charCodeAt argument expression to a suffix for the variable name.
+ * Returns undefined if the expression is too complex to represent.
+ *
+ * Examples:
+ * - `0` → "0"
+ * - `index` → "Index"
+ * - `index + 1` → "IndexPlus1"
+ * - `i` → "I"
+ * - `pos` → "Pos"
+ */
+const getArgumentSuffix = (expression, depth = 0) => {
+    // Prevent stack overflow from deeply nested expressions
+    if (depth > MAX_RECURSION_DEPTH)
+        return undefined;
+    // Numeric literal: charCodeAt(0) → "0"
+    if (expression.type === "NumericLiteral") {
+        if (Number.isInteger(expression.value) && expression.value >= 0) {
+            return String(expression.value);
+        }
+        return undefined;
+    }
+    // Identifier: charCodeAt(index) → "Index"
+    if (expression.type === "Identifier") {
+        return capitalize(expression.name);
+    }
+    // Binary expression with +: charCodeAt(index + 1) → "IndexPlus1"
+    if (expression.type === "BinaryExpression") {
+        // Skip if left is a PrivateName (can happen in class fields)
+        if (expression.left.type === "PrivateName")
+            return undefined;
+        if (expression.operator === "+") {
+            const leftSuffix = getArgumentSuffix(expression.left, depth + 1);
+            const rightSuffix = getArgumentSuffix(expression.right, depth + 1);
+            if (leftSuffix !== undefined && rightSuffix !== undefined) {
+                return `${leftSuffix}Plus${rightSuffix}`;
+            }
+        }
+        if (expression.operator === "-") {
+            const leftSuffix = getArgumentSuffix(expression.left, depth + 1);
+            const rightSuffix = getArgumentSuffix(expression.right, depth + 1);
+            if (leftSuffix !== undefined && rightSuffix !== undefined) {
+                return `${leftSuffix}Minus${rightSuffix}`;
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * Detects if the init is a call to .charCodeAt() and extracts the argument.
+ * Returns the argument expression if valid, undefined otherwise.
+ */
+const getCharCodeAtArgument = (path) => {
+    const init = path.node.init;
+    if (init?.type !== "CallExpression")
+        return undefined;
+    const callee = init.callee;
+    if (callee.type !== "MemberExpression")
+        return undefined;
+    const property = callee.property;
+    if (property.type !== "Identifier")
+        return undefined;
+    if (property.name !== "charCodeAt")
+        return undefined;
+    // If charCodeAt is accessed via computed property, skip
+    if (callee.computed)
+        return undefined;
+    // Must have exactly one argument
+    if (init.arguments.length !== 1)
+        return undefined;
+    const firstArgument = init.arguments[0];
+    if (!firstArgument)
+        return undefined;
+    if (firstArgument.type === "SpreadElement")
+        return undefined;
+    if (firstArgument.type === "ArgumentPlaceholder")
+        return undefined;
+    return firstArgument;
+};
+export const renameCharcodeVariablesV2Transform = {
+    id: "rename-charcode-variables-v2",
+    description: "Renames variables assigned from .charCodeAt(arg) to $charCodeAt{Arg} based on the argument",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    // Skip already-stable names
+                    if (isStableRenamed(id.name))
+                        return;
+                    const argument = getCharCodeAtArgument(path);
+                    if (argument === undefined)
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    // Skip if the variable is reassigned
+                    if (!binding.constant)
+                        return;
+                    // Try to derive a suffix from the argument
+                    const suffix = getArgumentSuffix(argument);
+                    if (suffix === undefined)
+                        return;
+                    const baseName = `charCodeAt${suffix}`;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/transform-registry.js

@@ -3,13 +3,18 @@ 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 { renameCharCodeAtTransform } from "./rename-char-code-at/rename-char-code-at-transform.js";
+import { renameCharcodeVariablesTransform } from "./rename-charcode-variables/rename-charcode-variables-transform.js";
+import { renameCharcodeVariablesV2Transform } from "./rename-charcode-variables-v2/rename-charcode-variables-v2-transform.js";
 import { renameComparisonFlagsTransform } from "./rename-comparison-flags/rename-comparison-flags-transform.js";
 import { renameDestructuredAliasesTransform } from "./rename-destructured-aliases/rename-destructured-aliases-transform.js";
 import { renameEventParametersTransform } from "./rename-event-parameters/rename-event-parameters-transform.js";
 import { renameLoopIndexVariablesTransform } from "./rename-loop-index-variables/rename-loop-index-variables-transform.js";
 import { renameLoopIndexVariablesV2Transform } from "./rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.js";
 import { renameLoopIndexVariablesV3Transform } from "./rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.js";
+import { renameParametersToMatchPropertiesTransform } from "./rename-parameters-to-match-properties/rename-parameters-to-match-properties-transform.js";
 import { renamePromiseExecutorParametersTransform } from "./rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
 import { renameReplaceChildParametersTransform } from "./rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameThisAliasesTransform } from "./rename-this-aliases/rename-this-aliases-transform.js";
@@ -17,22 +22,24 @@ 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,
+    [renameCharCodeAtTransform.id]: renameCharCodeAtTransform,
+    [renameCharcodeVariablesTransform.id]: renameCharcodeVariablesTransform,
+    [renameCharcodeVariablesV2Transform.id]: renameCharcodeVariablesV2Transform,
     [renameComparisonFlagsTransform.id]: renameComparisonFlagsTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameEventParametersTransform.id]: renameEventParametersTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,
     [renameLoopIndexVariablesV2Transform.id]: renameLoopIndexVariablesV2Transform,
     [renameLoopIndexVariablesV3Transform.id]: renameLoopIndexVariablesV3Transform,
+    [renameParametersToMatchPropertiesTransform.id]: renameParametersToMatchPropertiesTransform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
@@ -40,6 +47,5 @@ export const transformRegistry = {
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
-    [renameParametersToMatchPropertiesTransform.id]: renameParametersToMatchPropertiesTransform,
 };
 export const allTransformIds = Object.keys(transformRegistry);

package/package.json

@@ -2,7 +2,7 @@
   "name": "miniread",
   "author": "Łukasz Jerciński",
   "license": "MIT",
-  "version": "1.15.0",
+  "version": "1.17.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,16 @@
       "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))",
@@ -209,6 +219,27 @@
       "diffReductionImpact": 0.00003774938185385768,
       "recommended": true,
       "notes": "Added manually based on high-confidence heuristic."
+    },
+    {
+      "id": "rename-charcode-variables",
+      "description": "Renames variables assigned from .charCodeAt() to $charCode or charCode/charCode2/...",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": false,
+      "evaluatedAt": "2026-01-23T17:59:00.000Z",
+      "notes": "Superseded by rename-charcode-variables-v2.",
+      "supersededBy": "rename-charcode-variables-v2"
+    },
+    {
+      "id": "rename-charcode-variables-v2",
+      "description": "Renames variables assigned from .charCodeAt(arg) to $charCodeAt{Arg} based on the argument",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T18:10:00.000Z",
+      "notes": "Derives names from charCodeAt argument for better stability (e.g., $charCodeAtIndex, $charCodeAtIndexPlus1)."
     }
   ],
   "presetStats": {