miniread 1.5.0 → 1.7.0

package/dist/core/normalize-code.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Normalizes JavaScript/TypeScript code through the parse → generate → format pipeline.
+ *
+ * This ensures consistent whitespace and formatting regardless of the original source.
+ * Use this when comparing code that may have gone through different pipelines
+ * (e.g., comparing base.js to transform output).
+ *
+ * The pipeline:
+ * 1. Parse with Babel (normalizes AST structure)
+ * 2. Generate with Babel (produces consistent whitespace)
+ * 3. Format with Prettier (final formatting)
+ */
+/**
+ * Normalizes code through parse → generate → format pipeline.
+ * Returns the normalized code string.
+ */
+export declare const normalizeCode: (code: string) => Promise<string>;

package/dist/core/normalize-code.js

@@ -0,0 +1,35 @@
+/**
+ * Normalizes JavaScript/TypeScript code through the parse → generate → format pipeline.
+ *
+ * This ensures consistent whitespace and formatting regardless of the original source.
+ * Use this when comparing code that may have gone through different pipelines
+ * (e.g., comparing base.js to transform output).
+ *
+ * The pipeline:
+ * 1. Parse with Babel (normalizes AST structure)
+ * 2. Generate with Babel (produces consistent whitespace)
+ * 3. Format with Prettier (final formatting)
+ */
+import { createRequire } from "node:module";
+import * as prettier from "prettier";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const parser = require("@babel/parser");
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const parse = parser.parse;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const generate = require("@babel/generator").default;
+const PARSER_OPTIONS = {
+    sourceType: "unambiguous",
+    plugins: ["jsx", "typescript", "importAttributes"],
+};
+/**
+ * Normalizes code through parse → generate → format pipeline.
+ * Returns the normalized code string.
+ */
+export const normalizeCode = async (code) => {
+    const ast = parse(code, PARSER_OPTIONS);
+    const generated = generate(ast);
+    const formatted = await prettier.format(generated.code, { parser: "babel" });
+    return formatted;
+};

package/dist/core/stable-naming.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Helpers for the stable name prefix convention (§5.6-5.9 in workflow.md).
+ *
+ * The `$` prefix signals that a variable has been renamed stably by a transform
+ * and should be skipped by other transforms.
+ *
+ * - Stable names (`$timeoutId`): Readable AND deterministic across versions
+ * - Readable names (`timeoutId`): Semantic but order-dependent
+ */
+import type { Scope } from "@babel/traverse";
+/**
+ * Returns true if the name has been stable-renamed (starts with $).
+ * Transforms should skip variables with this prefix.
+ */
+export declare const isStableRenamed: (name: string) => boolean;
+/**
+ * Entry for a planned rename operation.
+ */
+type RenameEntry = {
+    /** The Babel scope containing the binding */
+    scope: Scope;
+    /** Current name of the variable */
+    currentName: string;
+    /** Desired semantic base name (e.g., "timeoutId", "error") */
+    baseName: string;
+};
+/**
+ * Collects rename operations and applies them with automatic stability logic.
+ *
+ * Usage:
+ * ```typescript
+ * const group = new RenameGroup();
+ *
+ * // Collect renames during traversal
+ * group.add({ scope: path.scope, currentName: "a", baseName: "timeoutId" });
+ * group.add({ scope: path.scope, currentName: "b", baseName: "timeoutId" });
+ *
+ * // Apply with automatic stability
+ * const count = group.apply();
+ * // Result: a → timeoutId, b → timeoutId2 (readable, 2+ unstable)
+ * // Or if only one: a → $timeoutId (stable, exactly 1 unstable)
+ * ```
+ *
+ * Stability rules (per scope, per baseName):
+ * - If exactly 1 unstable variable wants this name → stable (`$baseName`)
+ * - If 2+ unstable variables want the same name → readable only (`baseName`, `baseName2`, ...)
+ */
+export declare class RenameGroup {
+    private entries;
+    /**
+     * Add a variable to be renamed.
+     * Already-stable names (starting with $) are automatically skipped.
+     */
+    add(entry: RenameEntry): void;
+    /**
+     * Apply all collected renames with automatic stability logic.
+     * Returns the number of transformations applied.
+     */
+    apply(): number;
+}
+export {};

package/dist/core/stable-naming.js

@@ -0,0 +1,121 @@
+/**
+ * Helpers for the stable name prefix convention (§5.6-5.9 in workflow.md).
+ *
+ * The `$` prefix signals that a variable has been renamed stably by a transform
+ * and should be skipped by other transforms.
+ *
+ * - Stable names (`$timeoutId`): Readable AND deterministic across versions
+ * - Readable names (`timeoutId`): Semantic but order-dependent
+ */
+const STABLE_PREFIX = "$";
+/**
+ * Returns true if the name has been stable-renamed (starts with $).
+ * Transforms should skip variables with this prefix.
+ */
+export const isStableRenamed = (name) => {
+    return name.startsWith(STABLE_PREFIX);
+};
+/**
+ * Creates a stable name by adding the $ prefix.
+ * Internal helper - prefer using RenameGroup which handles stability logic automatically.
+ */
+const makeStableName = (baseName) => {
+    return `${STABLE_PREFIX}${baseName}`;
+};
+/**
+ * Finds the next available name slot in a scope.
+ */
+const findAvailableName = (scope, baseName, startIndex, canBeStable) => {
+    let index = startIndex;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    while (true) {
+        const suffix = index === 1 ? "" : String(index);
+        const candidateBase = `${baseName}${suffix}`;
+        const candidateStable = makeStableName(candidateBase);
+        const candidateReadable = candidateBase;
+        // Check if either form is already taken in this scope
+        const stableTaken = scope.hasBinding(candidateStable);
+        const readableTaken = scope.hasBinding(candidateReadable);
+        if (!stableTaken && !readableTaken) {
+            // This slot is available
+            const name = canBeStable ? candidateStable : candidateReadable;
+            return { name, nextIndex: index + 1 };
+        }
+        index++;
+    }
+};
+/**
+ * Collects rename operations and applies them with automatic stability logic.
+ *
+ * Usage:
+ * ```typescript
+ * const group = new RenameGroup();
+ *
+ * // Collect renames during traversal
+ * group.add({ scope: path.scope, currentName: "a", baseName: "timeoutId" });
+ * group.add({ scope: path.scope, currentName: "b", baseName: "timeoutId" });
+ *
+ * // Apply with automatic stability
+ * const count = group.apply();
+ * // Result: a → timeoutId, b → timeoutId2 (readable, 2+ unstable)
+ * // Or if only one: a → $timeoutId (stable, exactly 1 unstable)
+ * ```
+ *
+ * Stability rules (per scope, per baseName):
+ * - If exactly 1 unstable variable wants this name → stable (`$baseName`)
+ * - If 2+ unstable variables want the same name → readable only (`baseName`, `baseName2`, ...)
+ */
+export class RenameGroup {
+    entries = [];
+    /**
+     * Add a variable to be renamed.
+     * Already-stable names (starting with $) are automatically skipped.
+     */
+    add(entry) {
+        if (isStableRenamed(entry.currentName))
+            return;
+        this.entries.push(entry);
+    }
+    /**
+     * Apply all collected renames with automatic stability logic.
+     * Returns the number of transformations applied.
+     */
+    apply() {
+        // Group entries by (scope, baseName) using a two-level Map
+        const scopeGroups = new Map();
+        for (const entry of this.entries) {
+            let baseNameMap = scopeGroups.get(entry.scope);
+            if (!baseNameMap) {
+                baseNameMap = new Map();
+                scopeGroups.set(entry.scope, baseNameMap);
+            }
+            let group = baseNameMap.get(entry.baseName);
+            if (!group) {
+                group = [];
+                baseNameMap.set(entry.baseName, group);
+            }
+            group.push(entry);
+        }
+        let transformationsApplied = 0;
+        // Process each scope
+        for (const [scope, baseNameMap] of scopeGroups) {
+            // Process each baseName group within this scope
+            for (const [baseName, group] of baseNameMap) {
+                // Determine if names can be stable (only 1 unstable entry for this baseName)
+                const canBeStable = group.length === 1;
+                // Track which index to try next
+                let index = 1;
+                for (const entry of group) {
+                    // Find next available name slot
+                    const targetName = findAvailableName(scope, baseName, index, canBeStable);
+                    index = targetName.nextIndex;
+                    if (entry.currentName !== targetName.name) {
+                        scope.rename(entry.currentName, targetName.name);
+                        transformationsApplied++;
+                    }
+                }
+            }
+        }
+        return transformationsApplied;
+    }
+}

package/dist/scripts/evaluate/check-expected-evaluations.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import { allTransformIds } from "../../transforms/transform-registry.js";
 import { transformRegistry } from "../../transforms/transform-registry.js";
+import { transformPresets } from "../../transforms/transform-presets.js";
 import { parseTransformManifest } from "./parse-transform-manifest.js";
 import { checkAllSnapshots } from "./check-snapshots.js";
 export const checkExpectedEvaluations = async (options) => {
@@ -24,6 +25,7 @@ export const checkExpectedEvaluations = async (options) => {
         testCasesDirectory,
         transformIds,
         transformRegistry,
+        recommendedTransformIds: transformPresets.recommended,
     });
     const allPresent = missingManifestEntries.length === 0 && snapshotIssues.length === 0;
     return {

package/dist/scripts/evaluate/check-recommended-snapshot.d.ts

@@ -0,0 +1,11 @@
+import type { Transform } from "../../core/types.js";
+import type { SnapshotIssue } from "./check-snapshots.js";
+type CheckRecommendedSnapshotOptions = {
+    basePath: string;
+    baseContent: string;
+    snapshotPath: string;
+    testCaseName: string;
+    transforms: Transform[];
+};
+export declare const checkRecommendedSnapshot: (options: CheckRecommendedSnapshotOptions) => Promise<SnapshotIssue | undefined>;
+export {};

package/dist/scripts/evaluate/check-recommended-snapshot.js

@@ -0,0 +1,53 @@
+import * as fs from "node:fs/promises";
+import * as prettier from "prettier";
+import { transformContentWithMultiple } from "./transform-content.js";
+const formatCode = async (code) => {
+    return prettier.format(code, { parser: "babel" });
+};
+const fileExists = async (filePath) => {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+export const checkRecommendedSnapshot = async (options) => {
+    const { basePath, baseContent, snapshotPath, testCaseName, transforms } = options;
+    const snapshotExists = await fileExists(snapshotPath);
+    // Run all recommended transforms to get the output
+    const result = await transformContentWithMultiple({
+        content: baseContent,
+        filePath: basePath,
+        transforms,
+    });
+    if (!result.ok) {
+        // Transform failed, skip this check
+        return undefined;
+    }
+    const formattedOutput = await formatCode(result.output);
+    if (snapshotExists) {
+        const snapshotContent = await fs.readFile(snapshotPath, "utf8");
+        const formattedSnapshot = await formatCode(snapshotContent);
+        // Check if snapshot is outdated (recommended snapshots are never "unnecessary")
+        if (formattedOutput !== formattedSnapshot) {
+            return {
+                transformId: "recommended",
+                testCase: testCaseName,
+                snapshotPath,
+                issue: "outdated",
+            };
+        }
+    }
+    else {
+        // Snapshot doesn't exist - it's always required for recommended
+        return {
+            transformId: "recommended",
+            testCase: testCaseName,
+            snapshotPath,
+            issue: "missing-required",
+        };
+    }
+    return undefined;
+};

package/dist/scripts/evaluate/check-snapshots.d.ts

@@ -9,6 +9,7 @@ type CheckAllSnapshotsOptions = {
     testCasesDirectory: string;
     transformIds: string[];
     transformRegistry: Record<string, Transform>;
+    recommendedTransformIds: string[];
 };
 export declare const checkAllSnapshots: (options: CheckAllSnapshotsOptions) => Promise<SnapshotIssue[]>;
 export {};

package/dist/scripts/evaluate/check-snapshots.js

@@ -1,7 +1,9 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import * as prettier from "prettier";
+import { normalizeCode } from "../../core/normalize-code.js";
 import { transformContent } from "./transform-content.js";
+import { checkRecommendedSnapshot } from "./check-recommended-snapshot.js";
 const formatCode = async (code) => {
     return prettier.format(code, { parser: "babel" });
 };
@@ -84,13 +86,18 @@ const getTestCaseNames = async (testCasesDirectory) => {
     return testCaseNames.toSorted();
 };
 export const checkAllSnapshots = async (options) => {
-    const { testCasesDirectory, transformIds, transformRegistry } = options;
+    const { testCasesDirectory, transformIds, transformRegistry, recommendedTransformIds, } = options;
     const snapshotIssues = [];
     const testCaseNames = await getTestCaseNames(testCasesDirectory);
+    // Get the recommended transforms in order
+    const recommendedTransforms = recommendedTransformIds
+        .map((id) => transformRegistry[id])
+        .filter((t) => t !== undefined);
     for (const testCaseName of testCaseNames) {
         const basePath = path.join(testCasesDirectory, testCaseName, "base.js");
         const baseContent = await fs.readFile(basePath, "utf8");
-        const formattedBase = await formatCode(baseContent);
+        const formattedBase = await normalizeCode(baseContent);
+        // Check individual transform snapshots
         for (const transformId of transformIds) {
             const snapshotPath = path.join(testCasesDirectory, testCaseName, `${transformId}.js`);
             const issue = await checkSnapshot({
@@ -106,6 +113,18 @@ export const checkAllSnapshots = async (options) => {
                 snapshotIssues.push(issue);
             }
         }
+        // Check recommended snapshot (always required)
+        const recommendedSnapshotPath = path.join(testCasesDirectory, testCaseName, "recommended.js");
+        const recommendedIssue = await checkRecommendedSnapshot({
+            basePath,
+            baseContent,
+            snapshotPath: recommendedSnapshotPath,
+            testCaseName,
+            transforms: recommendedTransforms,
+        });
+        if (recommendedIssue) {
+            snapshotIssues.push(recommendedIssue);
+        }
     }
     return snapshotIssues;
 };

package/dist/scripts/evaluate/transform-content.d.ts

@@ -11,4 +11,9 @@ export declare const transformContent: (options: {
     filePath: string;
     transform: Transform;
 }) => Promise<TransformContentResult>;
+export declare const transformContentWithMultiple: (options: {
+    content: string;
+    filePath: string;
+    transforms: Transform[];
+}) => Promise<TransformContentResult>;
 export {};

package/dist/scripts/evaluate/transform-content.js

@@ -2,24 +2,34 @@ import { buildProjectGraph } from "../../core/project-graph.js";
 import { generateCode } from "../../cli/generate-code.js";
 export const transformContent = async (options) => {
     const { content, filePath, transform } = options;
+    return transformContentWithMultiple({
+        content,
+        filePath,
+        transforms: [transform],
+    });
+};
+export const transformContentWithMultiple = async (options) => {
+    const { content, filePath, transforms } = options;
     const projectGraph = buildProjectGraph([{ path: filePath, content }]);
     const file = projectGraph.files.get(filePath);
     if (!file) {
         return { ok: false, error: "Failed to parse input" };
     }
-    try {
-        await transform.transform({
-            projectGraph,
-            currentFile: undefined,
-            options: {},
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            ok: false,
-            error: `Transform '${transform.id}' failed: ${message}`,
-        };
+    for (const transform of transforms) {
+        try {
+            await transform.transform({
+                projectGraph,
+                currentFile: undefined,
+                options: {},
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                error: `Transform '${transform.id}' failed: ${message}`,
+            };
+        }
     }
     const generated = generateCode(file.ast);
     const output = generated === ""

package/dist/transforms/rename-catch-parameters/rename-catch-parameters-transform.js

@@ -1,63 +1,40 @@
 import { createRequire } from "node:module";
+import { isStableRenamed, RenameGroup } from "../../core/stable-naming.js";
 import { getFilesToProcess, } from "../../core/types.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
 const traverse = require("@babel/traverse").default;
 const BASE_NAME = "caughtError";
-const getRenamedAncestorCatchCount = (path, renamedCatches) => {
-    let count = 0;
-    for (const ancestor of path.getAncestry()) {
-        if (ancestor === path)
-            continue;
-        if (!ancestor.isCatchClause())
-            continue;
-        if (renamedCatches.has(ancestor.node))
-            count++;
-    }
-    return count;
-};
-const getTargetCaughtErrorName = (renamedAncestorCatchCount) => {
-    if (renamedAncestorCatchCount === 0)
-        return BASE_NAME;
-    return `${BASE_NAME}${renamedAncestorCatchCount + 1}`;
-};
-const getCatchParameterNameIfEligible = (path) => {
-    const parameter = path.node.param;
-    if (!parameter)
-        return;
-    if (parameter.type !== "Identifier")
-        return;
-    if (parameter.name.length > 2)
-        return;
-    return parameter.name;
-};
 export const renameCatchParametersTransform = {
     id: "rename-catch-parameters",
-    description: "Renames minified catch clause parameters to caughtError/caughtError2/...",
+    description: "Renames catch clause parameters to $caughtError/$caughtError2/...",
     scope: "file",
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
         let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
-            const renamedCatches = new WeakMap();
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 CatchClause(path) {
                     nodesVisited++;
-                    const currentName = getCatchParameterNameIfEligible(path);
-                    if (!currentName)
+                    const parameter = path.node.param;
+                    if (!parameter)
                         return;
-                    const renamedAncestorCatchCount = getRenamedAncestorCatchCount(path, renamedCatches);
-                    const targetName = getTargetCaughtErrorName(renamedAncestorCatchCount);
-                    if (currentName === targetName)
+                    if (parameter.type !== "Identifier")
                         return;
-                    if (path.scope.hasBinding(targetName))
+                    const currentName = parameter.name;
+                    // Skip already-stable names
+                    if (isStableRenamed(currentName))
                         return;
-                    path.scope.rename(currentName, targetName);
-                    renamedCatches.set(path.node, targetName);
-                    transformationsApplied++;
+                    group.add({
+                        scope: path.scope,
+                        currentName,
+                        baseName: BASE_NAME,
+                    });
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({
             nodesVisited,

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

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
 import { isIdentifierName, isKeyword, isStrictBindReservedWord, } from "@babel/helper-validator-identifier";
 import { getFilesToProcess, } from "../../core/types.js";
+import { RenameGroup } from "../../core/stable-naming.js";
 import { isBindingContext } from "./binding-context.js";
 const require = createRequire(import.meta.url);
 // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
@@ -22,7 +23,7 @@ const isValidBindingIdentifier = (name) => {
         return false;
     return true;
 };
-const processObjectPattern = (path, stats) => {
+const processObjectPattern = (path, group) => {
     // Only process in binding contexts, not assignment expressions
     if (!isBindingContext(path))
         return;
@@ -84,14 +85,12 @@ const processObjectPattern = (path, stats) => {
             referencePath.scope.hasBinding(keyName));
         if (wouldBeShadowed)
             continue;
-        // Rename the variable in the scope
-        bindingScope.rename(aliasName, keyName);
-        // Update the destructuring to use shorthand
-        // For { a: b } -> { a }
-        // For { a: b = 1 } -> { a = 1 }
-        property.shorthand = true;
-        aliasIdentifier.name = keyName;
-        stats.transformationsApplied++;
+        // Add to rename group for batch processing with stability logic
+        group.add({
+            scope: bindingScope,
+            currentName: aliasName,
+            baseName: keyName,
+        });
     }
 };
 export const renameDestructuredAliasesTransform = {
@@ -101,18 +100,20 @@ export const renameDestructuredAliasesTransform = {
     parallelizable: true,
     transform(context) {
         let nodesVisited = 0;
-        const stats = { transformationsApplied: 0 };
+        let transformationsApplied = 0;
         for (const fileInfo of getFilesToProcess(context)) {
+            const group = new RenameGroup();
             traverse(fileInfo.ast, {
                 ObjectPattern(path) {
                     nodesVisited++;
-                    processObjectPattern(path, stats);
+                    processObjectPattern(path, group);
                 },
             });
+            transformationsApplied += group.apply();
         }
         return Promise.resolve({
             nodesVisited,
-            transformationsApplied: stats.transformationsApplied,
+            transformationsApplied,
         });
     },
 };

package/dist/transforms/rename-event-parameters/process-event-handler-function.d.ts

@@ -1,5 +1,4 @@
 import type { NodePath } from "@babel/traverse";
 import type { ArrowFunctionExpression, FunctionDeclaration, FunctionExpression } from "@babel/types";
-export declare const processEventHandlerFunction: (path: NodePath<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression>, stats: {
-    transformationsApplied: number;
-}) => void;
+import { type RenameGroup } from "../../core/stable-naming.js";
+export declare const processEventHandlerFunction: (path: NodePath<FunctionDeclaration | FunctionExpression | ArrowFunctionExpression>, group: RenameGroup) => void;

package/dist/transforms/rename-event-parameters/process-event-handler-function.js

@@ -1,3 +1,4 @@
+import { isStableRenamed } from "../../core/stable-naming.js";
 import { getEventParameterUsage, isHighConfidenceEventParameter, } from "./event-parameter-usage.js";
 import { getTargetEventName } from "./get-target-event-name.js";
 import { canRenameBindingSafely } from "./can-rename-binding-safely.js";
@@ -23,7 +24,7 @@ const wouldShadowReferencedImplicitGlobal = (functionPath, targetName) => {
     });
     return foundReference;
 };
-export const processEventHandlerFunction = (path, stats) => {
+export const processEventHandlerFunction = (path, group) => {
     const parameters = path.node.params;
     if (parameters.length !== 1)
         return;
@@ -32,12 +33,12 @@ export const processEventHandlerFunction = (path, stats) => {
         return;
     if (parameter.type !== "Identifier")
         return;
-    // 1-2 character parameter names are a strong minification signal (e.g. `e`, `t`, `WA`).
-    // Keeping this conservative avoids renaming common intentional abbreviations (e.g. `evt`).
-    if (parameter.name.length > 2)
+    const currentName = parameter.name;
+    // Skip already-stable names
+    if (isStableRenamed(currentName))
         return;
     const bindingScope = path.scope;
-    const binding = bindingScope.getBinding(parameter.name);
+    const binding = bindingScope.getBinding(currentName);
     if (!binding)
         return;
     if (!binding.constant)
@@ -46,14 +47,17 @@ export const processEventHandlerFunction = (path, stats) => {
     if (!isHighConfidenceEventParameter(usage))
         return;
     const targetName = getTargetEventName(usage);
-    if (parameter.name === targetName)
+    if (currentName === targetName)
         return;
     if (wouldShadowReferencedImplicitGlobal(path, targetName))
         return;
     if (wouldShadowReferencedOuterBinding(path, targetName))
         return;
-    if (!canRenameBindingSafely(bindingScope, parameter.name, targetName))
+    if (!canRenameBindingSafely(bindingScope, currentName, targetName))
         return;
-    bindingScope.rename(parameter.name, targetName);
-    stats.transformationsApplied++;
+    group.add({
+        scope: bindingScope,
+        currentName,
+        baseName: targetName,
+    });
 };

package/dist/transforms/rename-event-parameters/rename-event-parameters-transform.d.ts

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