miniread 1.10.0 → 1.11.0

package/dist/scripts/evaluate/create-output-slug.d.ts

@@ -0,0 +1,7 @@
+type CreateOutputSlugOptions = {
+    transforms: string[];
+    recommendedTransforms: readonly string[];
+    allTransformIds: readonly string[];
+};
+export declare const createOutputSlug: (options: CreateOutputSlugOptions) => string;
+export {};

package/dist/scripts/evaluate/create-output-slug.js

@@ -0,0 +1,38 @@
+import crypto from "node:crypto";
+import { sanitizeFileComponent } from "./sanitize.js";
+const isSameOrderedList = (a, b) => {
+    if (a.length !== b.length)
+        return false;
+    for (const [index, value] of a.entries()) {
+        const other = b[index];
+        if (other === undefined)
+            return false;
+        if (value !== other)
+            return false;
+    }
+    return true;
+};
+const createRawTransformSlug = (options) => {
+    const { transforms, recommendedTransforms, allTransformIds } = options;
+    if (transforms.length === 0)
+        return "none";
+    if (isSameOrderedList(transforms, recommendedTransforms))
+        return "recommended";
+    if (isSameOrderedList(transforms, allTransformIds))
+        return "all";
+    return transforms.join("-");
+};
+export const createOutputSlug = (options) => {
+    const sanitized = sanitizeFileComponent(createRawTransformSlug(options));
+    const maxLength = 120;
+    if (sanitized.length <= maxLength)
+        return sanitized;
+    const hash = crypto
+        .createHash("sha256")
+        .update(sanitized)
+        .digest("hex")
+        .slice(0, 10);
+    const prefixLength = maxLength - hash.length - 1;
+    const prefix = sanitized.slice(0, Math.max(0, prefixLength));
+    return `${prefix}-${hash}`;
+};

package/dist/scripts/evaluate/diff-utilities.d.ts

@@ -5,7 +5,6 @@ export type DiffStats = {
     removedLines: number;
     changedHunks: number;
 };
-export declare const createTransformSlug: (transforms: string[]) => string;
 type ComputeDirectoryDiffOptions = {
     diffPath: string;
     directoryA: string;

package/dist/scripts/evaluate/diff-utilities.js

@@ -4,9 +4,6 @@ import fs from "node:fs";
 import * as fsPromises from "node:fs/promises";
 import path from "node:path";
 import readline from "node:readline";
-export const createTransformSlug = (transforms) => {
-    return transforms.length > 0 ? transforms.join("-") : "none";
-};
 const isErrnoException = (error) => {
     return error instanceof Error;
 };

package/dist/scripts/evaluate/parse-evaluate-cli-options.js

@@ -1,8 +1,7 @@
 import path from "node:path";
 import { transformPresets } from "../../transforms/transform-presets.js";
 import { allTransformIds } from "../../transforms/transform-registry.js";
-import { createTransformSlug } from "./diff-utilities.js";
-import { sanitizeFileComponent } from "./sanitize.js";
+import { createOutputSlug } from "./create-output-slug.js";
 const parseTransformList = (value) => {
     if (!value || value === "none")
         return [];
@@ -66,8 +65,16 @@ export const parseEvaluateCliOptions = (options) => {
     const verbose = rawOptions.verbose ?? false;
     const overwrite = rawOptions.overwrite ?? false;
     const formatCode = rawOptions.formatCode;
-    const baselineSlug = sanitizeFileComponent(createTransformSlug(baselineTransforms));
-    const testSlug = sanitizeFileComponent(createTransformSlug(testTransforms));
+    const baselineSlug = createOutputSlug({
+        transforms: baselineTransforms,
+        recommendedTransforms: transformPresets.recommended,
+        allTransformIds,
+    });
+    const testSlug = createOutputSlug({
+        transforms: testTransforms,
+        recommendedTransforms: transformPresets.recommended,
+        allTransformIds,
+    });
     const sourcesDirectory = path.resolve(cwd, rawOptions.sources);
     const evaluationDirectory = path.resolve(cwd, rawOptions.evaluationDir);
     const manifestPath = path.resolve(cwd, rawOptions.manifestFile);

package/dist/transforms/rename-this-aliases/rename-this-aliases-transform.d.ts

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

package/dist/transforms/rename-this-aliases/rename-this-aliases-transform.js

@@ -0,0 +1,121 @@
+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 = "thisRef";
+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 renameThisAliasesTransform = {
+    id: "rename-this-aliases",
+    description: "Renames `var x = this` aliases to $thisRef (stable when unique) or thisRef/thisRef2/...",
+    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, init } = path.node;
+                    if (id.type !== "Identifier")
+                        return;
+                    if (init?.type !== "ThisExpression")
+                        return;
+                    const currentName = id.name;
+                    if (isStableRenamed(currentName))
+                        return;
+                    const binding = path.scope.getBinding(currentName);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    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/dist/transforms/transform-registry.js

@@ -10,6 +10,7 @@ import { renameLoopIndexVariablesV2Transform } from "./rename-loop-index-variabl
 import { renameLoopIndexVariablesV3Transform } from "./rename-loop-index-variables-v3/rename-loop-index-variables-v3-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";
 import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-ids-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";
@@ -27,6 +28,7 @@ export const transformRegistry = {
     [renameLoopIndexVariablesV3Transform.id]: renameLoopIndexVariablesV3Transform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
+    [renameThisAliasesTransform.id]: renameThisAliasesTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,

package/package.json

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

package/transform-manifest.json

@@ -81,6 +81,16 @@
       "evaluatedAt": "2026-01-22T12:49:10.952Z",
       "notes": "Auto-added by evaluation script. Measured with baseline none: 0.09%."
     },
+    {
+      "id": "rename-this-aliases",
+      "description": "Renames `var x = this` aliases to $thisRef (stable when unique) or thisRef/thisRef2/...",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0.00003774938185385768,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T17:57:26.908Z",
+      "notes": "Measured with baseline none: 0.00%. Improves readability by stabilizing `this` aliases used for closures."
+    },
     {
       "id": "expand-sequence-expressions-v4",
       "description": "Expands comma operator sequences in returns, throws, statements (including control-flow bodies), and variable initializers",
@@ -164,8 +174,8 @@
   ],
   "presetStats": {
     "recommended": {
-      "diffReductionImpact": 0.0027273928389422997,
-      "notes": "Measured with baseline none: 0.27%."
+      "diffReductionImpact": 0.003690002076215948,
+      "notes": "Measured with baseline none: 0.37%."
     }
   }
 }