miniread 1.53.0 → 1.55.0

package/README.md

@@ -17,8 +17,15 @@ miniread --list-transforms
 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
 ```
 
+## 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.
+
+By default, this transform runs even when it detects code patterns (like `eval`) that could make the output non-runnable. Use `--safe-stabilize-top-level-bindings` or set `MINIREAD_UNSAFE_STABILIZE_TOP_LEVEL_BINDINGS` to a falsy value (`0`, `false`, `no`, or empty string) to skip renaming in such cases.
+
 ## Examples
 
 ### Find the most common identifiers in a minified bundle

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

@@ -5,5 +5,10 @@ type TransformExecutionResult = {
     error?: string;
 };
 type VerboseLogger = (message: string) => void;
-export declare const executeTransforms: (transforms: Transform[], projectGraph: ProjectGraph, queue: PQueue, log: VerboseLogger) => Promise<TransformExecutionResult>;
+/**
+ * @param transformOptions - Shared across all transform invocations; shallow-frozen
+ * at runtime to prevent accidental top-level property mutation. Nested objects are
+ * not frozen (current options are all primitives).
+ */
+export declare const executeTransforms: (transforms: Transform[], projectGraph: ProjectGraph, queue: PQueue, transformOptions: Readonly<Record<string, unknown>>, log: VerboseLogger) => Promise<TransformExecutionResult>;
 export {};

package/dist/cli/execute-transforms.js

@@ -1,4 +1,10 @@
-export const executeTransforms = async (transforms, projectGraph, queue, log) => {
+/**
+ * @param transformOptions - Shared across all transform invocations; shallow-frozen
+ * at runtime to prevent accidental top-level property mutation. Nested objects are
+ * not frozen (current options are all primitives).
+ */
+export const executeTransforms = async (transforms, projectGraph, queue, transformOptions, log) => {
+    const frozenOptions = Object.freeze({ ...transformOptions });
     let totalTransformations = 0;
     for (const transform of transforms) {
         log(`Running transform: ${transform.id}`);
@@ -9,7 +15,7 @@ export const executeTransforms = async (transforms, projectGraph, queue, log) =>
                 const statsPromises = fileInfos.map((fileInfo) => queue.add(() => transform.transform({
                     projectGraph,
                     currentFile: fileInfo,
-                    options: {},
+                    options: frozenOptions,
                 })));
                 const allStats = await Promise.all(statsPromises);
                 const transformApplied = allStats.reduce((sum, stats) => sum + stats.transformationsApplied, 0);
@@ -21,7 +27,7 @@ export const executeTransforms = async (transforms, projectGraph, queue, log) =>
                 const stats = await transform.transform({
                     projectGraph,
                     currentFile: undefined,
-                    options: {},
+                    options: frozenOptions,
                 });
                 totalTransformations += stats.transformationsApplied;
                 log(`Applied ${stats.transformationsApplied} transformation(s)`);

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

@@ -0,0 +1,13 @@
+type FindInputFilesOk = {
+    ok: true;
+    inputBase: string;
+    sourceFilePaths: string[];
+    otherFilePaths: string[];
+};
+type FindInputFilesError = {
+    ok: false;
+    errors: string[];
+};
+type FindInputFilesResult = FindInputFilesOk | FindInputFilesError;
+export declare const findInputFiles: (input: string) => Promise<FindInputFilesResult>;
+export {};

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

@@ -0,0 +1,68 @@
+import * as fs from "node:fs/promises";
+import path from "node:path";
+const isSourceFile = (fileName) => {
+    return (!fileName.endsWith(".d.ts") &&
+        (fileName.endsWith(".ts") ||
+            fileName.endsWith(".tsx") ||
+            fileName.endsWith(".js") ||
+            fileName.endsWith(".jsx")));
+};
+const findAllFiles = async (directory) => {
+    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);
+            sourceFiles.push(...subResult.sourceFiles);
+            otherFiles.push(...subResult.otherFiles);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        if (isSourceFile(entry.name)) {
+            sourceFiles.push(fullPath);
+            continue;
+        }
+        otherFiles.push(fullPath);
+    }
+    return { sourceFiles, otherFiles };
+};
+export const findInputFiles = async (input) => {
+    let inputStat;
+    try {
+        inputStat = await fs.stat(input);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error accessing path";
+        return { ok: false, errors: [`Cannot access input path: ${message}`] };
+    }
+    let sourceFilePaths;
+    let otherFilePaths;
+    try {
+        if (inputStat.isDirectory()) {
+            const allFiles = await findAllFiles(input);
+            sourceFilePaths = allFiles.sourceFiles;
+            otherFilePaths = allFiles.otherFiles;
+        }
+        else {
+            sourceFilePaths = isSourceFile(input) ? [input] : [];
+            otherFilePaths = isSourceFile(input) ? [] : [input];
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error reading files";
+        return { ok: false, errors: [`Error reading input: ${message}`] };
+    }
+    if (sourceFilePaths.length === 0) {
+        return { ok: false, errors: ["No source files found in input path"] };
+    }
+    const inputBase = inputStat.isDirectory() ? input : path.dirname(input);
+    return {
+        ok: true,
+        inputBase,
+        sourceFilePaths,
+        otherFilePaths,
+    };
+};

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

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

package/dist/cli/run-transforms.js

@@ -1,77 +1,26 @@
 import * as fs from "node:fs/promises";
-import path from "node:path";
 import PQueue from "p-queue";
 import { buildProjectGraph } from "../core/project-graph.js";
 import { printDryRunSummary, writeOutputFiles } from "./output.js";
 import { generateCode } from "./generate-code.js";
 import { executeTransforms } from "./execute-transforms.js";
+import { findInputFiles } from "./find-input-files.js";
 const logVerbose = (verbose, message) => {
     if (!verbose)
         return;
     console.error(message);
 };
-const isSourceFile = (fileName) => {
-    return (!fileName.endsWith(".d.ts") &&
-        (fileName.endsWith(".ts") ||
-            fileName.endsWith(".tsx") ||
-            fileName.endsWith(".js") ||
-            fileName.endsWith(".jsx")));
-};
-const findAllFiles = async (directory) => {
-    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);
-            sourceFiles.push(...subResult.sourceFiles);
-            otherFiles.push(...subResult.otherFiles);
-        }
-        else if (entry.isFile()) {
-            if (isSourceFile(entry.name)) {
-                sourceFiles.push(fullPath);
-            }
-            else {
-                otherFiles.push(fullPath);
-            }
-        }
-    }
-    return { sourceFiles, otherFiles };
-};
 export const runTransforms = async (options) => {
-    const { input, output, transforms, dryRun, workers, overwrite, verbose } = options;
-    // Check if input exists
-    try {
-        await fs.access(input);
-    }
-    catch {
-        return {
-            filesProcessed: 0,
-            totalTransformations: 0,
-            errors: [`Input path does not exist: ${input}`],
-        };
-    }
-    // Find all files
-    const inputStat = await fs.stat(input);
-    let sourceFilePaths;
-    let otherFilePaths;
-    if (inputStat.isDirectory()) {
-        const allFiles = await findAllFiles(input);
-        sourceFilePaths = allFiles.sourceFiles;
-        otherFilePaths = allFiles.otherFiles;
-    }
-    else {
-        sourceFilePaths = isSourceFile(input) ? [input] : [];
-        otherFilePaths = isSourceFile(input) ? [] : [input];
-    }
-    if (sourceFilePaths.length === 0) {
+    const { input, output, transforms, transformOptions = {}, dryRun, workers, overwrite, verbose, } = options;
+    const inputFilesResult = await findInputFiles(input);
+    if (!inputFilesResult.ok) {
         return {
             filesProcessed: 0,
             totalTransformations: 0,
-            errors: ["No source files found in input path"],
+            errors: inputFilesResult.errors,
         };
     }
+    const { inputBase, sourceFilePaths, otherFilePaths } = inputFilesResult;
     logVerbose(verbose, `Found ${sourceFilePaths.length} source file(s)`);
     if (otherFilePaths.length > 0) {
         logVerbose(verbose, `Found ${otherFilePaths.length} other file(s) to copy`);
@@ -92,7 +41,7 @@ export const runTransforms = async (options) => {
     const log = (message) => {
         logVerbose(verbose, message);
     };
-    const result = await executeTransforms(transforms, projectGraph, queue, log);
+    const result = await executeTransforms(transforms, projectGraph, queue, transformOptions, log);
     if (result.error) {
         return {
             filesProcessed: 0,
@@ -108,7 +57,6 @@ export const runTransforms = async (options) => {
         finalFiles.set(filePath, generated);
     }
     // Output results
-    const inputBase = inputStat.isDirectory() ? input : path.dirname(input);
     if (dryRun) {
         printDryRunSummary(finalFiles, otherFilePaths, inputBase);
     }

package/dist/cli/transform-stdin.d.ts

@@ -1,6 +1,7 @@
 import type { Transform } from "../core/types.js";
 type StdinTransformOptions = {
     transforms: Transform[];
+    transformOptions: Record<string, unknown>;
     verbose: boolean;
 };
 type StdinTransformResult = {

package/dist/cli/transform-stdin.js

@@ -19,7 +19,7 @@ const readStdin = async () => {
     });
 };
 export const transformStdin = async (options) => {
-    const { transforms, verbose } = options;
+    const { transforms, transformOptions, verbose } = options;
     const inputText = await readStdin();
     const stdinPath = "stdin.tsx";
     const parsedFiles = [{ path: stdinPath, content: inputText }];
@@ -28,13 +28,14 @@ export const transformStdin = async (options) => {
     if (!stdinFile) {
         return { ok: false, error: "Failed to parse input" };
     }
+    const frozenOptions = Object.freeze({ ...transformOptions });
     let totalTransformations = 0;
     for (const transform of transforms) {
         try {
             const stats = await transform.transform({
                 projectGraph,
-                currentFile: undefined,
-                options: {},
+                currentFile: stdinFile,
+                options: frozenOptions,
             });
             totalTransformations += stats.transformationsApplied;
             logVerbose(verbose, `Applied ${stats.transformationsApplied} transformation(s) from ${transform.id}`);

package/dist/cli.js

@@ -3,6 +3,7 @@ import { Command, InvalidArgumentError } from "@commander-js/extra-typings";
 import packageJson from "../package.json" with { type: "json" };
 import { getTransformsToRun, getTransformSummaries } from "./cli/config.js";
 import { runTransforms, transformStdin } from "./cli/runner.js";
+import { getDefaultTransformOptions } from "./core/default-transform-options.js";
 const parseListFormat = (value) => {
     if (value === "text" || value === "tsv" || value === "json")
         return value;
@@ -15,6 +16,19 @@ const parsePositiveInt = (value) => {
     }
     return parsed;
 };
+const isEnvironmentFalsy = (value) => {
+    if (value === undefined)
+        return false;
+    const trimmed = value.trim().toLowerCase();
+    return trimmed === "" || ["0", "false", "no"].includes(trimmed);
+};
+const shouldUnsafeStabilize = (safeFlag) => {
+    if (safeFlag === true)
+        return false;
+    if (isEnvironmentFalsy(process.env.MINIREAD_UNSAFE_STABILIZE_TOP_LEVEL_BINDINGS))
+        return false;
+    return true;
+};
 const program = new Command()
     .name(packageJson.name)
     .description(packageJson.description)
@@ -29,7 +43,8 @@ const program = new Command()
     .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("-f, --overwrite", "Overwrite existing files in output directory");
+    .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", `
 Examples:
   # Read from stdin, write to stdout (filter mode)
@@ -86,6 +101,10 @@ else if (options.input) {
         input: options.input,
         output: options.output,
         transforms: transformsResult.transforms,
+        transformOptions: {
+            ...getDefaultTransformOptions(),
+            unsafeStabilizeTopLevelBindings: shouldUnsafeStabilize(options.safeStabilizeTopLevelBindings),
+        },
         dryRun: options.dryRun ?? false,
         workers: options.workers,
         overwrite: options.overwrite ?? false,
@@ -111,6 +130,10 @@ else {
     }
     const result = await transformStdin({
         transforms: transformsResult.transforms,
+        transformOptions: {
+            ...getDefaultTransformOptions(),
+            unsafeStabilizeTopLevelBindings: shouldUnsafeStabilize(options.safeStabilizeTopLevelBindings),
+        },
         verbose: options.verbose ?? false,
     });
     if (!result.ok) {

package/dist/core/collect-exported-names.js

@@ -1,4 +1,4 @@
-import { isArrayPattern, isAssignmentPattern, isClassDeclaration, isExportNamedDeclaration, isExportSpecifier, isFunctionDeclaration, isIdentifier, isObjectPattern, isObjectProperty, isRestElement, isVariableDeclaration, } from "@babel/types";
+import { isArrayPattern, isAssignmentPattern, isClassDeclaration, isExportDefaultDeclaration, isExportNamedDeclaration, isExportSpecifier, isFunctionDeclaration, isIdentifier, isObjectPattern, isObjectProperty, isRestElement, isVariableDeclaration, } from "@babel/types";
 const addBindingNamesFromNode = (node, out) => {
     const babelNode = node;
     if (!babelNode)
@@ -38,6 +38,22 @@ const addBindingNamesFromNode = (node, out) => {
 export const collectExportedNames = (program) => {
     const exportedNames = new Set();
     for (const statement of program.body) {
+        if (isExportDefaultDeclaration(statement)) {
+            const declaration = statement.declaration;
+            if (isIdentifier(declaration)) {
+                // `export default foo` doesn't declare a new binding, but `foo` is still
+                // part of the module's public surface, so be conservative and skip it.
+                exportedNames.add(declaration.name);
+                continue;
+            }
+            if (isFunctionDeclaration(declaration) ||
+                isClassDeclaration(declaration)) {
+                const id = declaration.id;
+                if (id)
+                    exportedNames.add(id.name);
+            }
+            continue;
+        }
         if (!isExportNamedDeclaration(statement))
             continue;
         const declaration = statement.declaration;
@@ -55,13 +71,17 @@ export const collectExportedNames = (program) => {
                 exportedNames.add(id.name);
             }
         }
-        for (const specifier of statement.specifiers) {
-            if (!isExportSpecifier(specifier))
-                continue;
-            const local = specifier.local;
-            if (!isIdentifier(local))
-                continue;
-            exportedNames.add(local.name);
+        // Re-exports like `export { foo } from "mod"` do not reference local bindings,
+        // so they should not affect rename-skipping decisions.
+        if (!statement.source) {
+            for (const specifier of statement.specifiers) {
+                if (!isExportSpecifier(specifier))
+                    continue;
+                const local = specifier.local;
+                if (!isIdentifier(local))
+                    continue;
+                exportedNames.add(local.name);
+            }
         }
     }
     return exportedNames;

package/dist/core/create-has-binding-options-up-to-scope.d.ts

@@ -0,0 +1,8 @@
+import type { Scope } from "@babel/traverse";
+type HasBindingOptions = {
+    noGlobals?: boolean;
+    noUids?: boolean;
+    upToScope?: Scope;
+};
+export declare const createHasBindingOptionsUpToScope: (upToScope: Scope) => HasBindingOptions;
+export {};

package/dist/core/create-has-binding-options-up-to-scope.js

@@ -0,0 +1,7 @@
+export const createHasBindingOptionsUpToScope = (upToScope) => {
+    return {
+        noGlobals: true,
+        noUids: true,
+        upToScope,
+    };
+};

package/dist/core/default-transform-options.d.ts

@@ -0,0 +1,10 @@
+type DefaultTransformOptions = {
+    /**
+     * When true, `stabilize-top-level-bindings` runs even if the file contains
+     * dynamic-name hazards (e.g. eval/with). This can improve diff stability and
+     * readability, but the transformed output may not be runnable.
+     */
+    unsafeStabilizeTopLevelBindings: boolean;
+};
+export declare const getDefaultTransformOptions: () => DefaultTransformOptions;
+export {};

package/dist/core/default-transform-options.js

@@ -0,0 +1,5 @@
+export const getDefaultTransformOptions = () => {
+    return {
+        unsafeStabilizeTopLevelBindings: true,
+    };
+};

package/dist/core/has-shadowing-risk.d.ts

@@ -0,0 +1,2 @@
+import type { Binding, Scope } from "@babel/traverse";
+export declare const hasShadowingRisk: (binding: Binding, bindingScope: Scope, targetName: string) => boolean;

package/dist/core/has-shadowing-risk.js

@@ -0,0 +1,24 @@
+import * as t from "@babel/types";
+import { createHasBindingOptionsUpToScope } from "./create-has-binding-options-up-to-scope.js";
+export const hasShadowingRisk = (binding, bindingScope, targetName) => {
+    // Include reassignment sites (`x = ...`) in addition to references so we also catch
+    // potential capture/shadowing risks at write locations (see has-shadowing-risk.test.ts).
+    const identifierPaths = [
+        ...binding.referencePaths,
+        ...binding.constantViolations,
+    ];
+    return identifierPaths.some((referencePath) => {
+        if (referencePath.scope === bindingScope)
+            return false;
+        // Inside a `with` statement, identifier resolution is runtime-dependent.
+        // Be conservative and refuse renames that touch such references.
+        if (referencePath.findParent((path) => {
+            return t.isWithStatement(path.node);
+        })) {
+            return true;
+        }
+        // Only consider bindings between this reference’s scope and the binding scope.
+        // This avoids incorrectly blocking safe renames due to unrelated outer bindings.
+        return referencePath.scope.hasBinding(targetName, createHasBindingOptionsUpToScope(bindingScope));
+    });
+};

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

@@ -4,6 +4,9 @@
  * The `$` prefix signals that a variable has been renamed stably by a transform
  * and should be skipped by other transforms.
  *
+ * Reserved prefixes:
+ * - `$h_`: used by `stabilize-top-level-bindings` for content-hash-based names.
+ *
  * - Stable names (`$timeoutId`): Readable AND deterministic across versions
  * - Readable names (`timeoutId`): Semantic but order-dependent
  */

package/dist/core/stable-naming.js

@@ -4,9 +4,13 @@
  * The `$` prefix signals that a variable has been renamed stably by a transform
  * and should be skipped by other transforms.
  *
+ * Reserved prefixes:
+ * - `$h_`: used by `stabilize-top-level-bindings` for content-hash-based names.
+ *
  * - Stable names (`$timeoutId`): Readable AND deterministic across versions
  * - Readable names (`timeoutId`): Semantic but order-dependent
  */
+import { hasShadowingRisk } from "./has-shadowing-risk.js";
 import { isTypeOnlyGlobalReference } from "./is-type-only-global-reference.js";
 const STABLE_PREFIX = "$";
 /**
@@ -23,19 +27,6 @@ export const isStableRenamed = (name) => {
 const makeStableName = (baseName) => {
     return `${STABLE_PREFIX}${baseName}`;
 };
-const hasShadowingRisk = (binding, bindingScope, targetName) => binding.referencePaths.some((referencePath) => {
-    if (referencePath.scope === bindingScope)
-        return false;
-    // Only consider bindings between this reference’s scope and the binding scope.
-    // This avoids incorrectly blocking safe renames due to unrelated outer bindings.
-    const hasBindingOptions = {
-        noGlobals: true,
-        noUids: true,
-        // Present in Babel scope implementation, but missing from our TypeScript types.
-        upToScope: bindingScope,
-    };
-    return referencePath.scope.hasBinding(targetName, hasBindingOptions);
-});
 // Cache is keyed by the program `Scope` instance produced by Babel traversal,
 // so it won't leak across separate traversals / transform passes.
 const programValueGlobalsCache = new WeakMap();
@@ -105,33 +96,36 @@ const findAvailableName = (scope, binding, baseName, startIndex, canBeStable, cu
             ? false
             : scope.hasBinding(candidateStable) ||
                 programGlobals.has(candidateStable);
-        if (canBeStable) {
-            if (stableTaken) {
-                index++;
-                continue;
-            }
-            // Stable names (`$foo`) don't collide with readable names (`foo`), so when
-            // we know we'll emit a stable name, we only need to check the stable slot.
-            const name = candidateStable;
-            if (binding && hasShadowingRisk(binding, scope, name)) {
-                index++;
-                continue;
-            }
-            return { name, nextIndex: index + 1 };
-        }
         const readableTaken = candidateReadable === currentName
             ? false
             : scope.hasBinding(candidateReadable) ||
                 programGlobals.has(candidateReadable);
-        if (!stableTaken && !readableTaken) {
-            const name = candidateReadable;
-            if (binding && hasShadowingRisk(binding, scope, name)) {
-                index++;
-                continue;
+        if (canBeStable) {
+            if (!stableTaken &&
+                (!binding || !hasShadowingRisk(binding, scope, candidateStable))) {
+                return { name: candidateStable, nextIndex: index + 1 };
+            }
+            // Prefer stable names, but fall back to the readable form (same suffix)
+            // before incrementing when the stable variant is blocked by shadowing.
+            if (!stableTaken &&
+                !readableTaken &&
+                (!binding || !hasShadowingRisk(binding, scope, candidateReadable))) {
+                return { name: candidateReadable, nextIndex: index + 1 };
             }
-            return { name, nextIndex: index + 1 };
+            index++;
+            continue;
+        }
+        // Reserve the stable name slot even for readable renames so a pre-existing
+        // `$foo` blocks introducing `foo` (keeps stable/readable "slots" aligned).
+        if (stableTaken || readableTaken) {
+            index++;
+            continue;
+        }
+        if (binding && hasShadowingRisk(binding, scope, candidateReadable)) {
+            index++;
+            continue;
         }
-        index++;
+        return { name: candidateReadable, nextIndex: index + 1 };
     }
 };
 /**

package/dist/core/types.d.ts

@@ -14,7 +14,7 @@ export type ProjectGraph = {
 export type TransformContext = {
     projectGraph: ProjectGraph;
     currentFile: SourceFileInfo | undefined;
-    options: Record<string, unknown>;
+    options: Readonly<Record<string, unknown>>;
 };
 export type TransformStats = {
     nodesVisited: number;

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

@@ -1,6 +1,7 @@
 import { createRequire } from "node:module";
 import * as fs from "node:fs/promises";
 import { buildProjectGraph } from "../../core/project-graph.js";
+import { getDefaultTransformOptions } from "../../core/default-transform-options.js";
 import { transformPresets } from "../../transforms/transform-presets.js";
 import { transformRegistry } from "../../transforms/transform-registry.js";
 import { formatCode } from "./format-code.js";
@@ -20,11 +21,12 @@ const runTransform = async (inputPath, transformId) => {
         return transform;
     });
     const projectGraph = buildProjectGraph([{ path: inputPath, content }]);
+    const options = getDefaultTransformOptions();
     for (const transform of transforms) {
         await transform.transform({
             projectGraph,
             currentFile: undefined,
-            options: {},
+            options,
         });
     }
     const fileInfo = projectGraph.files.get(inputPath);