miniread 1.48.0 → 1.49.0

package/dist/transforms/_generated/manifest.js

@@ -185,6 +185,11 @@ const manifestData = {
         notes: "Negative diff reduction in evaluation; keep optional.",
         evaluations: { "legacy:evaluation": { "diffSizePercent": 100.00188483649043, "evaluatedAt": "2026-01-25T10:04:22.417Z", "changedLines": 0, "durationSeconds": 0, "stableNames": 0 } },
     },
+    "rename-string-split-variables": {
+        recommended: true,
+        notes: "Measured with baseline none: 0.00%. Added to recommended for readability.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-01-26T07:03:04.068Z", "changedLines": 0, "durationSeconds": 78.43914533300001, "stableNames": 1357 } },
+    },
     "rename-this-aliases": {
         recommended: true,
         notes: "Measured with baseline none: 0.00%. Improves readability by stabilizing `this` aliases used for closures.",

package/dist/transforms/_generated/registry.js

@@ -36,6 +36,7 @@ import { renameRegexBuildersTransform } from "../rename-regex-builders/rename-re
 import { renameReplaceChildParametersTransform } from "../rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameRestParametersTransform } from "../rename-rest-parameters/rename-rest-parameters-transform.js";
 import { renameSafePropertyAccessorParametersTransform } from "../rename-safe-property-accessor-parameters/rename-safe-property-accessor-parameters-transform.js";
+import { renameStringSplitVariablesTransform } from "../rename-string-split-variables/rename-string-split-variables-transform.js";
 import { renameThisAliasesTransform } from "../rename-this-aliases/rename-this-aliases-transform.js";
 import { renameTimeoutDurationParametersTransform } from "../rename-timeout-duration-parameters/rename-timeout-duration-parameters-transform.js";
 import { renameTimeoutIdsTransform } from "../rename-timeout-ids/rename-timeout-ids-transform.js";
@@ -89,6 +90,7 @@ export const transformRegistry = {
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameRestParametersTransform.id]: renameRestParametersTransform,
     [renameSafePropertyAccessorParametersTransform.id]: renameSafePropertyAccessorParametersTransform,
+    [renameStringSplitVariablesTransform.id]: renameStringSplitVariablesTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
     [renameTimeoutDurationParametersTransform.id]: renameTimeoutDurationParametersTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,

package/dist/transforms/rename-string-split-variables/get-split-helper-info.d.ts

@@ -0,0 +1,8 @@
+import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+type SplitHelperInfo = SplitHelperDeclarations & {
+    inputName: string;
+    delimiterName: string;
+};
+export declare const getSplitHelperInfo: (node: FunctionDeclaration | FunctionExpression | ArrowFunctionExpression) => SplitHelperInfo | undefined;
+export {};

package/dist/transforms/rename-string-split-variables/get-split-helper-info.js

@@ -0,0 +1,40 @@
+import { isIdentifierNode } from "./split-helper-guards.js";
+import { getSplitHelperDeclarationsFromStatements } from "./split-helper-declarations.js";
+import { isSplitHelperLoop } from "./split-helper-loop.js";
+import { isSplitHelperTail } from "./split-helper-tail.js";
+export const getSplitHelperInfo = (node) => {
+    if (node.params.length !== 2)
+        return undefined;
+    const inputParameter = node.params[0];
+    const delimiterParameter = node.params[1];
+    if (!isIdentifierNode(inputParameter) ||
+        !isIdentifierNode(delimiterParameter))
+        return undefined;
+    if (node.body.type !== "BlockStatement")
+        return undefined;
+    const statements = node.body.body;
+    const declarationsMatch = getSplitHelperDeclarationsFromStatements(statements, inputParameter.name, delimiterParameter.name);
+    if (!declarationsMatch)
+        return undefined;
+    const { nextStatementIndex, ...declarations } = declarationsMatch;
+    const loopStatement = statements[nextStatementIndex];
+    if (!isSplitHelperLoop(loopStatement, declarations, inputParameter.name, delimiterParameter.name))
+        return undefined;
+    const tailStatements = statements.slice(nextStatementIndex + 1);
+    if (!isSplitHelperTail(tailStatements, declarations, inputParameter.name))
+        return undefined;
+    const uniqueNames = new Set([
+        inputParameter.name,
+        delimiterParameter.name,
+        declarations.partsName,
+        declarations.startIndexName,
+        declarations.delimiterIndexName,
+    ]);
+    if (uniqueNames.size !== 5)
+        return undefined;
+    return {
+        inputName: inputParameter.name,
+        delimiterName: delimiterParameter.name,
+        ...declarations,
+    };
+};

package/dist/transforms/rename-string-split-variables/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 100,
+            "evaluatedAt": "2026-01-26T07:03:04.068Z",
+            "changedLines": 0,
+            "durationSeconds": 78.43914533300001,
+            "stableNames": 1357
+        }
+    },
+    "notes": "Measured with baseline none: 0.00%. Added to recommended for readability."
+}

package/dist/transforms/rename-string-split-variables/rename-string-split-variables-transform.d.ts

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

package/dist/transforms/rename-string-split-variables/rename-string-split-variables-transform.js

@@ -0,0 +1,69 @@
+import { createRequire } from "node:module";
+import { RenameGroup } from "../../core/stable-naming.js";
+import { getFilesToProcess } from "../../core/types.js";
+import { getSplitHelperInfo } from "./get-split-helper-info.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+const collectSplitHelperRenames = (path, group) => {
+    // Intentionally no early-return based on stable-renamed params:
+    // parameters can be stable while helper locals are still minified.
+    const info = getSplitHelperInfo(path.node);
+    if (!info)
+        return;
+    const scope = path.scope;
+    group.add({
+        scope,
+        currentName: info.inputName,
+        baseName: "input",
+    });
+    group.add({
+        scope,
+        currentName: info.delimiterName,
+        baseName: "delimiter",
+    });
+    group.add({
+        scope,
+        currentName: info.partsName,
+        baseName: "parts",
+    });
+    group.add({
+        scope,
+        currentName: info.startIndexName,
+        baseName: "startIndex",
+    });
+    group.add({
+        scope,
+        currentName: info.delimiterIndexName,
+        baseName: "delimiterIndex",
+    });
+};
+export const renameStringSplitVariablesTransform = {
+    id: "rename-string-split-variables",
+    description: "Renames local variables in manual string split helpers (indexOf + slice loop) to stable $input-style names (prefers $input/$delimiter/$parts/$startIndex/$delimiterIndex)",
+    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, {
+                FunctionDeclaration(path) {
+                    nodesVisited++;
+                    collectSplitHelperRenames(path, group);
+                },
+                FunctionExpression(path) {
+                    nodesVisited++;
+                    collectSplitHelperRenames(path, group);
+                },
+                ArrowFunctionExpression(path) {
+                    nodesVisited++;
+                    collectSplitHelperRenames(path, group);
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-string-split-variables/split-helper-declarations.d.ts

@@ -0,0 +1,11 @@
+import type { Statement } from "@babel/types";
+export type SplitHelperDeclarations = {
+    partsName: string;
+    startIndexName: string;
+    delimiterIndexName: string;
+};
+type SplitHelperDeclarationsMatch = SplitHelperDeclarations & {
+    nextStatementIndex: number;
+};
+export declare const getSplitHelperDeclarationsFromStatements: (statements: Statement[], inputName: string, delimiterName: string) => SplitHelperDeclarationsMatch | undefined;
+export {};

package/dist/transforms/rename-string-split-variables/split-helper-declarations.js

@@ -0,0 +1,80 @@
+import { isIdentifierNode, isMemberCall, isNumericLiteralNode, } from "./split-helper-guards.js";
+const isDirectivePrologueStatement = (statement) => {
+    // In JavaScript, any leading sequence of `"..."`; expression statements is the
+    // "directive prologue" (most commonly `"use strict";`). Babel sometimes also
+    // marks these with `statement.directive`, but we intentionally only rely on
+    // the lexical shape so we still match after AST rewrites.
+    if (statement.type !== "ExpressionStatement")
+        return false;
+    return statement.expression.type === "StringLiteral";
+};
+const getVariableDeclarators = (statement) => {
+    if (statement.type !== "VariableDeclaration")
+        return undefined;
+    if (statement.declarations.length === 0)
+        return undefined;
+    return statement.declarations;
+};
+export const getSplitHelperDeclarationsFromStatements = (statements, inputName, delimiterName) => {
+    const declarators = [];
+    let statementIndex = 0;
+    while (statementIndex < statements.length) {
+        const statement = statements[statementIndex];
+        if (!statement)
+            return undefined;
+        if (!isDirectivePrologueStatement(statement))
+            break;
+        statementIndex++;
+    }
+    if (statementIndex >= statements.length)
+        return undefined;
+    let declarationStatementsConsumed = 0;
+    while (declarators.length < 3) {
+        if (statementIndex >= statements.length)
+            return undefined;
+        const statement = statements[statementIndex];
+        if (!statement)
+            return undefined;
+        const statementDeclarators = getVariableDeclarators(statement);
+        if (!statementDeclarators)
+            return undefined;
+        declarationStatementsConsumed++;
+        if (declarationStatementsConsumed > 3)
+            return undefined;
+        const totalDeclarators = declarators.length + statementDeclarators.length;
+        if (totalDeclarators > 3)
+            return undefined;
+        declarators.push(...statementDeclarators);
+        statementIndex++;
+    }
+    const identifierDeclarators = declarators.filter((declarator) => declarator.id.type === "Identifier");
+    if (identifierDeclarators.length !== declarators.length)
+        return undefined;
+    const partsDeclarator = identifierDeclarators.find((declarator) => {
+        if (declarator.init?.type !== "ArrayExpression")
+            return false;
+        return declarator.init.elements.length === 0;
+    });
+    const startDeclarator = identifierDeclarators.find((declarator) => isNumericLiteralNode(declarator.init ?? undefined, 0));
+    const indexDeclarator = identifierDeclarators.find((declarator) => {
+        if (declarator.init?.type !== "CallExpression")
+            return false;
+        if (!isMemberCall(declarator.init, inputName, "indexOf"))
+            return false;
+        if (!isIdentifierNode(declarator.init.arguments[0], delimiterName))
+            return false;
+        if (declarator.init.arguments.length === 1)
+            return true;
+        if (declarator.init.arguments.length !== 2)
+            return false;
+        return isNumericLiteralNode(declarator.init.arguments[1], 0);
+    });
+    if (!partsDeclarator || !startDeclarator || !indexDeclarator)
+        return undefined;
+    return {
+        partsName: partsDeclarator.id.name,
+        startIndexName: startDeclarator.id.name,
+        delimiterIndexName: indexDeclarator.id.name,
+        nextStatementIndex: statementIndex,
+    };
+};

package/dist/transforms/rename-string-split-variables/split-helper-guards.d.ts

@@ -0,0 +1,8 @@
+import type { BinaryExpression, CallExpression, Identifier, Node, NumericLiteral, Statement } from "@babel/types";
+export declare const isIdentifierNode: (node: Node | undefined, name?: string) => node is Identifier;
+export declare const isNumericLiteralNode: (node: Node | undefined, value?: number) => node is NumericLiteral;
+export declare const getBlockStatements: (statement: Statement) => Statement[] | undefined;
+export declare const isMemberCall: (expression: CallExpression, objectName: string, propertyName: string) => boolean;
+export declare const isPushSliceStatement: (statement: Statement, partsName: string, inputName: string, startName: string, endName?: string) => boolean;
+export declare const isAssignmentStatement: (statement: Statement, targetName: string, expectedExpression: (expression: Node) => boolean) => boolean;
+export declare const isBinaryExpression: (expression: Node, operator: BinaryExpression["operator"], leftName: string, rightValue: number) => boolean;

package/dist/transforms/rename-string-split-variables/split-helper-guards.js

@@ -0,0 +1,73 @@
+export const isIdentifierNode = (node, name) => {
+    if (node?.type !== "Identifier")
+        return false;
+    return name ? node.name === name : true;
+};
+export const isNumericLiteralNode = (node, value) => {
+    if (node?.type !== "NumericLiteral")
+        return false;
+    return value === undefined ? true : node.value === value;
+};
+export const getBlockStatements = (statement) => {
+    if (statement.type !== "BlockStatement")
+        return undefined;
+    return statement.body;
+};
+export const isMemberCall = (expression, objectName, propertyName) => {
+    const callee = expression.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (!isIdentifierNode(callee.object, objectName))
+        return false;
+    return isIdentifierNode(callee.property, propertyName);
+};
+const isSliceCallWithArguments = (expression, inputName, startName, endName) => {
+    if (!isMemberCall(expression, inputName, "slice"))
+        return false;
+    if (!isIdentifierNode(expression.arguments[0], startName))
+        return false;
+    if (endName === undefined) {
+        return expression.arguments.length === 1;
+    }
+    if (!isIdentifierNode(expression.arguments[1], endName))
+        return false;
+    return expression.arguments.length === 2;
+};
+export const isPushSliceStatement = (statement, partsName, inputName, startName, endName) => {
+    if (statement.type !== "ExpressionStatement")
+        return false;
+    const expression = statement.expression;
+    if (expression.type !== "CallExpression")
+        return false;
+    if (!isMemberCall(expression, partsName, "push"))
+        return false;
+    if (expression.arguments.length !== 1)
+        return false;
+    const argument0 = expression.arguments[0];
+    if (argument0?.type !== "CallExpression")
+        return false;
+    return isSliceCallWithArguments(argument0, inputName, startName, endName);
+};
+export const isAssignmentStatement = (statement, targetName, expectedExpression) => {
+    if (statement.type !== "ExpressionStatement")
+        return false;
+    const expression = statement.expression;
+    if (expression.type !== "AssignmentExpression")
+        return false;
+    if (expression.operator !== "=")
+        return false;
+    if (!isIdentifierNode(expression.left, targetName))
+        return false;
+    return expectedExpression(expression.right);
+};
+export const isBinaryExpression = (expression, operator, leftName, rightValue) => {
+    if (expression.type !== "BinaryExpression")
+        return false;
+    if (expression.operator !== operator)
+        return false;
+    if (!isIdentifierNode(expression.left, leftName))
+        return false;
+    return isNumericLiteralNode(expression.right, rightValue);
+};

package/dist/transforms/rename-string-split-variables/split-helper-loop.d.ts

@@ -0,0 +1,3 @@
+import type { Statement } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isSplitHelperLoop: (statement: Statement | undefined, declarations: SplitHelperDeclarations, inputName: string, delimiterName: string) => boolean;

package/dist/transforms/rename-string-split-variables/split-helper-loop.js

@@ -0,0 +1,116 @@
+import { isAssignmentStatement, isBinaryExpression, isIdentifierNode, isMemberCall, isNumericLiteralNode, isPushSliceStatement, } from "./split-helper-guards.js";
+const isNegativeOneLiteral = (expression) => {
+    if (expression.type === "NumericLiteral")
+        return expression.value === -1;
+    if (expression.type !== "UnaryExpression")
+        return false;
+    if (expression.operator !== "-")
+        return false;
+    if (expression.argument.type !== "NumericLiteral")
+        return false;
+    return expression.argument.value === 1;
+};
+const isNotFoundBinaryTest = (expression, name) => {
+    if (expression.type !== "BinaryExpression")
+        return false;
+    if (expression.operator !== "!==" && expression.operator !== "!=")
+        return false;
+    if (!isIdentifierNode(expression.left, name))
+        return false;
+    return isNegativeOneLiteral(expression.right);
+};
+const isFoundBinaryTest = (expression, name) => {
+    if (expression.type !== "BinaryExpression")
+        return false;
+    if (expression.operator !== ">")
+        return false;
+    if (!isIdentifierNode(expression.left, name))
+        return false;
+    return isNegativeOneLiteral(expression.right);
+};
+const isBitwiseNotTest = (expression, name) => {
+    if (expression.type !== "UnaryExpression")
+        return false;
+    if (expression.operator !== "~")
+        return false;
+    return isIdentifierNode(expression.argument, name);
+};
+export const isSplitHelperLoop = (statement, declarations, inputName, delimiterName) => {
+    if (statement?.type !== "WhileStatement")
+        return false;
+    const isNonNegativeTest = (expression) => {
+        if (isBinaryExpression(expression, ">=", declarations.delimiterIndexName, 0)) {
+            return true;
+        }
+        if (expression.type !== "BinaryExpression")
+            return false;
+        if (expression.operator !== "<=")
+            return false;
+        if (!isNumericLiteralNode(expression.left, 0))
+            return false;
+        return isIdentifierNode(expression.right, declarations.delimiterIndexName);
+    };
+    if (!isNonNegativeTest(statement.test) &&
+        !isNotFoundBinaryTest(statement.test, declarations.delimiterIndexName) &&
+        !isFoundBinaryTest(statement.test, declarations.delimiterIndexName) &&
+        !isBitwiseNotTest(statement.test, declarations.delimiterIndexName)) {
+        return false;
+    }
+    if (statement.body.type !== "BlockStatement")
+        return false;
+    if (statement.body.body.length !== 3)
+        return false;
+    const [pushStatement, advanceStatement, updateStatement] = statement.body.body;
+    if (!pushStatement || !advanceStatement || !updateStatement)
+        return false;
+    if (!isPushSliceStatement(pushStatement, declarations.partsName, inputName, declarations.startIndexName, declarations.delimiterIndexName))
+        return false;
+    const isAdvanceExpression = (expression) => {
+        if (isBinaryExpression(expression, "+", declarations.delimiterIndexName, 1)) {
+            return true;
+        }
+        if (expression.type === "BinaryExpression" && expression.operator === "+") {
+            if (isNumericLiteralNode(expression.left, 1) &&
+                isIdentifierNode(expression.right, declarations.delimiterIndexName)) {
+                return true;
+            }
+            const left = expression.left;
+            const right = expression.right;
+            if (left.type === "MemberExpression" &&
+                !left.computed &&
+                isIdentifierNode(left.object, delimiterName) &&
+                isIdentifierNode(left.property, "length") &&
+                isIdentifierNode(right, declarations.delimiterIndexName)) {
+                return true;
+            }
+        }
+        if (expression.type !== "BinaryExpression")
+            return false;
+        if (expression.operator !== "+")
+            return false;
+        if (!isIdentifierNode(expression.left, declarations.delimiterIndexName))
+            return false;
+        const right = expression.right;
+        if (right.type !== "MemberExpression")
+            return false;
+        if (right.computed)
+            return false;
+        if (!isIdentifierNode(right.object, delimiterName))
+            return false;
+        return isIdentifierNode(right.property, "length");
+    };
+    if (!isAssignmentStatement(advanceStatement, declarations.startIndexName, isAdvanceExpression))
+        return false;
+    const isUpdateExpression = (expression) => {
+        if (expression.type !== "CallExpression")
+            return false;
+        if (!isMemberCall(expression, inputName, "indexOf"))
+            return false;
+        if (expression.arguments.length !== 2)
+            return false;
+        if (!isIdentifierNode(expression.arguments[0], delimiterName))
+            return false;
+        return isIdentifierNode(expression.arguments[1], declarations.startIndexName);
+    };
+    return isAssignmentStatement(updateStatement, declarations.delimiterIndexName, isUpdateExpression);
+};

package/dist/transforms/rename-string-split-variables/split-helper-tail-expressions.d.ts

@@ -0,0 +1,3 @@
+import type { Node } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isReturnWithOptionalTailPush: (node: Node, declarations: SplitHelperDeclarations, inputName: string) => boolean;

package/dist/transforms/rename-string-split-variables/split-helper-tail-expressions.js

@@ -0,0 +1,86 @@
+import { isIdentifierNode } from "./split-helper-guards.js";
+import { isAtEndTest, isShouldPushTailTest, } from "./split-helper-tail-tests.js";
+const isPushSliceCallExpression = (node, declarations, inputName) => {
+    if (node.type !== "CallExpression")
+        return false;
+    const callee = node.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    if (callee.computed)
+        return false;
+    if (!isIdentifierNode(callee.object, declarations.partsName))
+        return false;
+    if (!isIdentifierNode(callee.property, "push"))
+        return false;
+    if (node.arguments.length !== 1)
+        return false;
+    const argument0 = node.arguments[0];
+    if (argument0?.type !== "CallExpression")
+        return false;
+    const sliceCallee = argument0.callee;
+    if (sliceCallee.type !== "MemberExpression")
+        return false;
+    if (sliceCallee.computed)
+        return false;
+    if (!isIdentifierNode(sliceCallee.object, inputName))
+        return false;
+    if (!isIdentifierNode(sliceCallee.property, "slice"))
+        return false;
+    if (argument0.arguments.length !== 1)
+        return false;
+    return isIdentifierNode(argument0.arguments[0], declarations.startIndexName);
+};
+const isPushSequenceExpression = (node, declarations, inputName) => {
+    if (node.type !== "SequenceExpression")
+        return false;
+    if (node.expressions.length !== 2)
+        return false;
+    const [first, second] = node.expressions;
+    if (!first || !second)
+        return false;
+    if (!isPushSliceCallExpression(first, declarations, inputName))
+        return false;
+    return isIdentifierNode(second, declarations.partsName);
+};
+export const isReturnWithOptionalTailPush = (node, declarations, inputName) => {
+    if (node.type === "ConditionalExpression") {
+        const testIsShouldPush = isShouldPushTailTest(node.test, declarations, inputName);
+        const testIsAtEnd = isAtEndTest(node.test, declarations, inputName);
+        if (!testIsShouldPush && !testIsAtEnd)
+            return false;
+        const consequent = node.consequent;
+        const alternate = node.alternate;
+        const consequentIsParts = isIdentifierNode(consequent, declarations.partsName);
+        const alternateIsParts = isIdentifierNode(alternate, declarations.partsName);
+        const consequentIsPush = isPushSequenceExpression(consequent, declarations, inputName);
+        const alternateIsPush = isPushSequenceExpression(alternate, declarations, inputName);
+        if (testIsShouldPush) {
+            if (!consequentIsPush)
+                return false;
+            return alternateIsParts;
+        }
+        if (!testIsAtEnd)
+            return false;
+        if (!alternateIsPush)
+            return false;
+        return consequentIsParts;
+    }
+    if (node.type !== "SequenceExpression")
+        return false;
+    if (node.expressions.length !== 2)
+        return false;
+    const [first, second] = node.expressions;
+    if (!first || !second)
+        return false;
+    if (!isIdentifierNode(second, declarations.partsName))
+        return false;
+    if (isPushSliceCallExpression(first, declarations, inputName))
+        return true;
+    if (first.type === "LogicalExpression" &&
+        first.operator === "&&" &&
+        isShouldPushTailTest(first.left, declarations, inputName) &&
+        isPushSliceCallExpression(first.right, declarations, inputName)) {
+        return true;
+    }
+    return false;
+};

package/dist/transforms/rename-string-split-variables/split-helper-tail-tests.d.ts

@@ -0,0 +1,4 @@
+import type { Node } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isShouldPushTailTest: (node: Node, declarations: SplitHelperDeclarations, inputName: string) => boolean;
+export declare const isAtEndTest: (node: Node, declarations: SplitHelperDeclarations, inputName: string) => boolean;

package/dist/transforms/rename-string-split-variables/split-helper-tail-tests.js

@@ -0,0 +1,39 @@
+import { isIdentifierNode } from "./split-helper-guards.js";
+const isInputLengthMemberExpression = (node, inputName) => {
+    if (node.type !== "MemberExpression")
+        return false;
+    if (node.computed)
+        return false;
+    if (!isIdentifierNode(node.object, inputName))
+        return false;
+    return isIdentifierNode(node.property, "length");
+};
+export const isShouldPushTailTest = (node, declarations, inputName) => {
+    if (node.type !== "BinaryExpression")
+        return false;
+    const operator = node.operator;
+    if ((operator === "!==" || operator === "!=" || operator === "<") &&
+        isIdentifierNode(node.left, declarations.startIndexName) &&
+        isInputLengthMemberExpression(node.right, inputName)) {
+        return true;
+    }
+    if ((operator === "!==" || operator === "!=" || operator === ">") &&
+        isInputLengthMemberExpression(node.left, inputName) &&
+        isIdentifierNode(node.right, declarations.startIndexName)) {
+        return true;
+    }
+    return false;
+};
+export const isAtEndTest = (node, declarations, inputName) => {
+    if (node.type !== "BinaryExpression")
+        return false;
+    const operator = node.operator;
+    if (operator !== "===" && operator !== "==")
+        return false;
+    if (isIdentifierNode(node.left, declarations.startIndexName) &&
+        isInputLengthMemberExpression(node.right, inputName)) {
+        return true;
+    }
+    return (isInputLengthMemberExpression(node.left, inputName) &&
+        isIdentifierNode(node.right, declarations.startIndexName));
+};

package/dist/transforms/rename-string-split-variables/split-helper-tail.d.ts

@@ -0,0 +1,3 @@
+import type { Statement } from "@babel/types";
+import type { SplitHelperDeclarations } from "./split-helper-declarations.js";
+export declare const isSplitHelperTail: (tailStatements: Statement[], declarations: SplitHelperDeclarations, inputName: string) => boolean;

package/dist/transforms/rename-string-split-variables/split-helper-tail.js

@@ -0,0 +1,49 @@
+import { getBlockStatements, isIdentifierNode, isPushSliceStatement, } from "./split-helper-guards.js";
+import { isReturnWithOptionalTailPush } from "./split-helper-tail-expressions.js";
+import { isShouldPushTailTest } from "./split-helper-tail-tests.js";
+const isReturnPartsStatement = (statement, declarations) => {
+    if (statement?.type !== "ReturnStatement")
+        return false;
+    return isIdentifierNode(statement.argument ?? undefined, declarations.partsName);
+};
+export const isSplitHelperTail = (tailStatements, declarations, inputName) => {
+    if (tailStatements.length === 2) {
+        const [firstTailStatement, secondTailStatement] = tailStatements;
+        if (!firstTailStatement || !secondTailStatement)
+            return false;
+        if (firstTailStatement.type === "IfStatement") {
+            const ifStatement = firstTailStatement;
+            const returnStatement = secondTailStatement;
+            if (ifStatement.alternate)
+                return false;
+            if (!isShouldPushTailTest(ifStatement.test, declarations, inputName))
+                return false;
+            const ifStatements = getBlockStatements(ifStatement.consequent) ?? [
+                ifStatement.consequent,
+            ];
+            if (ifStatements.length !== 1)
+                return false;
+            const ifConsequent = ifStatements[0];
+            if (!ifConsequent)
+                return false;
+            if (!isPushSliceStatement(ifConsequent, declarations.partsName, inputName, declarations.startIndexName))
+                return false;
+            return isReturnPartsStatement(returnStatement, declarations);
+        }
+        if (isPushSliceStatement(firstTailStatement, declarations.partsName, inputName, declarations.startIndexName)) {
+            return isReturnPartsStatement(secondTailStatement, declarations);
+        }
+        return false;
+    }
+    if (tailStatements.length !== 1)
+        return false;
+    const tailStatement = tailStatements[0];
+    if (!tailStatement)
+        return false;
+    if (tailStatement.type !== "ReturnStatement")
+        return false;
+    const argument = tailStatement.argument;
+    if (!argument)
+        return false;
+    return isReturnWithOptionalTailPush(argument, declarations, inputName);
+};

package/package.json

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