miniread 1.4.0 → 1.6.0

package/dist/transforms/expand-sequence-expressions-v4/expand-expression-statement-sequence.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ExpressionStatement } from "@babel/types";
+export declare const tryExpandExpressionStatementSequence: (path: NodePath<ExpressionStatement>) => boolean;

package/dist/transforms/expand-sequence-expressions-v4/expand-expression-statement-sequence.js

@@ -0,0 +1,86 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+const canReplaceWithMultiple = (path) => path.parentPath.isProgram() ||
+    path.parentPath.isBlockStatement() ||
+    path.parentPath.isStaticBlock() ||
+    path.parentPath.isSwitchCase();
+const canWrapInBlock = (path) => {
+    const parentPath = path.parentPath;
+    if (parentPath.isIfStatement() &&
+        (path.key === "consequent" || path.key === "alternate")) {
+        return true;
+    }
+    if ((parentPath.isForStatement() ||
+        parentPath.isForInStatement() ||
+        parentPath.isForOfStatement() ||
+        parentPath.isWhileStatement() ||
+        parentPath.isDoWhileStatement() ||
+        parentPath.isWithStatement() ||
+        parentPath.isLabeledStatement()) &&
+        path.key === "body") {
+        return true;
+    }
+    return false;
+};
+const isDirectiveProloguePosition = (path) => {
+    const parentPath = path.parentPath;
+    if (parentPath.isBlockStatement()) {
+        const grandParent = parentPath.parentPath;
+        if (parentPath.key !== "body")
+            return false;
+        if (!grandParent.isFunction())
+            return false;
+    }
+    else if (!parentPath.isProgram()) {
+        return false;
+    }
+    const siblings = parentPath.get("body");
+    if (!Array.isArray(siblings))
+        return false;
+    const index = siblings.findIndex((sibling) => sibling.node === path.node);
+    if (index === -1)
+        return false;
+    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
+        const sibling = siblings[bodyIndex];
+        if (!sibling)
+            return false;
+        if (!sibling.isExpressionStatement())
+            return false;
+        if (sibling.node.expression.type !== "StringLiteral")
+            return false;
+    }
+    return true;
+};
+export const tryExpandExpressionStatementSequence = (path) => {
+    if (!canReplaceWithMultiple(path) && !canWrapInBlock(path))
+        return false;
+    const expression = path.node.expression;
+    if (expression.type !== "SequenceExpression")
+        return false;
+    if (expression.expressions.length < 2)
+        return false;
+    const firstExpression = expression.expressions[0];
+    if (firstExpression?.type === "StringLiteral" &&
+        canReplaceWithMultiple(path) &&
+        isDirectiveProloguePosition(path)) {
+        return false;
+    }
+    const statements = expression.expressions.map((expr) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        return t.expressionStatement(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        t.cloneNode(expr, true));
+    });
+    if (canReplaceWithMultiple(path)) {
+        path.replaceWithMultiple(statements);
+        return true;
+    }
+    if (canWrapInBlock(path)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        path.replaceWith(t.blockStatement(statements));
+        return true;
+    }
+    return false;
+};

package/dist/transforms/expand-sequence-expressions-v4/expand-return-sequence.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ReturnStatement } from "@babel/types";
+export declare const tryExpandReturnSequence: (path: NodePath<ReturnStatement>) => boolean;

package/dist/transforms/expand-sequence-expressions-v4/expand-return-sequence.js

@@ -0,0 +1,91 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+const canReplaceWithMultiple = (path) => {
+    return path.parentPath.isBlockStatement() || path.parentPath.isSwitchCase();
+};
+const canWrapInBlock = (path) => {
+    const parentPath = path.parentPath;
+    if (parentPath.isIfStatement() &&
+        (path.key === "consequent" || path.key === "alternate")) {
+        return true;
+    }
+    if ((parentPath.isForStatement() ||
+        parentPath.isForInStatement() ||
+        parentPath.isForOfStatement() ||
+        parentPath.isWhileStatement() ||
+        parentPath.isDoWhileStatement() ||
+        parentPath.isWithStatement() ||
+        parentPath.isLabeledStatement()) &&
+        path.key === "body") {
+        return true;
+    }
+    return false;
+};
+const replaceReturnWithStatements = (path, statements) => {
+    if (canReplaceWithMultiple(path)) {
+        path.replaceWithMultiple(statements);
+        return true;
+    }
+    if (canWrapInBlock(path)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        path.replaceWith(t.blockStatement(statements));
+        return true;
+    }
+    return false;
+};
+const isDirectiveProloguePosition = (path) => {
+    if (!path.parentPath.isBlockStatement())
+        return false;
+    if (path.parentPath.key !== "body")
+        return false;
+    if (!path.parentPath.parentPath.isFunction())
+        return false;
+    const siblings = path.parentPath.get("body");
+    if (!Array.isArray(siblings))
+        return false;
+    const index = siblings.findIndex((sibling) => sibling.node === path.node);
+    if (index === -1)
+        return false;
+    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
+        const sibling = siblings[bodyIndex];
+        if (!sibling)
+            return false;
+        if (!sibling.isExpressionStatement())
+            return false;
+        if (sibling.node.expression.type !== "StringLiteral")
+            return false;
+    }
+    return true;
+};
+export const tryExpandReturnSequence = (path) => {
+    if (!canReplaceWithMultiple(path) && !canWrapInBlock(path))
+        return false;
+    const argument = path.node.argument;
+    if (!argument)
+        return false;
+    if (argument.type !== "SequenceExpression")
+        return false;
+    if (argument.expressions.length < 2)
+        return false;
+    const leadingExpressions = argument.expressions.slice(0, -1);
+    const lastExpression = argument.expressions.at(-1);
+    if (!lastExpression)
+        return false;
+    const firstExpression = leadingExpressions[0];
+    if (firstExpression?.type === "StringLiteral" &&
+        isDirectiveProloguePosition(path)) {
+        return false;
+    }
+    const statements = leadingExpressions.map((expression) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        return t.expressionStatement(
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        t.cloneNode(expression, true));
+    });
+    statements.push(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    t.returnStatement(t.cloneNode(lastExpression, true)));
+    return replaceReturnWithStatements(path, statements);
+};

package/dist/transforms/expand-sequence-expressions-v4/expand-sequence-expressions-v4-transform.d.ts

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

package/dist/transforms/expand-sequence-expressions-v4/expand-sequence-expressions-v4-transform.js

@@ -0,0 +1,48 @@
+import { createRequire } from "node:module";
+import { tryExpandExpressionStatementSequence } from "./expand-expression-statement-sequence.js";
+import { tryExpandReturnSequence } from "./expand-return-sequence.js";
+import { tryExpandThrowSequence } from "./expand-throw-sequence.js";
+import { tryExpandVariableDeclarationSequenceInitializers } from "./expand-variable-declaration-sequence.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 expandSequenceExpressionsV4Transform = {
+    id: "expand-sequence-expressions-v4",
+    description: "Expands comma operator sequences in returns, throws, statements (including control-flow bodies), and variable initializers",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                ReturnStatement(path) {
+                    nodesVisited++;
+                    if (!tryExpandReturnSequence(path))
+                        return;
+                    transformationsApplied += 1;
+                },
+                ThrowStatement(path) {
+                    nodesVisited++;
+                    if (!tryExpandThrowSequence(path))
+                        return;
+                    transformationsApplied += 1;
+                },
+                ExpressionStatement(path) {
+                    nodesVisited++;
+                    if (!tryExpandExpressionStatementSequence(path))
+                        return;
+                    transformationsApplied += 1;
+                },
+                VariableDeclaration(path) {
+                    nodesVisited++;
+                    if (!tryExpandVariableDeclarationSequenceInitializers(path))
+                        return;
+                    transformationsApplied += 1;
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/expand-sequence-expressions-v4/expand-throw-sequence.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { ThrowStatement } from "@babel/types";
+export declare const tryExpandThrowSequence: (path: NodePath<ThrowStatement>) => boolean;

package/dist/transforms/expand-sequence-expressions-v4/expand-throw-sequence.js

@@ -0,0 +1,101 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+const canReplaceWithMultiple = (path) => {
+    return (path.parentPath.isProgram() ||
+        path.parentPath.isBlockStatement() ||
+        path.parentPath.isStaticBlock() ||
+        path.parentPath.isSwitchCase());
+};
+const canWrapInBlock = (path) => {
+    const parentPath = path.parentPath;
+    if (parentPath.isIfStatement() &&
+        (path.key === "consequent" || path.key === "alternate")) {
+        return true;
+    }
+    if ((parentPath.isForStatement() ||
+        parentPath.isForInStatement() ||
+        parentPath.isForOfStatement() ||
+        parentPath.isWhileStatement() ||
+        parentPath.isDoWhileStatement() ||
+        parentPath.isWithStatement() ||
+        parentPath.isLabeledStatement()) &&
+        path.key === "body") {
+        return true;
+    }
+    return false;
+};
+const replaceThrowWithStatements = (path, statements) => {
+    if (canReplaceWithMultiple(path)) {
+        path.replaceWithMultiple(statements);
+        return true;
+    }
+    if (canWrapInBlock(path)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        path.replaceWith(t.blockStatement(statements));
+        return true;
+    }
+    return false;
+};
+const isDirectiveProloguePosition = (path) => {
+    const parentPath = path.parentPath;
+    if (parentPath.isBlockStatement()) {
+        const grandParent = parentPath.parentPath;
+        if (parentPath.key !== "body")
+            return false;
+        if (!grandParent.isFunction())
+            return false;
+    }
+    else if (!parentPath.isProgram()) {
+        return false;
+    }
+    const siblings = parentPath.get("body");
+    if (!Array.isArray(siblings))
+        return false;
+    const index = siblings.findIndex((sibling) => sibling.node === path.node);
+    if (index === -1)
+        return false;
+    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
+        const sibling = siblings[bodyIndex];
+        if (!sibling)
+            return false;
+        if (!sibling.isExpressionStatement())
+            return false;
+        if (sibling.node.expression.type !== "StringLiteral")
+            return false;
+    }
+    return true;
+};
+export const tryExpandThrowSequence = (path) => {
+    if (!canReplaceWithMultiple(path) && !canWrapInBlock(path))
+        return false;
+    const argument = path.node.argument;
+    if (argument.type !== "SequenceExpression")
+        return false;
+    if (argument.expressions.length < 2)
+        return false;
+    const leadingExpressions = argument.expressions.slice(0, -1);
+    const lastExpression = argument.expressions.at(-1);
+    if (!lastExpression)
+        return false;
+    const firstExpression = leadingExpressions[0];
+    const shouldWrapFirstStringLiteral = firstExpression?.type === "StringLiteral" &&
+        isDirectiveProloguePosition(path);
+    const statements = leadingExpressions.map((expression) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        let clonedExpression = t.cloneNode(expression, true);
+        if (shouldWrapFirstStringLiteral && expression === firstExpression) {
+            // Prevent inserting a directive prologue statement like `"use strict";`.
+            // `("use strict");` is not treated as a directive.
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+            clonedExpression = t.parenthesizedExpression(clonedExpression);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        return t.expressionStatement(clonedExpression);
+    });
+    statements.push(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    t.throwStatement(t.cloneNode(lastExpression, true)));
+    return replaceThrowWithStatements(path, statements);
+};

package/dist/transforms/expand-sequence-expressions-v4/expand-variable-declaration-sequence.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { VariableDeclaration } from "@babel/types";
+export declare const tryExpandVariableDeclarationSequenceInitializers: (path: NodePath<VariableDeclaration>) => boolean;

package/dist/transforms/expand-sequence-expressions-v4/expand-variable-declaration-sequence.js

@@ -0,0 +1,99 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const t = require("@babel/types");
+const createExpressionStatement = (expression) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    return t.expressionStatement(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    t.cloneNode(expression, true));
+};
+const createVariableDeclarationStatement = (kind, declarator) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    return t.variableDeclaration(kind, [declarator]);
+};
+const createVariableDeclarator = (id, init) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    return t.variableDeclarator(
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    t.cloneNode(id, true), init
+        ? // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+            t.cloneNode(init, true)
+        : undefined);
+};
+const isSupportedStatementContainer = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath)
+        return false;
+    return (parentPath.isProgram() ||
+        parentPath.isBlockStatement() ||
+        parentPath.isStaticBlock() ||
+        parentPath.isSwitchCase());
+};
+const isDirectiveProloguePosition = (path) => {
+    const parentPath = path.parentPath;
+    if (!parentPath)
+        return false;
+    if (parentPath.isBlockStatement()) {
+        const grandParent = parentPath.parentPath;
+        if (parentPath.key !== "body")
+            return false;
+        if (!grandParent.isFunction())
+            return false;
+    }
+    else if (!parentPath.isProgram()) {
+        return false;
+    }
+    const siblings = parentPath.get("body");
+    if (!Array.isArray(siblings))
+        return false;
+    const index = siblings.findIndex((sibling) => sibling.node === path.node);
+    if (index === -1)
+        return false;
+    for (let bodyIndex = 0; bodyIndex < index; bodyIndex++) {
+        const sibling = siblings[bodyIndex];
+        if (!sibling)
+            return false;
+        if (!sibling.isExpressionStatement())
+            return false;
+        if (sibling.node.expression.type !== "StringLiteral")
+            return false;
+    }
+    return true;
+};
+export const tryExpandVariableDeclarationSequenceInitializers = (path) => {
+    if (!isSupportedStatementContainer(path))
+        return false;
+    if (isDirectiveProloguePosition(path)) {
+        const wouldInsertStringLiteral = path.node.declarations.some((declarator) => declarator.init?.type === "SequenceExpression" &&
+            declarator.init.expressions[0]?.type === "StringLiteral");
+        if (wouldInsertStringLiteral)
+            return false;
+    }
+    const hasAnySequence = path.node.declarations.some((declarator) => declarator.init?.type === "SequenceExpression" &&
+        declarator.init.expressions.length >= 2);
+    if (!hasAnySequence)
+        return false;
+    const kind = path.node.kind;
+    const statements = [];
+    for (const declarator of path.node.declarations) {
+        const init = declarator.init;
+        if (init?.type !== "SequenceExpression") {
+            statements.push(createVariableDeclarationStatement(kind, declarator));
+            continue;
+        }
+        const leadingExpressions = init.expressions.slice(0, -1);
+        const lastExpression = init.expressions.at(-1);
+        if (!lastExpression) {
+            statements.push(createVariableDeclarationStatement(kind, declarator));
+            continue;
+        }
+        for (const expression of leadingExpressions) {
+            statements.push(createExpressionStatement(expression));
+        }
+        const newDeclarator = createVariableDeclarator(declarator.id, lastExpression);
+        statements.push(createVariableDeclarationStatement(kind, newDeclarator));
+    }
+    path.replaceWithMultiple(statements);
+    return true;
+};

package/dist/transforms/rename-use-reference-guards-v2/get-member-expression-for-reference.d.ts

@@ -0,0 +1,3 @@
+import type { NodePath } from "@babel/traverse";
+import type { Identifier, MemberExpression, OptionalMemberExpression } from "@babel/types";
+export declare const getMemberExpressionForReference: (referencePath: NodePath<Identifier>) => NodePath<MemberExpression | OptionalMemberExpression> | undefined;

package/dist/transforms/rename-use-reference-guards-v2/get-member-expression-for-reference.js

@@ -0,0 +1,10 @@
+export const getMemberExpressionForReference = (referencePath) => {
+    const parentPath = referencePath.parentPath;
+    if (parentPath.isMemberExpression() &&
+        parentPath.node.object === referencePath.node)
+        return parentPath;
+    if (parentPath.isOptionalMemberExpression() &&
+        parentPath.node.object === referencePath.node)
+        return parentPath;
+    return;
+};

package/dist/transforms/rename-use-reference-guards-v2/get-reference-usage.d.ts

@@ -0,0 +1,8 @@
+import type { Binding } from "@babel/traverse";
+type ReferenceUsage = {
+    isSafe: boolean;
+    hasRead: boolean;
+    hasTrueWrite: boolean;
+};
+export declare const getReferenceUsage: (binding: Binding) => ReferenceUsage;
+export {};

package/dist/transforms/rename-use-reference-guards-v2/get-reference-usage.js

@@ -0,0 +1,58 @@
+import { getMemberExpressionForReference } from "./get-member-expression-for-reference.js";
+const getKnownBooleanValue = (expression) => {
+    if (expression.type === "BooleanLiteral")
+        return expression.value;
+    if (expression.type === "UnaryExpression" &&
+        expression.operator === "!" &&
+        expression.argument.type === "NumericLiteral" &&
+        (expression.argument.value === 0 || expression.argument.value === 1)) {
+        return !expression.argument.value;
+    }
+    return;
+};
+export const getReferenceUsage = (binding) => {
+    let hasRead = false;
+    let hasTrueWrite = false;
+    for (const referencePath of binding.referencePaths) {
+        if (!referencePath.isIdentifier())
+            return { isSafe: false, hasRead, hasTrueWrite };
+        const memberPath = getMemberExpressionForReference(referencePath);
+        if (!memberPath)
+            return { isSafe: false, hasRead, hasTrueWrite };
+        const memberNode = memberPath.node;
+        if (memberNode.computed)
+            return { isSafe: false, hasRead, hasTrueWrite };
+        if (memberNode.property.type !== "Identifier" ||
+            memberNode.property.name !== "current") {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        const parentPath = memberPath.parentPath;
+        if (parentPath.isAssignmentExpression() &&
+            parentPath.node.left === memberNode) {
+            if (parentPath.node.operator !== "=")
+                return { isSafe: false, hasRead, hasTrueWrite };
+            const right = parentPath.node.right;
+            const value = getKnownBooleanValue(right);
+            if (value === undefined)
+                return { isSafe: false, hasRead, hasTrueWrite };
+            if (value) {
+                hasTrueWrite = true;
+            }
+            continue;
+        }
+        if (parentPath.isUpdateExpression() &&
+            parentPath.node.argument === memberNode) {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        if (parentPath.isUnaryExpression() &&
+            parentPath.node.operator === "delete" &&
+            parentPath.node.argument === memberNode) {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        if (!memberPath.isReferenced()) {
+            return { isSafe: false, hasRead, hasTrueWrite };
+        }
+        hasRead = true;
+    }
+    return { isSafe: true, hasRead, hasTrueWrite };
+};

package/dist/transforms/rename-use-reference-guards-v2/get-target-name.d.ts

@@ -0,0 +1,2 @@
+import type { Binding, Scope } from "@babel/traverse";
+export declare const getTargetName: (bindingScope: Scope, binding: Binding) => string | undefined;

package/dist/transforms/rename-use-reference-guards-v2/get-target-name.js

@@ -0,0 +1,23 @@
+import { isValidBindingIdentifier } from "./is-valid-binding-identifier.js";
+const BASE_NAME = "hasRunRef";
+// Cap retries to avoid pathological loops while handling large bundles.
+const MAX_CANDIDATES = 1000;
+export const getTargetName = (bindingScope, binding) => {
+    const programScope = bindingScope.getProgramParent();
+    for (let index = 0; index < MAX_CANDIDATES; index++) {
+        const candidate = index === 0 ? BASE_NAME : `${BASE_NAME}${index + 1}`;
+        if (!isValidBindingIdentifier(candidate))
+            continue;
+        // Avoid shadowing bindings in parent scopes.
+        if (bindingScope.hasBinding(candidate))
+            continue;
+        if (Object.hasOwn(programScope.globals, candidate))
+            continue;
+        const wouldBeShadowed = binding.referencePaths.some((referencePath) => referencePath.scope !== bindingScope &&
+            referencePath.scope.hasBinding(candidate));
+        if (wouldBeShadowed)
+            continue;
+        return candidate;
+    }
+    return;
+};

package/dist/transforms/rename-use-reference-guards-v2/is-use-reference-false-initializer.d.ts

@@ -0,0 +1,2 @@
+import type { VariableDeclarator } from "@babel/types";
+export declare const isUseReferenceFalseInitializer: (declarator: VariableDeclarator) => boolean;

package/dist/transforms/rename-use-reference-guards-v2/is-use-reference-false-initializer.js

@@ -0,0 +1,40 @@
+const isKnownFalseValue = (expression) => {
+    if (expression.type === "BooleanLiteral")
+        return !expression.value;
+    if (expression.type === "UnaryExpression" &&
+        expression.operator === "!" &&
+        expression.argument.type === "NumericLiteral" &&
+        expression.argument.value === 1) {
+        return true;
+    }
+    return false;
+};
+export const isUseReferenceFalseInitializer = (declarator) => {
+    const init = declarator.init;
+    if (!init)
+        return false;
+    if (init.type !== "CallExpression")
+        return false;
+    if (init.arguments.length !== 1)
+        return false;
+    const argument = init.arguments[0];
+    if (!argument)
+        return false;
+    if (argument.type === "SpreadElement")
+        return false;
+    if (argument.type === "ArgumentPlaceholder")
+        return false;
+    if (!isKnownFalseValue(argument))
+        return false;
+    const callee = init.callee;
+    if (callee.type === "Identifier") {
+        return callee.name === "useRef";
+    }
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (callee.property.type !== "Identifier")
+        return false;
+    return callee.property.name === "useRef";
+};

package/dist/transforms/rename-use-reference-guards-v2/is-valid-binding-identifier.d.ts

@@ -0,0 +1 @@
+export declare const isValidBindingIdentifier: (name: string) => boolean;

package/dist/transforms/rename-use-reference-guards-v2/is-valid-binding-identifier.js

@@ -0,0 +1,10 @@
+import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
+export const isValidBindingIdentifier = (name) => {
+    if (!isIdentifierName(name))
+        return false;
+    if (isKeyword(name))
+        return false;
+    if (isStrictBindReservedWord(name, true))
+        return false;
+    return true;
+};

package/dist/transforms/rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.d.ts

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

package/dist/transforms/rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js

@@ -0,0 +1,52 @@
+import { createRequire } from "node:module";
+import { getReferenceUsage } from "./get-reference-usage.js";
+import { getTargetName } from "./get-target-name.js";
+import { isUseReferenceFalseInitializer } from "./is-use-reference-false-initializer.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const renameUseReferenceGuardsV2Transform = {
+    id: "rename-use-reference-guards-v2",
+    description: "Renames boolean useRef(false) guard variables (including reset-to-false guards) to hasRunRef/hasRunRef2/...",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        const { projectGraph } = context;
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const [, fileInfo] of projectGraph.files) {
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    if (id.name.length > 2)
+                        return;
+                    if (!isUseReferenceFalseInitializer(path.node))
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    if (!binding.constant)
+                        return;
+                    const usage = getReferenceUsage(binding);
+                    if (!usage.isSafe || !usage.hasRead || !usage.hasTrueWrite)
+                        return;
+                    const targetName = getTargetName(path.scope, binding);
+                    if (!targetName)
+                        return;
+                    if (id.name === targetName)
+                        return;
+                    path.scope.rename(id.name, targetName);
+                    transformationsApplied++;
+                },
+            });
+        }
+        return Promise.resolve({
+            nodesVisited,
+            transformationsApplied,
+        });
+    },
+};
+export { renameUseReferenceGuardsV2Transform };

package/dist/transforms/transform-registry.js

@@ -4,6 +4,7 @@ import { expandSequenceExpressionsTransform } from "./expand-sequence-expression
 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 { expandSequenceExpressionsV4Transform } from "./expand-sequence-expressions-v4/expand-sequence-expressions-v4-transform.js";
 import { expandThrowSequenceTransform } from "./expand-throw-sequence/expand-throw-sequence-transform.js";
 import { expandUndefinedLiteralsTransform } from "./expand-undefined-literals/expand-undefined-literals-transform.js";
 import { renameCatchParametersTransform } from "./rename-catch-parameters/rename-catch-parameters-transform.js";
@@ -13,6 +14,7 @@ import { renameLoopIndexVariablesTransform } from "./rename-loop-index-variables
 import { renamePromiseExecutorParametersTransform } from "./rename-promise-executor-parameters/rename-promise-executor-parameters-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";
 import { splitVariableDeclarationsTransform } from "./split-variable-declarations/split-variable-declarations-transform.js";
 export const transformRegistry = {
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
@@ -21,6 +23,7 @@ export const transformRegistry = {
     [expandSequenceExpressionsV2Transform.id]: expandSequenceExpressionsV2Transform,
     [expandSequenceExpressionsV3Transform.id]: expandSequenceExpressionsV3Transform,
     [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
+    [expandSequenceExpressionsV4Transform.id]: expandSequenceExpressionsV4Transform,
     [expandThrowSequenceTransform.id]: expandThrowSequenceTransform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
@@ -30,6 +33,7 @@ export const transformRegistry = {
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
+    [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
 };
 export const allTransformIds = Object.keys(transformRegistry);

package/package.json

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

package/transform-manifest.json

@@ -95,19 +95,39 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": -0.014391951831788763,
-      "recommended": true,
+      "recommended": false,
       "evaluatedAt": "2026-01-23T08:21:23.662Z",
       "notes": "Supersedes expand-sequence-expressions-v2 in the recommended preset. Measured with baseline none: -1.44%. Enabled for readability even when line diffs increase."
     },
+    {
+      "id": "expand-sequence-expressions-v4",
+      "description": "Expands comma operator sequences in returns, throws, statements (including control-flow bodies), and variable initializers",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": -0.01730809158000035,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T10:57:45.082Z",
+      "notes": "Measured with baseline none: -1.73%. Supersedes expand-sequence-expressions-v3 and includes control-flow-body expansion."
+    },
     {
       "id": "rename-use-reference-guards",
       "description": "Renames boolean useRef(false) guard variables to hasRunRef/hasRunRef2/...",
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": 0,
-      "recommended": true,
+      "recommended": false,
       "evaluatedAt": "2026-01-22T17:03:19.826Z",
-      "notes": "Auto-added by evaluation script."
+      "notes": "Superseded by rename-use-reference-guards-v2.",
+      "supersededBy": "rename-use-reference-guards-v2"
+    },
+    {
+      "id": "rename-use-reference-guards-v2",
+      "description": "Renames boolean useRef(false) guard variables (including reset-to-false guards) to hasRunRef/hasRunRef2/...",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "notes": "Supersedes rename-use-reference-guards and also covers guards that reset to false."
     },
     {
       "id": "rename-timeout-ids",
@@ -162,8 +182,8 @@
   ],
   "presetStats": {
     "recommended": {
-      "diffReductionImpact": 0.00560578320530003,
-      "notes": "Measured with baseline none: 0.56%."
+      "diffReductionImpact": 0.0027273928389422997,
+      "notes": "Measured with baseline none: 0.27%."
     }
   }
 }