miniread 1.16.0 → 1.18.0

package/dist/scripts/snapshot/format-code.d.ts

@@ -0,0 +1 @@
+export declare const formatCode: (code: string) => Promise<string>;

package/dist/scripts/snapshot/format-code.js

@@ -0,0 +1,4 @@
+import * as prettier from "prettier";
+export const formatCode = async (code) => {
+    return prettier.format(code, { parser: "babel" });
+};

package/dist/scripts/snapshot/print-snapshot-diff.d.ts

@@ -0,0 +1,6 @@
+type PrintSnapshotDiffOptions = {
+    expectedContent: string;
+    actualOutput: string;
+};
+export declare const printSnapshotDiff: (options: PrintSnapshotDiffOptions) => void;
+export {};

package/dist/scripts/snapshot/print-snapshot-diff.js

@@ -0,0 +1,26 @@
+export const printSnapshotDiff = (options) => {
+    const { expectedContent, actualOutput } = options;
+    console.log(`\nDiff: expected vs actual`);
+    console.log("---");
+    const expectedLines = expectedContent.split("\n");
+    const actualLines = actualOutput.split("\n");
+    const maxLines = Math.max(expectedLines.length, actualLines.length);
+    for (let lineIndex = 0; lineIndex < maxLines; lineIndex++) {
+        const expectedLine = expectedLines[lineIndex];
+        const actualLine = actualLines[lineIndex];
+        if (expectedLine === actualLine)
+            continue;
+        console.log(`Line ${lineIndex + 1}:`);
+        if (expectedLine !== undefined && actualLine === undefined) {
+            console.log(`  - ${expectedLine}`);
+            continue;
+        }
+        if (expectedLine === undefined && actualLine !== undefined) {
+            console.log(`  + ${actualLine}`);
+            continue;
+        }
+        console.log(`  - ${expectedLine}`);
+        console.log(`  + ${actualLine}`);
+    }
+    console.log("---");
+};

package/dist/scripts/snapshot/resolve-testcase-input.d.ts

@@ -0,0 +1,16 @@
+type ResolveTestcaseInputOptions = {
+    testcase: string;
+};
+type ResolveTestcaseInputValue = {
+    testcaseDirectory: string;
+    basePath: string;
+};
+type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: Error;
+};
+export declare const resolveTestcaseInput: (options: ResolveTestcaseInputOptions) => Promise<Result<ResolveTestcaseInputValue>>;
+export {};

package/dist/scripts/snapshot/resolve-testcase-input.js

@@ -0,0 +1,30 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+const TEST_CASES_DIR = path.resolve(import.meta.dirname, "../../../test-cases");
+export const resolveTestcaseInput = async (options) => {
+    const { testcase } = options;
+    const testcaseDirectory = path.join(TEST_CASES_DIR, testcase);
+    try {
+        const stats = await fs.stat(testcaseDirectory);
+        if (!stats.isDirectory()) {
+            return { ok: false, error: new Error(`${testcase} is not a directory`) };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            error: new Error(`Test case directory not found: test-cases/${testcase}`),
+        };
+    }
+    const basePath = path.join(testcaseDirectory, "base.js");
+    try {
+        await fs.access(basePath);
+    }
+    catch {
+        return {
+            ok: false,
+            error: new Error(`base.js not found in test-cases/${testcase}/`),
+        };
+    }
+    return { ok: true, value: { testcaseDirectory, basePath } };
+};

package/dist/scripts/snapshot/run-snapshot-cli.js

@@ -1,75 +1,39 @@
 import * as fs from "node:fs/promises";
-import { createRequire } from "node:module";
 import path from "node:path";
-import * as prettier from "prettier";
 import packageJson from "../../../package.json" with { type: "json" };
-import { buildProjectGraph } from "../../core/project-graph.js";
-import { transformPresets } from "../../transforms/transform-presets.js";
-import { transformRegistry } from "../../transforms/transform-registry.js";
+import { formatCode } from "./format-code.js";
 import { createSnapshotCommand, } from "./create-snapshot-command.js";
-const require = createRequire(import.meta.url);
-// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-const generate = require("@babel/generator").default;
-const TEST_CASES_DIR = path.resolve(import.meta.dirname, "../../../test-cases");
-const formatCode = async (code) => prettier.format(code, { parser: "babel" });
-const runTransform = async (inputPath, transformId) => {
-    const content = await fs.readFile(inputPath, "utf8");
-    // Handle "recommended" as a special case that runs all recommended transforms
-    const transformIds = transformId === "recommended"
-        ? transformPresets.recommended
-        : [transformId];
-    const transforms = transformIds.map((id) => {
-        const transform = transformRegistry[id];
-        if (!transform) {
-            throw new Error(`Unknown transform: ${id}. Run 'miniread --list-transforms' to see available transforms.`);
-        }
-        return transform;
-    });
-    const projectGraph = buildProjectGraph([{ path: inputPath, content }]);
-    for (const transform of transforms) {
-        await transform.transform({
-            projectGraph,
-            currentFile: undefined,
-            options: {},
-        });
-    }
-    const fileInfo = projectGraph.files.get(inputPath);
-    if (!fileInfo) {
-        return content;
-    }
-    return generate(fileInfo.ast).code;
-};
+import { printSnapshotDiff } from "./print-snapshot-diff.js";
+import { resolveTestcaseInput } from "./resolve-testcase-input.js";
+import { runTestcaseTransform } from "./run-testcase-transform.js";
 export const runSnapshotCli = async (argv) => {
     const program = createSnapshotCommand({ version: packageJson.version });
     program.parse(argv.filter((argument) => argument !== "--"));
     const rawOptions = program.opts();
     const { testcase, transform, expected } = rawOptions;
-    // Validate test case directory exists
-    const testCaseDirectory = path.join(TEST_CASES_DIR, testcase);
-    try {
-        const stats = await fs.stat(testCaseDirectory);
-        if (!stats.isDirectory()) {
-            console.error(`Error: ${testcase} is not a directory`);
+    const resolved = await resolveTestcaseInput({ testcase });
+    if (!resolved.ok) {
+        const message = resolved.error.message;
+        if (message === `${testcase} is not a directory`) {
+            console.error(`Error: ${message}`);
             return 1;
         }
-    }
-    catch {
-        console.error(`Error: Test case directory not found: test-cases/${testcase}`);
-        console.error(`Create it first: mkdir -p test-cases/${testcase}`);
-        return 1;
-    }
-    // Validate base.js exists
-    const basePath = path.join(testCaseDirectory, "base.js");
-    try {
-        await fs.access(basePath);
-    }
-    catch {
-        console.error(`Error: base.js not found in test-cases/${testcase}/`);
-        console.error(`Create test-cases/${testcase}/base.js with your minified snippet first.`);
+        if (message.startsWith("Test case directory not found:")) {
+            console.error(`Error: ${message}`);
+            console.error(`Create it first: mkdir -p test-cases/${testcase}`);
+            return 1;
+        }
+        if (message.startsWith("base.js not found in test-cases/")) {
+            console.error(`Error: ${message}`);
+            console.error(`Create test-cases/${testcase}/base.js with your minified snippet first.`);
+            return 1;
+        }
+        console.error(`Error: ${message}`);
         return 1;
     }
-    const expectedPath = path.join(testCaseDirectory, `${transform}-expected.js`);
-    const actualPath = path.join(testCaseDirectory, `${transform}.js`);
+    const { testcaseDirectory, basePath } = resolved.value;
+    const expectedPath = path.join(testcaseDirectory, `${transform}-expected.js`);
+    const actualPath = path.join(testcaseDirectory, `${transform}.js`);
     if (expected) {
         // Expected-file workflow
         // Step 1: Check if expected file exists, create from base.js if not
@@ -83,69 +47,53 @@ export const runSnapshotCli = async (argv) => {
             await fs.writeFile(expectedPath, formattedBase);
             console.log(`Created: test-cases/${testcase}/${transform}-expected.js`);
             console.log("Edit this file to match your expected output, then re-run.");
+            // Design phase: allow creating the expected file before the transform exists.
+            // The next run (after implementing the transform) will write the actual output
+            // and compare it against this expected snapshot.
             return 0;
         }
-    }
-    // Common path: Run the transform, format, and write actual output
-    let actualOutput;
-    try {
-        const rawOutput = await runTransform(basePath, transform);
-        actualOutput = await formatCode(rawOutput);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        console.error(`Error running transform: ${message}`);
-        return 1;
-    }
-    await fs.writeFile(actualPath, actualOutput);
-    console.log(`Created: test-cases/${testcase}/${transform}.js`);
-    if (!expected) {
-        return 0;
-    }
-    // Step 3: Compare expected vs actual
-    const expectedContent = await fs.readFile(expectedPath, "utf8");
-    if (expectedContent === actualOutput) {
-        // Success! Delete expected file
-        await fs.unlink(expectedPath);
-        console.log(`\nSuccess: Output matches expected.`);
-        console.log(`Deleted: test-cases/${testcase}/${transform}-expected.js`);
-        console.log(`\nSnapshot ready: test-cases/${testcase}/${transform}.js`);
-        return 0;
-    }
-    // Diff - show the difference
-    console.log(`\nDiff: expected vs actual`);
-    console.log("---");
-    // Simple line-by-line diff output
-    const expectedLines = expectedContent.split("\n");
-    const actualLines = actualOutput.split("\n");
-    const maxLines = Math.max(expectedLines.length, actualLines.length);
-    let hasDiff = false;
-    for (let lineIndex = 0; lineIndex < maxLines; lineIndex++) {
-        const exp = expectedLines[lineIndex];
-        const act = actualLines[lineIndex];
-        if (exp !== act) {
-            hasDiff = true;
-            if (exp !== undefined && act === undefined) {
-                console.log(`Line ${lineIndex + 1}:`);
-                console.log(`  - ${exp}`);
-            }
-            else if (exp === undefined && act !== undefined) {
-                console.log(`Line ${lineIndex + 1}:`);
-                console.log(`  + ${act}`);
-            }
-            else {
-                console.log(`Line ${lineIndex + 1}:`);
-                console.log(`  - ${exp}`);
-                console.log(`  + ${act}`);
-            }
+        const outputResult = await runTestcaseTransform({
+            inputPath: basePath,
+            transformId: transform,
+        });
+        if (!outputResult.ok) {
+            console.error(`Error running transform: ${outputResult.error.message}`);
+            return 1;
+        }
+        const actualOutput = outputResult.value;
+        // Step 2: Write actual output
+        await fs.writeFile(actualPath, actualOutput);
+        console.log(`Created: test-cases/${testcase}/${transform}.js`);
+        // Step 3: Compare expected vs actual
+        const expectedContent = await fs.readFile(expectedPath, "utf8");
+        if (expectedContent === actualOutput) {
+            // Success! Delete expected file
+            await fs.unlink(expectedPath);
+            console.log(`\nSuccess: Output matches expected.`);
+            console.log(`Deleted: test-cases/${testcase}/${transform}-expected.js`);
+            console.log(`\nSnapshot ready: test-cases/${testcase}/${transform}.js`);
+            return 0;
+        }
+        else {
+            printSnapshotDiff({ expectedContent, actualOutput });
+            console.log(`\nExpected file preserved: test-cases/${testcase}/${transform}-expected.js`);
+            console.log("Fix the implementation or update the expected file, then re-run.");
+            return 1;
         }
     }
-    if (!hasDiff) {
-        // Shouldn't happen since we already checked equality, but just in case
-        console.log("(no visible differences)");
+    else {
+        const outputResult = await runTestcaseTransform({
+            inputPath: basePath,
+            transformId: transform,
+        });
+        if (!outputResult.ok) {
+            console.error(`Error running transform: ${outputResult.error.message}`);
+            return 1;
+        }
+        const actualOutput = outputResult.value;
+        // Simple mode: just write actual output
+        await fs.writeFile(actualPath, actualOutput);
+        console.log(`Created: test-cases/${testcase}/${transform}.js`);
+        return 0;
     }
-    console.log("---");
-    console.log(`\nExpected file preserved: test-cases/${testcase}/${transform}-expected.js`);
-    console.log("Fix the implementation or update the expected file, then re-run.");
-    return 1;
 };

package/dist/scripts/snapshot/run-testcase-transform.d.ts

@@ -0,0 +1,13 @@
+type Result<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: Error;
+};
+type RunTestcaseTransformOptions = {
+    inputPath: string;
+    transformId: string;
+};
+export declare const runTestcaseTransform: (options: RunTestcaseTransformOptions) => Promise<Result<string>>;
+export {};

package/dist/scripts/snapshot/run-testcase-transform.js

@@ -0,0 +1,46 @@
+import { createRequire } from "node:module";
+import * as fs from "node:fs/promises";
+import { buildProjectGraph } from "../../core/project-graph.js";
+import { transformPresets } from "../../transforms/transform-presets.js";
+import { transformRegistry } from "../../transforms/transform-registry.js";
+import { formatCode } from "./format-code.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const generate = require("@babel/generator").default;
+const runTransform = async (inputPath, transformId) => {
+    const content = await fs.readFile(inputPath, "utf8");
+    const transformIds = transformId === "recommended"
+        ? transformPresets.recommended
+        : [transformId];
+    const transforms = transformIds.map((id) => {
+        const transform = transformRegistry[id];
+        if (!transform) {
+            throw new Error(`Unknown transform: ${id}. Run 'miniread --list-transforms' to see available transforms.`);
+        }
+        return transform;
+    });
+    const projectGraph = buildProjectGraph([{ path: inputPath, content }]);
+    for (const transform of transforms) {
+        await transform.transform({
+            projectGraph,
+            currentFile: undefined,
+            options: {},
+        });
+    }
+    const fileInfo = projectGraph.files.get(inputPath);
+    if (!fileInfo)
+        return content;
+    return generate(fileInfo.ast).code;
+};
+export const runTestcaseTransform = async (options) => {
+    const { inputPath, transformId } = options;
+    try {
+        const rawOutput = await runTransform(inputPath, transformId);
+        const output = await formatCode(rawOutput);
+        return { ok: true, value: output };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { ok: false, error: new Error(message) };
+    }
+};

package/dist/transforms/rename-charcode-variables/rename-charcode-variables-transform.d.ts

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

package/dist/transforms/rename-charcode-variables/rename-charcode-variables-transform.js

@@ -0,0 +1,67 @@
+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 = "charCode";
+/**
+ * Detects if the init is a call to .charCodeAt()
+ * e.g., `var a = str.charCodeAt(0)`
+ */
+const isCharCodeAtCall = (path) => {
+    const init = path.node.init;
+    if (init?.type !== "CallExpression")
+        return false;
+    const callee = init.callee;
+    if (callee.type !== "MemberExpression")
+        return false;
+    const property = callee.property;
+    if (property.type !== "Identifier")
+        return false;
+    if (property.name !== "charCodeAt")
+        return false;
+    // If charCodeAt is accessed via computed property, skip
+    if (callee.computed)
+        return false;
+    return true;
+};
+export const renameCharcodeVariablesTransform = {
+    id: "rename-charcode-variables",
+    description: "Renames variables assigned from .charCodeAt() to $charCode or charCode/charCode2/...",
+    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, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    // Skip already-stable names
+                    if (isStableRenamed(id.name))
+                        return;
+                    if (!isCharCodeAtCall(path))
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    // Skip if the variable is reassigned
+                    if (!binding.constant)
+                        return;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName: BASE_NAME,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/rename-charcode-variables-v2/rename-charcode-variables-v2-transform.d.ts

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

package/dist/transforms/rename-charcode-variables-v2/rename-charcode-variables-v2-transform.js

@@ -0,0 +1,135 @@
+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;
+/**
+ * Capitalizes the first letter of a string.
+ */
+const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+const MAX_RECURSION_DEPTH = 5;
+/**
+ * Converts a charCodeAt argument expression to a suffix for the variable name.
+ * Returns undefined if the expression is too complex to represent.
+ *
+ * Examples:
+ * - `0` → "0"
+ * - `index` → "Index"
+ * - `index + 1` → "IndexPlus1"
+ * - `i` → "I"
+ * - `pos` → "Pos"
+ */
+const getArgumentSuffix = (expression, depth = 0) => {
+    // Prevent stack overflow from deeply nested expressions
+    if (depth > MAX_RECURSION_DEPTH)
+        return undefined;
+    // Numeric literal: charCodeAt(0) → "0"
+    if (expression.type === "NumericLiteral") {
+        if (Number.isInteger(expression.value) && expression.value >= 0) {
+            return String(expression.value);
+        }
+        return undefined;
+    }
+    // Identifier: charCodeAt(index) → "Index"
+    if (expression.type === "Identifier") {
+        return capitalize(expression.name);
+    }
+    // Binary expression with +: charCodeAt(index + 1) → "IndexPlus1"
+    if (expression.type === "BinaryExpression") {
+        // Skip if left is a PrivateName (can happen in class fields)
+        if (expression.left.type === "PrivateName")
+            return undefined;
+        if (expression.operator === "+") {
+            const leftSuffix = getArgumentSuffix(expression.left, depth + 1);
+            const rightSuffix = getArgumentSuffix(expression.right, depth + 1);
+            if (leftSuffix !== undefined && rightSuffix !== undefined) {
+                return `${leftSuffix}Plus${rightSuffix}`;
+            }
+        }
+        if (expression.operator === "-") {
+            const leftSuffix = getArgumentSuffix(expression.left, depth + 1);
+            const rightSuffix = getArgumentSuffix(expression.right, depth + 1);
+            if (leftSuffix !== undefined && rightSuffix !== undefined) {
+                return `${leftSuffix}Minus${rightSuffix}`;
+            }
+        }
+    }
+    return undefined;
+};
+/**
+ * Detects if the init is a call to .charCodeAt() and extracts the argument.
+ * Returns the argument expression if valid, undefined otherwise.
+ */
+const getCharCodeAtArgument = (path) => {
+    const init = path.node.init;
+    if (init?.type !== "CallExpression")
+        return undefined;
+    const callee = init.callee;
+    if (callee.type !== "MemberExpression")
+        return undefined;
+    const property = callee.property;
+    if (property.type !== "Identifier")
+        return undefined;
+    if (property.name !== "charCodeAt")
+        return undefined;
+    // If charCodeAt is accessed via computed property, skip
+    if (callee.computed)
+        return undefined;
+    // Must have exactly one argument
+    if (init.arguments.length !== 1)
+        return undefined;
+    const firstArgument = init.arguments[0];
+    if (!firstArgument)
+        return undefined;
+    if (firstArgument.type === "SpreadElement")
+        return undefined;
+    if (firstArgument.type === "ArgumentPlaceholder")
+        return undefined;
+    return firstArgument;
+};
+export const renameCharcodeVariablesV2Transform = {
+    id: "rename-charcode-variables-v2",
+    description: "Renames variables assigned from .charCodeAt(arg) to $charCodeAt{Arg} based on the argument",
+    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, {
+                VariableDeclarator(path) {
+                    nodesVisited++;
+                    const id = path.node.id;
+                    if (id.type !== "Identifier")
+                        return;
+                    // Skip already-stable names
+                    if (isStableRenamed(id.name))
+                        return;
+                    const argument = getCharCodeAtArgument(path);
+                    if (argument === undefined)
+                        return;
+                    const binding = path.scope.getBinding(id.name);
+                    if (!binding)
+                        return;
+                    // Skip if the variable is reassigned
+                    if (!binding.constant)
+                        return;
+                    // Try to derive a suffix from the argument
+                    const suffix = getArgumentSuffix(argument);
+                    if (suffix === undefined)
+                        return;
+                    const baseName = `charCodeAt${suffix}`;
+                    group.add({
+                        scope: path.scope,
+                        currentName: id.name,
+                        baseName,
+                    });
+                },
+            });
+            transformationsApplied += group.apply();
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/simplify-boolean-negations/simplify-boolean-negations-transform.d.ts

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

package/dist/transforms/simplify-boolean-negations/simplify-boolean-negations-transform.js

@@ -0,0 +1,90 @@
+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;
+const t = require("@babel/types");
+const isInBooleanTestContext = (path) => {
+    let current = path;
+    // A `!!x` node is safe to rewrite as `x` only when its value is consumed
+    // purely for truthiness (control-flow tests and boolean operator chains).
+    // If we encounter any other parent expression before reaching the test
+    // boundary, the expression value is being used (e.g. as a call argument),
+    // and rewriting would be unsafe.
+    for (;;) {
+        const parent = current.parentPath;
+        if (!parent)
+            return false;
+        if ((parent.isIfStatement() ||
+            parent.isWhileStatement() ||
+            parent.isDoWhileStatement() ||
+            parent.isForStatement() ||
+            parent.isConditionalExpression()) &&
+            current.key === "test") {
+            return true;
+        }
+        if (parent.isLogicalExpression()) {
+            if (current.key !== "left" && current.key !== "right")
+                return false;
+            current = parent;
+            continue;
+        }
+        if (parent.isUnaryExpression({ operator: "!" })) {
+            if (current.key !== "argument")
+                return false;
+            current = parent;
+            continue;
+        }
+        if (parent.isSequenceExpression()) {
+            if (current.listKey !== "expressions")
+                return false;
+            const expressions = parent.node.expressions;
+            const lastExpression = expressions.at(-1);
+            if (!lastExpression)
+                return false;
+            if (lastExpression !== current.node)
+                return false;
+            current = parent;
+            continue;
+        }
+        if (parent.isParenthesizedExpression()) {
+            if (current.key !== "expression")
+                return false;
+            current = parent;
+            continue;
+        }
+        return false;
+    }
+};
+export const simplifyBooleanNegationsTransform = {
+    id: "simplify-boolean-negations",
+    description: "Simplifies redundant boolean negations: !true/!false and !!x in control-flow tests",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            traverse(fileInfo.ast, {
+                UnaryExpression(path) {
+                    nodesVisited++;
+                    if (path.node.operator !== "!")
+                        return;
+                    const argument = path.node.argument;
+                    if (argument.type === "BooleanLiteral") {
+                        path.replaceWith(t.booleanLiteral(!argument.value));
+                        transformationsApplied++;
+                        return;
+                    }
+                    if (argument.type === "UnaryExpression" &&
+                        argument.operator === "!" &&
+                        isInBooleanTestContext(path)) {
+                        path.replaceWith(argument.argument);
+                        transformationsApplied++;
+                    }
+                },
+            });
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/transform-registry.js

@@ -5,23 +5,25 @@ import { expandSequenceExpressionsV5Transform } from "./expand-sequence-expressi
 import { expandUndefinedLiteralsTransform } from "./expand-undefined-literals/expand-undefined-literals-transform.js";
 import { removeRedundantElseTransform } from "./remove-redundant-else/remove-redundant-else-transform.js";
 import { renameCatchParametersTransform } from "./rename-catch-parameters/rename-catch-parameters-transform.js";
+import { renameCharCodeAtTransform } from "./rename-char-code-at/rename-char-code-at-transform.js";
+import { renameCharcodeVariablesTransform } from "./rename-charcode-variables/rename-charcode-variables-transform.js";
+import { renameCharcodeVariablesV2Transform } from "./rename-charcode-variables-v2/rename-charcode-variables-v2-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";
 import { renameLoopIndexVariablesV2Transform } from "./rename-loop-index-variables-v2/rename-loop-index-variables-v2-transform.js";
 import { renameLoopIndexVariablesV3Transform } from "./rename-loop-index-variables-v3/rename-loop-index-variables-v3-transform.js";
+import { renameParametersToMatchPropertiesTransform } from "./rename-parameters-to-match-properties/rename-parameters-to-match-properties-transform.js";
 import { renamePromiseExecutorParametersTransform } from "./rename-promise-executor-parameters/rename-promise-executor-parameters-transform.js";
 import { renameReplaceChildParametersTransform } from "./rename-replace-child-parameters/rename-replace-child-parameters-transform.js";
 import { renameThisAliasesTransform } from "./rename-this-aliases/rename-this-aliases-transform.js";
 import { renameTimeoutIdsTransform } from "./rename-timeout-ids/rename-timeout-ids-transform.js";
 import { renameUseReferenceGuardsTransform } from "./rename-use-reference-guards/rename-use-reference-guards-transform.js";
 import { renameUseReferenceGuardsV2Transform } from "./rename-use-reference-guards-v2/rename-use-reference-guards-v2-transform.js";
+import { simplifyBooleanNegationsTransform } from "./simplify-boolean-negations/simplify-boolean-negations-transform.js";
 import { splitVariableDeclarationsTransform } from "./split-variable-declarations/split-variable-declarations-transform.js";
-import { renameCharCodeAtTransform } from "./rename-char-code-at/rename-char-code-at-transform.js";
-import { renameParametersToMatchPropertiesTransform } from "./rename-parameters-to-match-properties/rename-parameters-to-match-properties-transform.js";
 export const transformRegistry = {
-    [renameCharCodeAtTransform.id]: renameCharCodeAtTransform,
     [expandBooleanLiteralsTransform.id]: expandBooleanLiteralsTransform,
     [expandSpecialNumberLiteralsTransform.id]: expandSpecialNumberLiteralsTransform,
     [expandSequenceExpressionsV4Transform.id]: expandSequenceExpressionsV4Transform,
@@ -29,19 +31,23 @@ export const transformRegistry = {
     [expandUndefinedLiteralsTransform.id]: expandUndefinedLiteralsTransform,
     [removeRedundantElseTransform.id]: removeRedundantElseTransform,
     [renameCatchParametersTransform.id]: renameCatchParametersTransform,
+    [renameCharCodeAtTransform.id]: renameCharCodeAtTransform,
+    [renameCharcodeVariablesTransform.id]: renameCharcodeVariablesTransform,
+    [renameCharcodeVariablesV2Transform.id]: renameCharcodeVariablesV2Transform,
     [renameComparisonFlagsTransform.id]: renameComparisonFlagsTransform,
     [renameDestructuredAliasesTransform.id]: renameDestructuredAliasesTransform,
     [renameEventParametersTransform.id]: renameEventParametersTransform,
     [renameLoopIndexVariablesTransform.id]: renameLoopIndexVariablesTransform,
     [renameLoopIndexVariablesV2Transform.id]: renameLoopIndexVariablesV2Transform,
     [renameLoopIndexVariablesV3Transform.id]: renameLoopIndexVariablesV3Transform,
+    [renameParametersToMatchPropertiesTransform.id]: renameParametersToMatchPropertiesTransform,
     [renamePromiseExecutorParametersTransform.id]: renamePromiseExecutorParametersTransform,
     [renameReplaceChildParametersTransform.id]: renameReplaceChildParametersTransform,
     [renameThisAliasesTransform.id]: renameThisAliasesTransform,
     [renameTimeoutIdsTransform.id]: renameTimeoutIdsTransform,
     [renameUseReferenceGuardsTransform.id]: renameUseReferenceGuardsTransform,
     [renameUseReferenceGuardsV2Transform.id]: renameUseReferenceGuardsV2Transform,
+    [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
-    [renameParametersToMatchPropertiesTransform.id]: renameParametersToMatchPropertiesTransform,
 };
 export const allTransformIds = Object.keys(transformRegistry);

package/package.json

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

package/transform-manifest.json

@@ -10,6 +10,15 @@
       "evaluatedAt": "2026-01-21T15:01:23.708Z",
       "notes": "Improves readability but does not reduce diffs (boolean literals are already deterministic)"
     },
+    {
+      "id": "simplify-boolean-negations",
+      "description": "Simplifies redundant boolean negations: !true/!false and !!x in control-flow tests",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "notes": "Added manually; improves readability and cleans up `expand-boolean-literals` output."
+    },
     {
       "id": "expand-undefined-literals",
       "description": "Expands void 0 to undefined (when undefined is not shadowed)",
@@ -219,6 +228,27 @@
       "diffReductionImpact": 0.00003774938185385768,
       "recommended": true,
       "notes": "Added manually based on high-confidence heuristic."
+    },
+    {
+      "id": "rename-charcode-variables",
+      "description": "Renames variables assigned from .charCodeAt() to $charCode or charCode/charCode2/...",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": false,
+      "evaluatedAt": "2026-01-23T17:59:00.000Z",
+      "notes": "Superseded by rename-charcode-variables-v2.",
+      "supersededBy": "rename-charcode-variables-v2"
+    },
+    {
+      "id": "rename-charcode-variables-v2",
+      "description": "Renames variables assigned from .charCodeAt(arg) to $charCodeAt{Arg} based on the argument",
+      "scope": "file",
+      "parallelizable": true,
+      "diffReductionImpact": 0,
+      "recommended": true,
+      "evaluatedAt": "2026-01-23T18:10:00.000Z",
+      "notes": "Derives names from charCodeAt argument for better stability (e.g., $charCodeAtIndex, $charCodeAtIndexPlus1)."
     }
   ],
   "presetStats": {