miniread 1.11.0 → 1.13.0

package/dist/transforms/expand-sequence-expressions-v5/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-v5/expand-expression-statement-sequence.js

@@ -0,0 +1,92 @@
+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];
+    const shouldWrapFirstStringLiteralDirective = firstExpression?.type === "StringLiteral" &&
+        canReplaceWithMultiple(path) &&
+        isDirectiveProloguePosition(path);
+    const statements = expression.expressions.map((expr, index) => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        let clonedExpression = t.cloneNode(expr, true);
+        if (shouldWrapFirstStringLiteralDirective &&
+            index === 0 &&
+            expr.type === "StringLiteral") {
+            // 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);
+    });
+    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-v5/expand-if-statement-test-sequence.d.ts

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

package/dist/transforms/expand-sequence-expressions-v5/expand-if-statement-test-sequence.js

@@ -0,0 +1,104 @@
+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 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;
+};
+const createExpressionStatement = (expression, options) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    let clonedExpression = t.cloneNode(expression, true);
+    if (options.wrapStringLiteralDirective &&
+        expression.type === "StringLiteral") {
+        // 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);
+};
+export const tryExpandIfStatementTestSequence = (path) => {
+    if (!canReplaceWithMultiple(path) && !canWrapInBlock(path))
+        return false;
+    const test = path.node.test;
+    if (test.type !== "SequenceExpression")
+        return false;
+    if (test.expressions.length < 2)
+        return false;
+    const leadingExpressions = test.expressions.slice(0, -1);
+    const lastExpression = test.expressions.at(-1);
+    if (!lastExpression)
+        return false;
+    const firstExpression = leadingExpressions[0];
+    const shouldWrapFirstStringLiteralDirective = firstExpression?.type === "StringLiteral" &&
+        isDirectiveProloguePosition(path);
+    const statements = leadingExpressions.map((expression, index) => createExpressionStatement(expression, {
+        wrapStringLiteralDirective: shouldWrapFirstStringLiteralDirective && index === 0,
+    }));
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    const updatedIfStatement = t.cloneNode(path.node, true);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    updatedIfStatement.test = t.cloneNode(lastExpression, true);
+    statements.push(updatedIfStatement);
+    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-v5/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-v5/expand-return-sequence.js

@@ -0,0 +1,100 @@
+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) => {
+    const parentPath = path.parentPath;
+    if (parentPath.isBlockStatement()) {
+        if (parentPath.key !== "body")
+            return false;
+        if (!parentPath.parentPath.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 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];
+    const shouldWrapFirstStringLiteralDirective = 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 (shouldWrapFirstStringLiteralDirective &&
+            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.returnStatement(t.cloneNode(lastExpression, true)));
+    return replaceReturnWithStatements(path, statements);
+};

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

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

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

@@ -0,0 +1,55 @@
+import { createRequire } from "node:module";
+import { tryExpandExpressionStatementSequence } from "./expand-expression-statement-sequence.js";
+import { tryExpandIfStatementTestSequence } from "./expand-if-statement-test-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 expandSequenceExpressionsV5Transform = {
+    id: "expand-sequence-expressions-v5",
+    description: "Expands comma operator sequences in returns, throws, statements (including control-flow bodies), variable initializers, and `if` tests",
+    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;
+                },
+                IfStatement(path) {
+                    nodesVisited++;
+                    if (!tryExpandIfStatementTestSequence(path))
+                        return;
+                    transformationsApplied += 1;
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/expand-sequence-expressions-v5/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-v5/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-v5/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-v5/expand-variable-declaration-sequence.js

@@ -0,0 +1,103 @@
+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, options) => {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+    let clonedExpression = t.cloneNode(expression, true);
+    if (options.wrapStringLiteralDirective &&
+        expression.type === "StringLiteral") {
+        // 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);
+};
+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;
+    const isDirectivePrologueAtInsertion = isDirectiveProloguePosition(path);
+    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, {
+                wrapStringLiteralDirective: isDirectivePrologueAtInsertion && statements.length === 0,
+            }));
+        }
+        const newDeclarator = createVariableDeclarator(declarator.id, lastExpression);
+        statements.push(createVariableDeclarationStatement(kind, newDeclarator));
+    }
+    path.replaceWithMultiple(statements);
+    return true;
+};

package/dist/transforms/rename-comparison-flags/rename-comparison-flags-transform.d.ts

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

package/dist/transforms/rename-comparison-flags/rename-comparison-flags-transform.js

@@ -0,0 +1,86 @@
+import { createRequire } from "node:module";
+import { RenameGroup, isStableRenamed } 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 renameComparisonFlagsTransform = {
+    id: "rename-comparison-flags",
+    description: "Rename boolean variables assigned from string comparisons to descriptive flag names",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const renameGroup = new RenameGroup();
+            traverse(fileInfo.ast, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const { id, init } = path.node;
+                    if (!init || id.type !== "Identifier") {
+                        return;
+                    }
+                    if (init.type !== "BinaryExpression" ||
+                        (init.operator !== "===" &&
+                            init.operator !== "!==" &&
+                            init.operator !== "==" &&
+                            init.operator !== "!=")) {
+                        return;
+                    }
+                    let stringValue;
+                    if (init.right.type === "StringLiteral" &&
+                        init.left.type === "Identifier") {
+                        stringValue = init.right.value;
+                    }
+                    else if (init.left.type === "StringLiteral" &&
+                        init.right.type === "Identifier") {
+                        stringValue = init.left.value;
+                    }
+                    if (stringValue === undefined) {
+                        return;
+                    }
+                    const currentName = id.name;
+                    if (isStableRenamed(currentName)) {
+                        return;
+                    }
+                    const operator = init.operator;
+                    const parts = stringValue.split(/[^\dA-Za-z]+/u).filter(Boolean);
+                    const capitalizedValue = parts.length === 0
+                        ? stringValue === ""
+                            ? "EmptyString"
+                            : "Flag"
+                        : parts
+                            .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+                            .join("");
+                    let baseName;
+                    switch (operator) {
+                        case "===": {
+                            baseName = `is${capitalizedValue}`;
+                            break;
+                        }
+                        case "!==": {
+                            baseName = `isNot${capitalizedValue}`;
+                            break;
+                        }
+                        case "==": {
+                            baseName = `equals${capitalizedValue}`;
+                            break;
+                        }
+                        case "!=": {
+                            baseName = `notEquals${capitalizedValue}`;
+                            break;
+                        }
+                    }
+                    renameGroup.add({
+                        scope: path.scope,
+                        currentName,
+                        baseName,
+                    });
+                },
+            });
+            transformationsApplied += renameGroup.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/transform-registry.js

@@ -1,8 +1,10 @@
 import { expandBooleanLiteralsTransform } from "./expand-boolean-literals/expand-boolean-literals-transform.js";
 import { expandSpecialNumberLiteralsTransform } from "./expand-special-number-literals/expand-special-number-literals-transform.js";
 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 { 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";
 import { renameEventParametersTransform } from "./rename-event-parameters/rename-event-parameters-transform.js";
 import { renameLoopIndexVariablesTransform } from "./rename-loop-index-variables/rename-loop-index-variables-transform.js";
@@ -19,8 +21,10 @@ export const transformRegistry = {
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
     [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
     [expandSequenceExpressionsV4Transform.id]: expandSequenceExpressionsV4Transform,
+    [expandSequenceExpressionsV5Transform.id]: expandSequenceExpressionsV5Transform,
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
+    [renameComparisonFlagsTransform.id]: renameComparisonFlagsTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameEventParametersTransform.id]: renameEventParametersTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,

package/package.json

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

package/transform-manifest.json

@@ -97,9 +97,19 @@
       "scope": "file",
       "parallelizable": true,
       "diffReductionImpact": -0.01730809158000035,
-      "recommended": true,
+      "recommended": false,
       "evaluatedAt": "2026-01-23T10:57:45.082Z",
-      "notes": "Measured with baseline none: -1.73%. Supersedes all prior sequence expression transforms."
+      "notes": "Measured with baseline none: -1.73%. Supersedes all prior sequence expression transforms. Superseded by expand-sequence-expressions-v5.",
+      "supersededBy": "expand-sequence-expressions-v5"
+    },
+    {
+      "id": "expand-sequence-expressions-v5",
+      "description": "Expands comma operator sequences in returns, throws, statements (including control-flow bodies), variable initializers, and `if` tests",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": -0.020243106019139034,
+      "recommended": true,
+      "notes": "Extends expand-sequence-expressions-v4 by also expanding `if ((a, b)) ...` style tests."
     },
     {
       "id": "rename-use-reference-guards",
@@ -131,6 +141,16 @@
       "evaluatedAt": "2026-01-23T10:29:23.279Z",
       "notes": "Measured with baseline none: 0.00%. Added to recommended for readability."
     },
+    {
+      "id": "rename-comparison-flags",
+      "description": "Rename boolean variables assigned from string comparisons to descriptive flag names",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T17:54:14.000Z",
+      "notes": "Measured with baseline none: 0%. Improves readability by renaming minified variables like 'saA === \"darwin\"' to '$isDarwin'."
+    },
     {
       "id": "split-variable-declarations",
       "description": "Splits multi-declarator variable declarations into separate statements",