miniread 1.94.0 → 1.95.1

package/README.md

@@ -18,8 +18,11 @@ miniread --input ./minified --output ./readable --transforms recommended
 miniread --input ./minified --output ./readable --dry-run
 miniread --input ./minified --output ./readable --workers 8
 miniread --input ./minified --output ./readable --safe-stabilize-top-level-bindings
+miniread --input ./repo --output ./readable --ignore-dirs none
 ```
 
+When scanning an input directory, miniread ignores `.git`, `node_modules`, `coverage`, `.turbo`, and `.next` by default. `--ignore-dirs` replaces that default list (for example: `--ignore-dirs build,dist`), and `--ignore-dirs none` disables ignores entirely.
+
 ## Output stability
 
 The recommended preset includes `stabilize-top-level-bindings`, which renames program-scope bindings to stable hash-based names (`$h_<hash>`). This produces deterministic output across minifier versions, making diffs more useful.

package/dist/cli/create-program.d.ts

@@ -14,6 +14,7 @@ export declare const createProgram: (packageMetadata: PackageMetadata) => Comman
     format: ListFormat;
     dryRun?: true | undefined;
     workers: number;
+    ignoreDirs?: ReadonlySet<string> | undefined;
     overwrite?: true | undefined;
     safeStabilizeTopLevelBindings?: true | undefined;
 }, {}>;

package/dist/cli/create-program.js

@@ -1,4 +1,5 @@
 import { Command, InvalidArgumentError } from "@commander-js/extra-typings";
+import { parseIgnoredDirectories } from "./parse-ignored-directories.js";
 const parseListFormat = (value) => {
     if (value === "text" || value === "tsv" || value === "json")
         return value;
@@ -26,6 +27,7 @@ export const createProgram = (packageMetadata) => {
         .option("--format <format>", "Output format for --list-transforms: text, tsv, json", parseListFormat, "text")
         .option("--dry-run", "Show what would be changed without writing files")
         .option("-w, --workers <n>", "Number of parallel workers", parsePositiveInt, 4)
+        .option("--ignore-dirs <list>", "Comma-separated directory names to skip during --input directory scans. Replaces default ignores (.git,node_modules,coverage,.turbo,.next). Use 'none' to disable.", parseIgnoredDirectories)
         .option("-f, --overwrite", "Overwrite existing files in output directory")
         .option("--safe-stabilize-top-level-bindings", "Make stabilize-top-level-bindings bail out on dynamic-name hazards (safer; output more likely runnable)");
     program.addHelpText("after", `

package/dist/cli/find-input-files.d.ts

@@ -9,5 +9,8 @@ type FindInputFilesError = {
     errors: string[];
 };
 type FindInputFilesResult = FindInputFilesOk | FindInputFilesError;
-export declare const findInputFiles: (input: string) => Promise<FindInputFilesResult>;
+type FindInputFilesOptions = {
+    ignoredDirectories?: ReadonlySet<string>;
+};
+export declare const findInputFiles: (input: string, options?: FindInputFilesOptions) => Promise<FindInputFilesResult>;
 export {};

package/dist/cli/find-input-files.js

@@ -7,14 +7,34 @@ const isSourceFile = (fileName) => {
             fileName.endsWith(".js") ||
             fileName.endsWith(".jsx")));
 };
-const findAllFiles = async (directory) => {
+const ignoredDirectoryNames = new Set([
+    ".git",
+    "node_modules",
+    "coverage",
+    ".turbo",
+    ".next",
+]);
+const normalizeIgnoredDirectoryNames = (directoryNames) => {
+    const normalized = new Set();
+    for (const directoryName of directoryNames) {
+        const normalizedDirectoryName = directoryName.trim().toLowerCase();
+        if (normalizedDirectoryName === "")
+            continue;
+        normalized.add(normalizedDirectoryName);
+    }
+    return normalized;
+};
+const findAllFiles = async (directory, ignoredDirectories) => {
     const sourceFiles = [];
     const otherFiles = [];
     const entries = await fs.readdir(directory, { withFileTypes: true });
     for (const entry of entries) {
         const fullPath = path.join(directory, entry.name);
         if (entry.isDirectory()) {
-            const subResult = await findAllFiles(fullPath);
+            // Directory matching should be case-insensitive across filesystems.
+            if (ignoredDirectories.has(entry.name.toLowerCase()))
+                continue;
+            const subResult = await findAllFiles(fullPath, ignoredDirectories);
             sourceFiles.push(...subResult.sourceFiles);
             otherFiles.push(...subResult.otherFiles);
             continue;
@@ -29,7 +49,7 @@ const findAllFiles = async (directory) => {
     }
     return { sourceFiles, otherFiles };
 };
-export const findInputFiles = async (input) => {
+export const findInputFiles = async (input, options = {}) => {
     let inputStat;
     try {
         inputStat = await fs.stat(input);
@@ -40,9 +60,10 @@ export const findInputFiles = async (input) => {
     }
     let sourceFilePaths;
     let otherFilePaths;
+    const normalizedIgnoredDirectories = normalizeIgnoredDirectoryNames(options.ignoredDirectories ?? ignoredDirectoryNames);
     try {
         if (inputStat.isDirectory()) {
-            const allFiles = await findAllFiles(input);
+            const allFiles = await findAllFiles(input, normalizedIgnoredDirectories);
             sourceFilePaths = allFiles.sourceFiles;
             otherFilePaths = allFiles.otherFiles;
         }

package/dist/cli/parse-ignored-directories.d.ts

@@ -0,0 +1 @@
+export declare const parseIgnoredDirectories: (value: string) => ReadonlySet<string>;

package/dist/cli/parse-ignored-directories.js

@@ -0,0 +1,18 @@
+import { InvalidArgumentError } from "@commander-js/extra-typings";
+export const parseIgnoredDirectories = (value) => {
+    const normalizedValue = value.trim();
+    if (normalizedValue.toLowerCase() === "none") {
+        return new Set();
+    }
+    if (normalizedValue === "") {
+        throw new InvalidArgumentError("must not be empty; use 'none' to disable ignored directories");
+    }
+    const directories = normalizedValue
+        .split(",")
+        .map((directoryName) => directoryName.trim())
+        .filter((directoryName) => directoryName !== "");
+    if (directories.length === 0) {
+        throw new InvalidArgumentError("must contain at least one directory name or 'none'");
+    }
+    return new Set(directories);
+};

package/dist/cli/run-input-mode.js

@@ -25,6 +25,7 @@ export const runInputMode = async (options) => {
         input: options.input,
         output: options.output,
         transforms: transformsResult.transforms,
+        ignoredDirectories: options.ignoreDirs,
         transformOptions: {
             ...getDefaultTransformOptions(),
             unsafeStabilizeTopLevelBindings: shouldUnsafeStabilize(options.safeStabilizeTopLevelBindings),

package/dist/cli/run-transforms.d.ts

@@ -3,6 +3,7 @@ export type RunnerOptions = {
     input: string;
     output: string;
     transforms: Transform[];
+    ignoredDirectories?: ReadonlySet<string>;
     transformOptions?: Record<string, unknown>;
     dryRun: boolean;
     workers: number;

package/dist/cli/run-transforms.js

@@ -11,8 +11,8 @@ const logVerbose = (verbose, message) => {
     console.error(message);
 };
 export const runTransforms = async (options) => {
-    const { input, output, transforms, transformOptions = {}, dryRun, workers, overwrite, verbose, } = options;
-    const inputFilesResult = await findInputFiles(input);
+    const { input, output, transforms, ignoredDirectories, transformOptions = {}, dryRun, workers, overwrite, verbose, } = options;
+    const inputFilesResult = await findInputFiles(input, { ignoredDirectories });
     if (!inputFilesResult.ok) {
         return {
             filesProcessed: 0,

package/dist/transforms/_generated/manifest.js

@@ -162,7 +162,7 @@ const manifestData = {
     },
     "rename-execfile-arguments": {
         recommended: true,
-        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-04T12:56:34.513Z", "changedLines": 4, "durationSeconds": 163.50355117599997, "stableNames": 1359 } },
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100, "evaluatedAt": "2026-02-07T09:44:20.481Z", "changedLines": 4, "durationSeconds": 27.924432042, "stableNames": 1359 } },
     },
     "rename-file-extension-variables": {
         recommended: true,

package/dist/transforms/rename-execfile-arguments/detect-execfile-call.js

@@ -1,5 +1,6 @@
 import { isIdentifier } from "@babel/types";
 const CHILD_PROCESS_MODULES = new Set(["child_process", "node:child_process"]);
+const childProcessExecFileBindingCache = new WeakMap();
 export const getExecFileBindings = (pattern) => {
     if (pattern.elements.length !== 2)
         return undefined;
@@ -35,48 +36,57 @@ const isExecFileCallee = (call) => {
     return (callee.property.type === "Identifier" && callee.property.name === "execFile");
 };
 const isChildProcessExecFileBinding = (binding) => {
+    const cached = childProcessExecFileBindingCache.get(binding);
+    if (cached !== undefined)
+        return cached;
     const bindingPath = binding.path;
+    let isMatch = false;
     // ESM: import { execFile } from 'child_process'
     if (bindingPath.isImportSpecifier()) {
         const importDeclaration = bindingPath.parentPath;
-        if (!importDeclaration.isImportDeclaration())
-            return false;
-        if (!CHILD_PROCESS_MODULES.has(importDeclaration.node.source.value))
-            return false;
-        const imported = bindingPath.node.imported;
-        return imported.type === "Identifier" && imported.name === "execFile";
+        if (importDeclaration.isImportDeclaration() &&
+            CHILD_PROCESS_MODULES.has(importDeclaration.node.source.value)) {
+            const imported = bindingPath.node.imported;
+            isMatch = imported.type === "Identifier" && imported.name === "execFile";
+        }
+        childProcessExecFileBindingCache.set(binding, isMatch);
+        return isMatch;
     }
     // CJS: const { execFile } = require('child_process')
     // For CJS destructuring, Babel's binding path is the VariableDeclarator,
     // not an Identifier inside ObjectProperty.
     if (bindingPath.isVariableDeclarator()) {
         const declarator = bindingPath.node;
-        if (declarator.id.type !== "ObjectPattern")
-            return false;
-        const init = declarator.init;
-        if (init?.type !== "CallExpression")
-            return false;
-        if (init.callee.type !== "Identifier" || init.callee.name !== "require")
-            return false;
-        const source = init.arguments[0];
-        if (source?.type !== "StringLiteral")
-            return false;
-        if (!CHILD_PROCESS_MODULES.has(source.value))
-            return false;
-        // Find the property that matches the binding identifier
-        const bindingName = binding.identifier.name;
-        for (const property of declarator.id.properties) {
-            if (property.type !== "ObjectProperty")
-                continue;
-            if (property.value.type !== "Identifier")
-                continue;
-            if (property.value.name !== bindingName)
-                continue;
-            // Check the key is 'execFile' (handles aliases like { execFile: exec })
-            return (property.key.type === "Identifier" && property.key.name === "execFile");
+        if (declarator.id.type === "ObjectPattern") {
+            const init = declarator.init;
+            if (init?.type === "CallExpression" &&
+                init.callee.type === "Identifier" &&
+                init.callee.name === "require") {
+                const source = init.arguments[0];
+                if (source?.type === "StringLiteral" &&
+                    CHILD_PROCESS_MODULES.has(source.value)) {
+                    // Find the property that matches the binding identifier
+                    const bindingName = binding.identifier.name;
+                    for (const property of declarator.id.properties) {
+                        if (property.type !== "ObjectProperty")
+                            continue;
+                        if (property.value.type !== "Identifier")
+                            continue;
+                        if (property.value.name !== bindingName)
+                            continue;
+                        // Check the key is 'execFile' (handles aliases like { execFile: exec })
+                        isMatch =
+                            property.key.type === "Identifier" &&
+                                property.key.name === "execFile";
+                        break;
+                    }
+                }
+            }
         }
-        return false;
+        childProcessExecFileBindingCache.set(binding, isMatch);
+        return isMatch;
     }
+    childProcessExecFileBindingCache.set(binding, false);
     return false;
 };
 export const isExecFileCallArgument = (referencePath, commandBinding, argumentsBinding) => {

package/dist/transforms/rename-execfile-arguments/manifest.json

@@ -3,9 +3,9 @@
     "evaluations": {
         "claude-code-2.1.10:claude-code-2.1.11": {
             "diffSizePercent": 100,
-            "evaluatedAt": "2026-02-04T12:56:34.513Z",
+            "evaluatedAt": "2026-02-07T09:44:20.481Z",
             "changedLines": 4,
-            "durationSeconds": 163.50355117599997,
+            "durationSeconds": 27.924432042,
             "stableNames": 1359
         }
     }

package/package.json

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