miniread 1.6.0 → 1.8.0

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

@@ -1,93 +0,0 @@
-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.isSwitchCase());
-};
-const isDirectiveProloguePosition = (path) => {
-    const parentPath = path.parentPath;
-    if (!parentPath)
-        return false;
-    if (!parentPath.isProgram() && !parentPath.isBlockStatement())
-        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 (path.node.kind !== "var" && path.node.declarations.length > 1) {
-        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/expand-sequence-expressions-v3/expand-expression-statement-sequence.d.ts

@@ -1,3 +0,0 @@
-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-v3/expand-expression-statement-sequence.js

@@ -1,64 +0,0 @@
-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 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.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 (!isSupportedStatementContainer(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" &&
-        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));
-    });
-    path.replaceWithMultiple(statements);
-    return true;
-};

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

@@ -1,3 +0,0 @@
-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-v3/expand-return-sequence.js

@@ -1,91 +0,0 @@
-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-v3/expand-sequence-expressions-v3-transform.d.ts

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

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

@@ -1,48 +0,0 @@
-import { createRequire } from "node:module";
-import { getFilesToProcess, } from "../../core/types.js";
-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 expandSequenceExpressionsV3Transform = {
-    id: "expand-sequence-expressions-v3",
-    description: "Expands comma operator sequences in returns, throws, statements, and variable initializers",
-    scope: "file",
-    parallelizable: true,
-    transform(context) {
-        let nodesVisited = 0;
-        let transformationsApplied = 0;
-        for (const fileInfo of getFilesToProcess(context)) {
-            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-v3/expand-throw-sequence.d.ts

@@ -1,3 +0,0 @@
-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-v3/expand-throw-sequence.js

@@ -1,101 +0,0 @@
-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-v3/expand-variable-declaration-sequence.d.ts

@@ -1,3 +0,0 @@
-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-v3/expand-variable-declaration-sequence.js

@@ -1,99 +0,0 @@
-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/expand-throw-sequence/expand-throw-sequence-transform.d.ts

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

package/dist/transforms/expand-throw-sequence/expand-throw-sequence-transform.js

@@ -1,117 +0,0 @@
-import { createRequire } from "node:module";
-import { getFilesToProcess, } from "../../core/types.js";
-const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-const traverse = require("@babel/traverse").default;
-// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-const t = require("@babel/types");
-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.isProgram() && !parentPath.isBlockStatement())
-        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 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);
-};
-export const expandThrowSequenceTransform = {
-    id: "expand-throw-sequence",
-    description: "Expands throw sequences like `throw (a(), b)`",
-    scope: "file",
-    parallelizable: true,
-    transform(context) {
-        let nodesVisited = 0;
-        let transformationsApplied = 0;
-        for (const fileInfo of getFilesToProcess(context)) {
-            traverse(fileInfo.ast, {
-                ThrowStatement(path) {
-                    nodesVisited++;
-                    if (!tryExpandThrowSequence(path))
-                        return;
-                    transformationsApplied += 1;
-                },
-            });
-        }
-        return Promise.resolve({ nodesVisited, transformationsApplied });
-    },
-};

package/dist/transforms/rename-binding/get-target-name.d.ts

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