miniread 1.68.0 → 1.69.0

package/dist/{transforms/stabilize-nested-bindings → core/fingerprint}/fingerprint-scalar-fields.js

@@ -1,5 +1,16 @@
 import * as t from "@babel/types";
 const encodeScalar = (value) => value === undefined ? "undefined" : JSON.stringify(value);
+const extractKeyName = (key) => {
+    if (t.isIdentifier(key))
+        return key.name;
+    if (t.isStringLiteral(key))
+        return key.value;
+    if (t.isNumericLiteral(key))
+        return String(key.value);
+    if (t.isPrivateName(key))
+        return `#${key.id.name}`;
+    return undefined;
+};
 export const fingerprintScalarFields = (node) => {
     if (node.type === "AssignmentExpression" ||
         node.type === "BinaryExpression" ||
@@ -20,6 +31,9 @@ export const fingerprintScalarFields = (node) => {
         const computed = node.computed;
         const property = node
             .property;
+        // Include non-computed property names to reduce collisions (e.g. `obj.foo` vs
+        // `obj.bar`). This trades some cross-build stability for fewer collisions if
+        // a toolchain mangles property names between builds.
         const propertyName = computed === false && t.isIdentifier(property)
             ? property.name
             : computed === false && t.isPrivateName(property)
@@ -47,6 +61,8 @@ export const fingerprintScalarFields = (node) => {
         node.type === "ObjectMethod" ||
         node.type === "ClassMethod" ||
         node.type === "ClassPrivateMethod") {
+        // Keep a uniform field set for all function-like nodes; some fields (e.g. `static`,
+        // `computed`, `kind`) only exist on specific node types and will be `undefined` otherwise.
         const fields = [
             `async=${encodeScalar(node.async)}`,
             `generator=${encodeScalar(node.generator)}`,
@@ -54,36 +70,13 @@ export const fingerprintScalarFields = (node) => {
             `static=${encodeScalar(node.static)}`,
             `computed=${encodeScalar(node.computed)}`,
         ];
-        if (node.type === "ObjectMethod") {
+        if (node.type === "ObjectMethod" ||
+            node.type === "ClassMethod" ||
+            node.type === "ClassPrivateMethod") {
             const computed = node.computed;
             const key = node.key;
             if (computed !== true) {
-                const keyName = t.isIdentifier(key)
-                    ? key.name
-                    : t.isStringLiteral(key)
-                        ? key.value
-                        : t.isNumericLiteral(key)
-                            ? String(key.value)
-                            : t.isPrivateName(key)
-                                ? `#${key.id.name}`
-                                : undefined;
-                fields.push(`keyName=${encodeScalar(keyName)}`);
-            }
-        }
-        if (node.type === "ClassMethod" || node.type === "ClassPrivateMethod") {
-            const computed = node.computed;
-            const key = node.key;
-            if (computed !== true) {
-                const keyName = t.isIdentifier(key)
-                    ? key.name
-                    : t.isStringLiteral(key)
-                        ? key.value
-                        : t.isNumericLiteral(key)
-                            ? String(key.value)
-                            : t.isPrivateName(key)
-                                ? `#${key.id.name}`
-                                : undefined;
-                fields.push(`keyName=${encodeScalar(keyName)}`);
+                fields.push(`keyName=${encodeScalar(extractKeyName(key))}`);
             }
         }
         return fields;
@@ -93,33 +86,14 @@ export const fingerprintScalarFields = (node) => {
         const key = node.key;
         const fields = [`computed=${encodeScalar(computed)}`];
         if (computed !== true) {
-            const keyName = t.isIdentifier(key)
-                ? key.name
-                : t.isStringLiteral(key)
-                    ? key.value
-                    : t.isNumericLiteral(key)
-                        ? String(key.value)
-                        : t.isPrivateName(key)
-                            ? `#${key.id.name}`
-                            : undefined;
-            fields.push(`keyName=${encodeScalar(keyName)}`);
+            fields.push(`keyName=${encodeScalar(extractKeyName(key))}`);
         }
         return fields;
     }
     if (node.type === "ClassProperty" || node.type === "ClassPrivateProperty") {
         const computed = node.computed;
         const key = node.key;
-        const keyName = computed === true
-            ? undefined
-            : t.isIdentifier(key)
-                ? key.name
-                : t.isStringLiteral(key)
-                    ? key.value
-                    : t.isNumericLiteral(key)
-                        ? String(key.value)
-                        : t.isPrivateName(key)
-                            ? `#${key.id.name}`
-                            : undefined;
+        const keyName = computed === true ? undefined : extractKeyName(key);
         return [
             `static=${encodeScalar(node.static)}`,
             `computed=${encodeScalar(computed)}`,
@@ -129,12 +103,7 @@ export const fingerprintScalarFields = (node) => {
     if (node.type === "ImportSpecifier") {
         const imported = node
             .imported;
-        const importedName = t.isIdentifier(imported)
-            ? imported.name
-            : t.isStringLiteral(imported)
-                ? imported.value
-                : undefined;
-        return [`importedName=${encodeScalar(importedName)}`];
+        return [`importedName=${encodeScalar(extractKeyName(imported))}`];
     }
     return [];
 };

package/dist/{transforms/stabilize-top-level-bindings → core/fingerprint}/serialize-fingerprint-node.js

@@ -26,17 +26,15 @@ const pushNodeTasks = (stack, node) => {
     let visitorKeys = keys;
     // For non-computed member keys, we already serialize `keyName` via scalar fields.
     // Skipping the `key` child keeps fingerprints stable across equivalent key syntax
-    // like `{ foo: 1 }` vs `{ \"foo\": 1 }`.
+    // like `{ foo: 1 }` vs `{ "foo": 1 }`.
     const computed = node.computed;
-    if (computed === true) {
-        // Keep the key expression for computed properties.
-    }
-    else if (node.type === "ObjectProperty" ||
-        node.type === "ObjectMethod" ||
-        node.type === "ClassMethod" ||
-        node.type === "ClassPrivateMethod" ||
-        node.type === "ClassProperty" ||
-        node.type === "ClassPrivateProperty") {
+    if (computed !== true &&
+        (node.type === "ObjectProperty" ||
+            node.type === "ObjectMethod" ||
+            node.type === "ClassMethod" ||
+            node.type === "ClassPrivateMethod" ||
+            node.type === "ClassProperty" ||
+            node.type === "ClassPrivateProperty")) {
         visitorKeys = keys.filter((key) => key !== "key");
     }
     const nodeTasks = [{ kind: "text", text: node.type }];

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

@@ -7,6 +7,8 @@
  * Reserved prefixes:
  * - `$h_`: used by `stabilize-top-level-bindings` for content-hash-based names.
  * - `$f_`: used by `stabilize-nested-bindings` for factory-local content-hash-based names.
+ * - `$v_`: used by `stabilize-deferred-top-level-bindings` and `stabilize-deferred-stable-rhs`
+ *          for deferred variable names derived from enclosing function or RHS hashes.
  *
  * - Stable names (`$timeoutId`): Readable AND deterministic across versions
  * - Readable names (`timeoutId`): Semantic but order-dependent
@@ -17,6 +19,12 @@ import type { Scope } from "@babel/traverse";
  * Transforms should skip variables with this prefix.
  */
 export declare const isStableRenamed: (name: string) => boolean;
+/**
+ * Returns true if the name uses a content-hash-based stable prefix
+ * (`$h_`, `$f_`, or `$v_`). Use this to check whether a binding was
+ * stabilized by one of the hash-based stabilization transforms.
+ */
+export declare const isHashBasedStableName: (name: string) => boolean;
 /**
  * Entry for a planned rename operation.
  */

package/dist/core/stable-naming.js

@@ -7,6 +7,8 @@
  * Reserved prefixes:
  * - `$h_`: used by `stabilize-top-level-bindings` for content-hash-based names.
  * - `$f_`: used by `stabilize-nested-bindings` for factory-local content-hash-based names.
+ * - `$v_`: used by `stabilize-deferred-top-level-bindings` and `stabilize-deferred-stable-rhs`
+ *          for deferred variable names derived from enclosing function or RHS hashes.
  *
  * - Stable names (`$timeoutId`): Readable AND deterministic across versions
  * - Readable names (`timeoutId`): Semantic but order-dependent
@@ -21,6 +23,12 @@ const STABLE_PREFIX = "$";
 export const isStableRenamed = (name) => {
     return name.startsWith(STABLE_PREFIX);
 };
+/**
+ * Returns true if the name uses a content-hash-based stable prefix
+ * (`$h_`, `$f_`, or `$v_`). Use this to check whether a binding was
+ * stabilized by one of the hash-based stabilization transforms.
+ */
+export const isHashBasedStableName = (name) => name.startsWith("$h_") || name.startsWith("$f_") || name.startsWith("$v_");
 /**
  * Creates a stable name by adding the $ prefix.
  * Internal helper - prefer using RenameGroup which handles stability logic automatically.

package/dist/transforms/_generated/manifest.js

@@ -334,6 +334,16 @@ const manifestData = {
         notes: "Auto-added by evaluation script. Measured with baseline none: -0.28%. Enabled in the recommended preset for readability and to normalize variable declarations even when line diffs increase.",
         evaluations: { "legacy:evaluation": { "evaluatedAt": "2026-01-25T20:21:14.926Z", "changedLines": 208592, "durationSeconds": 0, "stableNames": 0, "diffSizePercent": 100.27969913444457 }, "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 100.27969913444457, "evaluatedAt": "2026-01-25T23:41:19.807Z", "changedLines": 208592, "durationSeconds": 65.61050708399999, "stableNames": 1357 } },
     },
+    "stabilize-deferred-stable-rhs": {
+        recommended: true,
+        notes: "Stabilizes deferred top-level vars whose RHS contains only stable identifiers (globals or $h_/$f_/$v_ prefixed names). Derives names by hashing the RHS code. Complements stabilize-deferred-top-level-bindings by handling multi-var functions.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 95.54, "evaluatedAt": "2026-02-05T18:30:00.000Z", "changedLines": 3730, "durationSeconds": 30, "stableNames": 1741 } },
+    },
+    "stabilize-deferred-top-level-bindings": {
+        recommended: true,
+        notes: "Stabilizes top-level var declarations that are initialized inside stable-named functions (lazy init pattern). Only applies when the enclosing function has exactly one such deferred var to avoid order-dependent naming. Renames ~750 vars but diff reduction is minimal (0.03%) because most vars already have consistent minified names between versions. The stabilization helps when minifiers do vary names.",
+        evaluations: { "claude-code-2.1.10:claude-code-2.1.11": { "diffSizePercent": 99.97, "evaluatedAt": "2026-02-05T17:32:00.000Z", "changedLines": 753, "durationSeconds": 26, "stableNames": 2110 } },
+    },
     "stabilize-nested-bindings": {
         recommended: true,
         notes: "Stabilizes local bindings inside CommonJS factory callbacks using content-hash naming ($f_<hash>). Must run AFTER stabilize-top-level-bindings. Combined with top-level stabilization, achieves 33.49% diff size (67% reduction from baseline).",
@@ -377,6 +387,8 @@ export const manifestEntries = Object.entries(transformRegistry)
 export const recommendedTransformIds = [
     "stabilize-top-level-bindings",
     "stabilize-nested-bindings",
+    "stabilize-deferred-top-level-bindings",
+    "stabilize-deferred-stable-rhs",
     "expand-boolean-literals",
     "expand-sequence-expressions-v5",
     "expand-special-number-literals",

package/dist/transforms/_generated/registry.js

@@ -68,6 +68,8 @@ import { replaceDynamicRequireEvalTransform } from "../replace-dynamic-require-e
 import { simplifyBooleanNegationsTransform } from "../simplify-boolean-negations/simplify-boolean-negations-transform.js";
 import { simplifyStringTrimTransform } from "../simplify-string-trim/simplify-string-trim-transform.js";
 import { splitVariableDeclarationsTransform } from "../split-variable-declarations/split-variable-declarations-transform.js";
+import { stabilizeDeferredStableRhsTransform } from "../stabilize-deferred-stable-rhs/stabilize-deferred-stable-rhs-transform.js";
+import { stabilizeDeferredTopLevelBindingsTransform } from "../stabilize-deferred-top-level-bindings/stabilize-deferred-top-level-bindings-transform.js";
 import { stabilizeNestedBindingsTransform } from "../stabilize-nested-bindings/stabilize-nested-bindings-transform.js";
 import { stabilizeTopLevelBindingsTransform } from "../stabilize-top-level-bindings/stabilize-top-level-bindings-transform.js";
 import { useObjectPropertyShorthandTransform } from "../use-object-property-shorthand/use-object-property-shorthand-transform.js";
@@ -142,6 +144,8 @@ export const transformRegistry = {
     [simplifyBooleanNegationsTransform.id]: simplifyBooleanNegationsTransform,
     [simplifyStringTrimTransform.id]: simplifyStringTrimTransform,
     [splitVariableDeclarationsTransform.id]: splitVariableDeclarationsTransform,
+    [stabilizeDeferredStableRhsTransform.id]: stabilizeDeferredStableRhsTransform,
+    [stabilizeDeferredTopLevelBindingsTransform.id]: stabilizeDeferredTopLevelBindingsTransform,
     [stabilizeNestedBindingsTransform.id]: stabilizeNestedBindingsTransform,
     [stabilizeTopLevelBindingsTransform.id]: stabilizeTopLevelBindingsTransform,
     [useObjectPropertyShorthandTransform.id]: useObjectPropertyShorthandTransform,

package/dist/transforms/preset-stats.json

@@ -1,6 +1,6 @@
 {
     "recommended": {
-        "diffSizePercent": 33.48924670219602,
-        "notes": "Measured with baseline none: 33.49% of original diff."
+        "diffSizePercent": 33.47412783006388,
+        "notes": "Measured with baseline none: 33.47% of original diff."
     }
 }

package/dist/transforms/recommended-transform-order.d.ts

@@ -4,4 +4,4 @@
  * This lets us tune transform interactions intentionally instead of relying on
  * alphabetical ID sorting.
  */
-export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "stabilize-nested-bindings", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-typeof-undefined-comparisons", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-awaiter-helper-functions", "rename-buffer-variables", "rename-to-buffer-results", "rename-catch-parameters", "rename-promise-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-date-now-start-times", "rename-default-options-parameters", "rename-deferred-resolve-parameters", "rename-destructured-aliases", "rename-rest-parameters", "rename-execfile-arguments", "rename-error-first-callback-parameters", "rename-error-variables", "rename-event-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-http-method-parameters", "rename-interval-ids", "rename-loop-index-variables-v3", "rename-loop-length-variables", "rename-document-fragment-variables", "rename-object-keys-variables", "rename-object-keys-iterator-variables", "rename-parameters-to-match-properties-v2", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-search-parameters-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-ids", "rename-typeof-variables", "rename-typescript-helper-aliases", "rename-uint8array-concat-variables", "rename-url-parameters", "rename-url-variables", "rename-use-reference-guards-v2", "rename-use-reference-sets", "rename-worker-handles", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];
+export declare const recommendedTransformOrder: readonly ["stabilize-top-level-bindings", "stabilize-nested-bindings", "stabilize-deferred-top-level-bindings", "stabilize-deferred-stable-rhs", "expand-boolean-literals", "expand-sequence-expressions-v5", "expand-special-number-literals", "expand-typeof-undefined-comparisons", "expand-undefined-literals", "remove-redundant-else", "rename-arguments-length-flags", "rename-asap-wrappers", "rename-awaiter-parameters", "rename-awaiter-helper-functions", "rename-buffer-variables", "rename-to-buffer-results", "rename-catch-parameters", "rename-promise-catch-parameters", "rename-char-code-at", "rename-charcode-variables-v2", "rename-client-aliases", "rename-comparison-flags", "rename-date-now-start-times", "rename-default-options-parameters", "rename-deferred-resolve-parameters", "rename-destructured-aliases", "rename-rest-parameters", "rename-execfile-arguments", "rename-error-first-callback-parameters", "rename-error-variables", "rename-event-parameters", "rename-http-server-parameters", "rename-fs-sync-variables", "rename-http-method-parameters", "rename-interval-ids", "rename-loop-index-variables-v3", "rename-loop-length-variables", "rename-document-fragment-variables", "rename-object-keys-variables", "rename-object-keys-iterator-variables", "rename-parameters-to-match-properties-v2", "rename-promise-executor-parameters-v2", "rename-range-parameters", "rename-read-file-lines", "rename-regex-builders", "rename-search-parameters-variables", "rename-string-split-variables", "rename-this-aliases", "rename-timeout-ids", "rename-typeof-variables", "rename-typescript-helper-aliases", "rename-uint8array-concat-variables", "rename-url-parameters", "rename-url-variables", "rename-use-reference-guards-v2", "rename-use-reference-sets", "rename-worker-handles", "simplify-boolean-negations", "simplify-string-trim", "split-variable-declarations", "use-optional-chaining", "use-object-property-shorthand", "use-object-shorthand", "replace-dynamic-require-eval"];

package/dist/transforms/recommended-transform-order.js

@@ -11,6 +11,13 @@ export const recommendedTransformOrder = [
     // Run second: stabilizes local bindings inside CommonJS factory callbacks.
     // Depends on stabilize-top-level-bindings having renamed factory wrapper functions to $h_*.
     "stabilize-nested-bindings",
+    // Run third: stabilizes top-level vars that are assigned inside stable-named functions.
+    // Depends on stabilize-top-level-bindings having renamed enclosing functions to $h_*.
+    "stabilize-deferred-top-level-bindings",
+    // Run fourth: stabilizes remaining deferred vars whose RHS has only stable identifiers.
+    // Depends on stabilize-top-level-bindings and stabilize-deferred-top-level-bindings
+    // having renamed identifiers to $h_*/$v_*.
+    "stabilize-deferred-stable-rhs",
     "expand-boolean-literals",
     "expand-sequence-expressions-v5",
     "expand-special-number-literals",

package/dist/transforms/stabilize-deferred-stable-rhs/check-rhs-stability.d.ts

@@ -0,0 +1,6 @@
+import type { Expression } from "@babel/types";
+/**
+ * Check if all identifier references in an expression are stable
+ * (globals or already-stabilized names).
+ */
+export declare const hasAllStableReferences: (expression: Expression, programScopeBindings: Set<string>) => boolean;

package/dist/transforms/stabilize-deferred-stable-rhs/check-rhs-stability.js

@@ -0,0 +1,51 @@
+import { isHashBasedStableName } from "../../core/stable-naming.js";
+/**
+ * Check if all identifier references in an expression are stable
+ * (globals or already-stabilized names).
+ */
+export const hasAllStableReferences = (expression, programScopeBindings) => {
+    const identifiers = collectIdentifierReferences(expression);
+    return identifiers.every((name) => isHashBasedStableName(name) || !programScopeBindings.has(name));
+};
+/**
+ * Collect all identifier references in an expression,
+ * skipping non-computed property keys in member expressions and object literals.
+ */
+const collectIdentifierReferences = (node) => {
+    if (!node || typeof node !== "object")
+        return [];
+    const astNode = node;
+    if (astNode.type === "Identifier")
+        return [astNode.name];
+    if ((astNode.type === "MemberExpression" ||
+        astNode.type === "OptionalMemberExpression") &&
+        !astNode.computed) {
+        return collectIdentifierReferences(astNode.object);
+    }
+    // Skip non-computed, non-shorthand ObjectProperty keys — they're labels, not references.
+    if (astNode.type === "ObjectProperty" &&
+        !astNode.computed &&
+        !astNode.shorthand) {
+        return collectIdentifierReferences(astNode.value);
+    }
+    const result = [];
+    for (const [key, value] of Object.entries(astNode)) {
+        if (key === "type" || key === "start" || key === "end" || key === "loc")
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                if (item &&
+                    typeof item === "object" &&
+                    item.type) {
+                    result.push(...collectIdentifierReferences(item));
+                }
+            }
+        }
+        else if (value &&
+            typeof value === "object" &&
+            value.type) {
+            result.push(...collectIdentifierReferences(value));
+        }
+    }
+    return result;
+};

package/dist/transforms/stabilize-deferred-stable-rhs/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "notes": "Stabilizes deferred top-level vars whose RHS contains only stable identifiers (globals or $h_/$f_/$v_ prefixed names). Derives names by hashing the RHS code. Complements stabilize-deferred-top-level-bindings by handling multi-var functions.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 95.54,
+            "evaluatedAt": "2026-02-05T18:30:00.000Z",
+            "changedLines": 3730,
+            "durationSeconds": 30,
+            "stableNames": 1741
+        }
+    }
+}

package/dist/transforms/stabilize-deferred-stable-rhs/stabilize-deferred-stable-rhs-transform.d.ts

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

package/dist/transforms/stabilize-deferred-stable-rhs/stabilize-deferred-stable-rhs-transform.js

@@ -0,0 +1,125 @@
+import { createRequire } from "node:module";
+import { createHash } from "node:crypto";
+import { parse } from "@babel/parser";
+import * as t from "@babel/types";
+import { getFilesToProcess, } from "../../core/types.js";
+import { generateCode } from "../../cli/generate-code.js";
+import { isHashBasedStableName } from "../../core/stable-naming.js";
+import { canRenameBindingSafely, findEnclosingBindingName, renameBindingInPlace, } from "../stabilize-deferred-top-level-bindings/rename-helpers.js";
+import { hasAllStableReferences } from "./check-rhs-stability.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const generate = require("@babel/generator").default;
+const hashCode = (code) => createHash("sha256").update(code).digest("hex").slice(0, 16);
+export const stabilizeDeferredStableRhsTransform = {
+    id: "stabilize-deferred-stable-rhs",
+    description: "Renames deferred top-level vars whose RHS contains only stable identifiers " +
+        "(globals or $h_/$f_/$v_ prefixed). Derives stable names by hashing the RHS code. " +
+        "Complements stabilize-deferred-top-level-bindings by handling multi-var functions.",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const program = fileInfo.ast.program;
+            let programScope;
+            traverse(fileInfo.ast, {
+                Program(path) {
+                    programScope = path.scope;
+                    path.stop();
+                },
+            });
+            if (!programScope)
+                continue;
+            const programScopeBindings = new Set(Object.keys(programScope.bindings));
+            // Step 1: Find all uninitialized top-level vars that aren't already stable
+            const uninitializedVariables = new Set();
+            traverse(fileInfo.ast, {
+                VariableDeclaration(path) {
+                    nodesVisited++;
+                    if (path.parent.type !== "Program")
+                        return;
+                    if (path.node.kind !== "var")
+                        return;
+                    for (const declaration of path.node.declarations) {
+                        if (!declaration.init &&
+                            t.isIdentifier(declaration.id) &&
+                            !isHashBasedStableName(declaration.id.name)) {
+                            uninitializedVariables.add(declaration.id.name);
+                        }
+                    }
+                },
+            });
+            // Step 2: Find assignments inside stable-named functions
+            const assignments = [];
+            traverse(fileInfo.ast, {
+                AssignmentExpression(path) {
+                    nodesVisited++;
+                    if (!t.isIdentifier(path.node.left))
+                        return;
+                    const variableName = path.node.left.name;
+                    if (!uninitializedVariables.has(variableName))
+                        return;
+                    const functionPath = path.findParent((p) => p.isFunction());
+                    if (!functionPath)
+                        return;
+                    const enclosingFunctionName = findEnclosingBindingName(functionPath);
+                    if (!enclosingFunctionName ||
+                        !isHashBasedStableName(enclosingFunctionName))
+                        return;
+                    // Check stability and capture RHS code NOW, before any renames happen.
+                    // This prevents order-dependent cascading where renaming one var
+                    // makes another var's RHS appear stable.
+                    const rhsNode = path.node.right;
+                    const isStable = hasAllStableReferences(rhsNode, programScopeBindings);
+                    assignments.push({
+                        variableName,
+                        rhsNode,
+                        enclosingFunctionName,
+                        rhsCode: isStable
+                            ? generate(rhsNode, { concise: true }).code
+                            : undefined,
+                    });
+                },
+            });
+            // Step 3: Apply renames for assignments with all-stable RHS.
+            // Deduplicate by variable name — if a var has multiple assignments,
+            // use only the first (order is AST traversal order).
+            // Track used target names to prevent collisions: two vars with identical
+            // RHS code produce the same hash, and renameBindingInPlace does not update
+            // Babel's scope map, so canRenameBindingSafely would not catch the second.
+            const seen = new Set();
+            const usedNewNames = new Set();
+            let fileTransformations = 0;
+            for (const { variableName, rhsCode } of assignments) {
+                if (!rhsCode)
+                    continue;
+                if (seen.has(variableName))
+                    continue;
+                seen.add(variableName);
+                const newName = `$v_${hashCode(rhsCode)}`;
+                if (usedNewNames.has(newName))
+                    continue;
+                if (!canRenameBindingSafely(programScope, variableName, newName))
+                    continue;
+                if (renameBindingInPlace(programScope, variableName, newName)) {
+                    usedNewNames.add(newName);
+                    fileTransformations++;
+                }
+            }
+            transformationsApplied += fileTransformations;
+            if (fileTransformations > 0) {
+                const code = generateCode(fileInfo.ast);
+                const newAst = parse(code, {
+                    sourceType: program.sourceType,
+                    plugins: ["jsx", "typescript"],
+                });
+                fileInfo.ast = newAst;
+            }
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/stabilize-deferred-top-level-bindings/collect-deferred-variables.d.ts

@@ -0,0 +1,22 @@
+import type { Scope } from "@babel/traverse";
+import * as t from "@babel/types";
+type DeferredVariableInfo = {
+    variableName: string;
+    enclosingFunctionName: string;
+    scope: Scope;
+};
+/**
+ * Collect information about deferred top-level var declarations.
+ * A "deferred var" is declared at top-level without an initializer,
+ * then assigned inside a function.
+ */
+export declare const collectDeferredVariables: (ast: t.File, programScope: Scope) => {
+    deferredVariables: DeferredVariableInfo[];
+    nodesVisited: number;
+};
+/**
+ * Group deferred vars by their enclosing function.
+ * Returns only vars where the function has exactly ONE deferred var.
+ */
+export declare const filterToSingleVariableFunctions: (deferredVariables: DeferredVariableInfo[]) => DeferredVariableInfo[];
+export {};

package/dist/transforms/stabilize-deferred-top-level-bindings/collect-deferred-variables.js

@@ -0,0 +1,115 @@
+import { createRequire } from "node:module";
+import * as t from "@babel/types";
+import { isHashBasedStableName } from "../../core/stable-naming.js";
+import { findEnclosingBindingName } from "./rename-helpers.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+/**
+ * Collect information about deferred top-level var declarations.
+ * A "deferred var" is declared at top-level without an initializer,
+ * then assigned inside a function.
+ */
+export const collectDeferredVariables = (ast, programScope) => {
+    let nodesVisited = 0;
+    // Step 1: Find all top-level var declarations without initializers
+    const uninitializedVariables = new Set();
+    traverse(ast, {
+        VariableDeclaration(path) {
+            nodesVisited++;
+            if (path.parent.type !== "Program")
+                return;
+            if (path.node.kind !== "var")
+                return;
+            for (const decl of path.node.declarations) {
+                if (!decl.init && t.isIdentifier(decl.id)) {
+                    uninitializedVariables.add(decl.id.name);
+                }
+            }
+        },
+    });
+    // Step 2: Find assignments to these vars and track which function they're in
+    const variableAssignments = new Map();
+    traverse(ast, {
+        AssignmentExpression(path) {
+            nodesVisited++;
+            if (!t.isIdentifier(path.node.left))
+                return;
+            const variableName = path.node.left.name;
+            if (!uninitializedVariables.has(variableName))
+                return;
+            // Find enclosing function
+            const functionPath = path.findParent((p) => p.isFunction());
+            if (!functionPath) {
+                // Top-level assignment — mark as unsuitable. Preserve count from any
+                // earlier function-scoped assignment so the step-3 filter stays correct.
+                const existing = variableAssignments.get(variableName);
+                variableAssignments.set(variableName, {
+                    enclosingFunctionName: undefined,
+                    count: (existing?.count ?? 0) + 1,
+                });
+                return;
+            }
+            // Get the enclosing function's binding name
+            const functionName = findEnclosingBindingName(functionPath);
+            const existing = variableAssignments.get(variableName);
+            if (existing) {
+                existing.count++;
+                // If assigned in different functions or multiple times, mark as unsuitable
+                if (existing.enclosingFunctionName !== functionName) {
+                    existing.enclosingFunctionName = undefined;
+                }
+            }
+            else {
+                variableAssignments.set(variableName, {
+                    enclosingFunctionName: functionName,
+                    count: 1,
+                });
+            }
+        },
+    });
+    // Step 3: Filter to vars that:
+    // - Have exactly one assignment
+    // - Are assigned inside a function with a stable name
+    const deferredVariables = [];
+    for (const [variableName, info] of variableAssignments) {
+        if (info.count === 1 &&
+            info.enclosingFunctionName &&
+            isHashBasedStableName(info.enclosingFunctionName)) {
+            const binding = programScope.getBinding(variableName);
+            if (binding) {
+                deferredVariables.push({
+                    variableName,
+                    enclosingFunctionName: info.enclosingFunctionName,
+                    scope: binding.scope,
+                });
+            }
+        }
+    }
+    return { deferredVariables, nodesVisited };
+};
+/**
+ * Group deferred vars by their enclosing function.
+ * Returns only vars where the function has exactly ONE deferred var.
+ */
+export const filterToSingleVariableFunctions = (deferredVariables) => {
+    // Group by enclosing function
+    const byFunction = new Map();
+    for (const info of deferredVariables) {
+        const existing = byFunction.get(info.enclosingFunctionName);
+        if (existing) {
+            existing.push(info);
+        }
+        else {
+            byFunction.set(info.enclosingFunctionName, [info]);
+        }
+    }
+    // Only keep vars where function has exactly one
+    const result = [];
+    for (const variables of byFunction.values()) {
+        if (variables.length === 1 && variables[0]) {
+            result.push(variables[0]);
+        }
+    }
+    return result;
+};

package/dist/transforms/stabilize-deferred-top-level-bindings/manifest.json

@@ -0,0 +1,13 @@
+{
+    "recommended": true,
+    "notes": "Stabilizes top-level var declarations that are initialized inside stable-named functions (lazy init pattern). Only applies when the enclosing function has exactly one such deferred var to avoid order-dependent naming. Renames ~750 vars but diff reduction is minimal (0.03%) because most vars already have consistent minified names between versions. The stabilization helps when minifiers do vary names.",
+    "evaluations": {
+        "claude-code-2.1.10:claude-code-2.1.11": {
+            "diffSizePercent": 99.97,
+            "evaluatedAt": "2026-02-05T17:32:00.000Z",
+            "changedLines": 753,
+            "durationSeconds": 26,
+            "stableNames": 2110
+        }
+    }
+}

package/dist/transforms/stabilize-deferred-top-level-bindings/rename-helpers.d.ts

@@ -0,0 +1,24 @@
+import type { NodePath, Scope } from "@babel/traverse";
+/**
+ * Extract the hash suffix from a stable function name (`$h_` or `$f_` prefix).
+ * Does not match `$v_` names — those are deferred variables, not functions.
+ */
+export declare const extractHashFromStableName: (name: string) => string | undefined;
+/**
+ * Rename a binding by mutating AST nodes directly.
+ * Does NOT update Babel's internal scope bindings map — callers that rename
+ * multiple bindings in a loop must track used names externally
+ * (see `usedNewNames` in stabilize-deferred-stable-rhs) and re-parse
+ * afterwards to refresh scope state.
+ */
+export declare const renameBindingInPlace: (bindingScope: Scope, fromName: string, toName: string) => boolean;
+/**
+ * Check if we can safely rename a binding.
+ */
+export declare const canRenameBindingSafely: (bindingScope: Scope, fromName: string, toName: string) => boolean;
+/**
+ * Walk up the AST to find the binding name of the enclosing function.
+ * Handles `var $h_xxx = () => { ... }`, `$h_xxx = fn(() => { ... })`,
+ * and `function $h_xxx() { ... }`.
+ */
+export declare const findEnclosingBindingName: (path: NodePath) => string | undefined;

package/dist/transforms/stabilize-deferred-top-level-bindings/rename-helpers.js

@@ -0,0 +1,92 @@
+import * as t from "@babel/types";
+import { hasShadowingRisk } from "../../core/has-shadowing-risk.js";
+/**
+ * Extract the hash suffix from a stable function name (`$h_` or `$f_` prefix).
+ * Does not match `$v_` names — those are deferred variables, not functions.
+ */
+export const extractHashFromStableName = (name) => {
+    const match = name.match(/^\$[fh]_(.+)$/u);
+    return match?.[1];
+};
+/**
+ * Rename a binding by mutating AST nodes directly.
+ * Does NOT update Babel's internal scope bindings map — callers that rename
+ * multiple bindings in a loop must track used names externally
+ * (see `usedNewNames` in stabilize-deferred-stable-rhs) and re-parse
+ * afterwards to refresh scope state.
+ */
+export const renameBindingInPlace = (bindingScope, fromName, toName) => {
+    const binding = bindingScope.getBinding(fromName);
+    if (!binding)
+        return false;
+    // Rename the declaration site
+    binding.identifier.name = toName;
+    // Rename all references (Identifier and JSXIdentifier)
+    for (const referencePath of binding.referencePaths) {
+        if (t.isIdentifier(referencePath.node, { name: fromName })) {
+            referencePath.node.name = toName;
+        }
+        else if (t.isJSXIdentifier(referencePath.node, { name: fromName })) {
+            referencePath.node.name = toName;
+        }
+    }
+    // Rename mutation sites (assignments, updates, for-in/of)
+    for (const violationPath of binding.constantViolations) {
+        const node = violationPath.node;
+        if (t.isAssignmentExpression(node) &&
+            t.isIdentifier(node.left, { name: fromName })) {
+            node.left.name = toName;
+        }
+        else if (t.isUpdateExpression(node) &&
+            t.isIdentifier(node.argument, { name: fromName })) {
+            node.argument.name = toName;
+        }
+        else if ((t.isForInStatement(node) || t.isForOfStatement(node)) &&
+            t.isIdentifier(node.left, { name: fromName })) {
+            node.left.name = toName;
+        }
+    }
+    return true;
+};
+/**
+ * Check if we can safely rename a binding.
+ */
+export const canRenameBindingSafely = (bindingScope, fromName, toName) => {
+    if (fromName === toName)
+        return false;
+    if (bindingScope.hasOwnBinding(toName))
+        return false;
+    const programScope = bindingScope.getProgramParent();
+    if (Object.hasOwn(programScope.globals, toName))
+        return false;
+    const binding = bindingScope.getBinding(fromName);
+    if (!binding)
+        return false;
+    if (hasShadowingRisk(binding, bindingScope, toName))
+        return false;
+    return true;
+};
+/**
+ * Walk up the AST to find the binding name of the enclosing function.
+ * Handles `var $h_xxx = () => { ... }`, `$h_xxx = fn(() => { ... })`,
+ * and `function $h_xxx() { ... }`.
+ */
+export const findEnclosingBindingName = (path) => {
+    // FunctionDeclaration: the path itself carries the id
+    if (path.isFunctionDeclaration() && path.node.id) {
+        return path.node.id.name;
+    }
+    let current = path.parentPath;
+    while (current) {
+        if (current.isVariableDeclarator() && t.isIdentifier(current.node.id)) {
+            return current.node.id.name;
+        }
+        if (current.isAssignmentExpression() && t.isIdentifier(current.node.left)) {
+            return current.node.left.name;
+        }
+        if (current.isProgram())
+            break;
+        current = current.parentPath;
+    }
+    return undefined;
+};

package/dist/transforms/stabilize-deferred-top-level-bindings/stabilize-deferred-top-level-bindings-transform.d.ts

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

package/dist/transforms/stabilize-deferred-top-level-bindings/stabilize-deferred-top-level-bindings-transform.js

@@ -0,0 +1,68 @@
+import { createRequire } from "node:module";
+import { parse } from "@babel/parser";
+import { getFilesToProcess, } from "../../core/types.js";
+import { generateCode } from "../../cli/generate-code.js";
+import { collectDeferredVariables, filterToSingleVariableFunctions, } from "./collect-deferred-variables.js";
+import { canRenameBindingSafely, extractHashFromStableName, renameBindingInPlace, } from "./rename-helpers.js";
+const require = createRequire(import.meta.url);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+const traverse = require("@babel/traverse").default;
+export const stabilizeDeferredTopLevelBindingsTransform = {
+    id: "stabilize-deferred-top-level-bindings",
+    description: "Renames top-level var declarations without initializers (deferred bindings) to stable names " +
+        "derived from their enclosing stable function. Only applies when the function has exactly one " +
+        "such deferred var to avoid order-dependent naming.",
+    scope: "file",
+    parallelizable: true,
+    transform(context) {
+        let nodesVisited = 0;
+        let transformationsApplied = 0;
+        for (const fileInfo of getFilesToProcess(context)) {
+            const program = fileInfo.ast.program;
+            // Get program scope
+            let programScope;
+            traverse(fileInfo.ast, {
+                Program(path) {
+                    programScope = path.scope;
+                    path.stop();
+                },
+            });
+            if (!programScope)
+                continue;
+            // Collect deferred vars
+            const { deferredVariables, nodesVisited: fileNodesVisited } = collectDeferredVariables(fileInfo.ast, programScope);
+            nodesVisited += fileNodesVisited;
+            // Filter to vars where function has exactly one deferred var
+            const eligibleVariables = filterToSingleVariableFunctions(deferredVariables);
+            // Apply renames. Track used names for consistency with stabilize-deferred-stable-rhs,
+            // even though collisions are structurally prevented by unique enclosing function names.
+            const usedNewNames = new Set();
+            let fileTransformations = 0;
+            for (const { variableName, enclosingFunctionName, scope, } of eligibleVariables) {
+                const hash = extractHashFromStableName(enclosingFunctionName);
+                if (!hash)
+                    continue;
+                const newName = `$v_${hash}`;
+                if (usedNewNames.has(newName))
+                    continue;
+                if (!canRenameBindingSafely(scope, variableName, newName))
+                    continue;
+                if (renameBindingInPlace(scope, variableName, newName)) {
+                    usedNewNames.add(newName);
+                    fileTransformations++;
+                }
+            }
+            transformationsApplied += fileTransformations;
+            // Re-parse the AST to refresh Babel's scope bindings for subsequent transforms
+            if (fileTransformations > 0) {
+                const code = generateCode(fileInfo.ast);
+                const newAst = parse(code, {
+                    sourceType: program.sourceType,
+                    plugins: ["jsx", "typescript"],
+                });
+                fileInfo.ast = newAst;
+            }
+        }
+        return Promise.resolve({ nodesVisited, transformationsApplied });
+    },
+};

package/dist/transforms/stabilize-nested-bindings/collect-factory-bindings.js

@@ -1,6 +1,6 @@
 import * as t from "@babel/types";
 import { isStableRenamed } from "../../core/stable-naming.js";
-import { hashFingerprintNode } from "./hash-fingerprint-node.js";
+import { hashFingerprintNode } from "../../core/fingerprint/hash-fingerprint-node.js";
 /**
  * Collects local binding candidates from a factory callback body.
  */

package/dist/transforms/stabilize-nested-bindings/is-factory-callback.js

@@ -7,9 +7,5 @@ export const isFactoryCallback = (callback) => {
     const parameters = callback.params;
     if (parameters.length === 0 || parameters.length > 2)
         return false;
-    // Check if first param is an identifier (exports or module.exports pattern)
-    const firstParameter = parameters[0];
-    if (!t.isIdentifier(firstParameter))
-        return false;
-    return true;
+    return t.isIdentifier(parameters[0]);
 };

package/dist/transforms/stabilize-top-level-bindings/collect-rename-candidates.js

@@ -1,6 +1,6 @@
 import * as t from "@babel/types";
 import { isStableRenamed } from "../../core/stable-naming.js";
-import { hashFingerprintNode } from "./fingerprint-node.js";
+import { hashFingerprintNode } from "../../core/fingerprint/hash-fingerprint-node.js";
 import { collectFirstProgramBodyAssignments } from "./collect-first-program-body-assignments.js";
 import { collectNestedProgramScopeVariableInitializers } from "./collect-nested-program-scope-variable-initializers.js";
 import { addRenameCandidate } from "./rename-candidate.js";

package/package.json

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

package/dist/transforms/stabilize-nested-bindings/serialize-fingerprint-node.js

@@ -1,102 +0,0 @@
-import * as t from "@babel/types";
-import { fingerprintLeafNode } from "./fingerprint-leaf-node.js";
-import { fingerprintScalarFields } from "./fingerprint-scalar-fields.js";
-const pushArrayTasks = (stack, value) => {
-    stack.push({ kind: "text", text: "]" });
-    for (let index = value.length - 1; index >= 0; index--) {
-        if (index < value.length - 1) {
-            stack.push({ kind: "text", text: "," });
-        }
-        stack.push({ kind: "value", value: value[index] });
-    }
-    stack.push({ kind: "text", text: "[" });
-};
-const pushNodeTasks = (stack, node) => {
-    const leaf = fingerprintLeafNode(node);
-    if (leaf !== undefined) {
-        stack.push({ kind: "text", text: leaf });
-        return;
-    }
-    const keys = t.VISITOR_KEYS[node.type];
-    if (!keys) {
-        stack.push({ kind: "text", text: node.type });
-        return;
-    }
-    let visitorKeys = keys;
-    const computed = node.computed;
-    if (computed !== true &&
-        (node.type === "ObjectProperty" ||
-            node.type === "ObjectMethod" ||
-            node.type === "ClassMethod" ||
-            node.type === "ClassPrivateMethod" ||
-            node.type === "ClassProperty" ||
-            node.type === "ClassPrivateProperty")) {
-        visitorKeys = keys.filter((key) => key !== "key");
-    }
-    const nodeTasks = [{ kind: "text", text: node.type }];
-    for (const field of fingerprintScalarFields(node)) {
-        nodeTasks.push({ kind: "text", text: field });
-    }
-    for (const key of visitorKeys) {
-        nodeTasks.push({
-            kind: "value",
-            value: node[key],
-        });
-    }
-    for (let index = nodeTasks.length - 1; index >= 0; index--) {
-        const nodeTask = nodeTasks[index];
-        if (!nodeTask)
-            continue;
-        stack.push(nodeTask);
-        if (index !== 0) {
-            stack.push({ kind: "text", text: "|" });
-        }
-    }
-};
-export const writeFingerprintNode = (value, write) => {
-    const stack = [{ kind: "value", value }];
-    while (stack.length > 0) {
-        const task = stack.pop();
-        if (!task)
-            break;
-        if (task.kind === "text") {
-            write(task.text);
-            continue;
-        }
-        const current = task.value;
-        if (current === null) {
-            write("null");
-            continue;
-        }
-        if (current === undefined) {
-            write("undefined");
-            continue;
-        }
-        if (typeof current === "string") {
-            write(JSON.stringify(current));
-            continue;
-        }
-        if (typeof current === "number" || typeof current === "boolean") {
-            write(String(current));
-            continue;
-        }
-        if (Array.isArray(current)) {
-            pushArrayTasks(stack, current);
-            continue;
-        }
-        if (typeof current !== "object") {
-            write(JSON.stringify(current));
-            continue;
-        }
-        const nodeCandidate = current;
-        if (!("type" in nodeCandidate)) {
-            write("{}");
-            continue;
-        }
-        if (nodeCandidate.type === "Identifier") {
-            write("_");
-            continue;
-        }
-        pushNodeTasks(stack, nodeCandidate);
-    }
-};

package/dist/transforms/stabilize-top-level-bindings/fingerprint-leaf-node.d.ts

@@ -1,2 +0,0 @@
-import type { Node } from "@babel/types";
-export declare const fingerprintLeafNode: (node: Node) => string | undefined;

package/dist/transforms/stabilize-top-level-bindings/fingerprint-leaf-node.js

@@ -1,23 +0,0 @@
-export const fingerprintLeafNode = (node) => {
-    // Normalize identifiers — this is the key operation that makes fingerprints
-    // stable across minified name changes.
-    if (node.type === "Identifier")
-        return "_";
-    if (node.type === "StringLiteral")
-        return `S:${JSON.stringify(node.value)}`;
-    if (node.type === "NumericLiteral")
-        return `N:${node.value}`;
-    if (node.type === "BooleanLiteral")
-        return `B:${node.value}`;
-    if (node.type === "NullLiteral")
-        return "NL";
-    if (node.type === "BigIntLiteral")
-        return `BI:${JSON.stringify(node.value)}`;
-    if (node.type === "RegExpLiteral")
-        return `R:${JSON.stringify(node.pattern)}:${JSON.stringify(node.flags)}`;
-    if (node.type === "TemplateElement")
-        return `T:${JSON.stringify(node.value.raw)}`;
-    if (node.type === "DirectiveLiteral")
-        return `D:${JSON.stringify(node.value)}`;
-    return undefined;
-};

package/dist/transforms/stabilize-top-level-bindings/fingerprint-node.d.ts

@@ -1 +0,0 @@
-export declare const hashFingerprintNode: (node: unknown) => string;

package/dist/transforms/stabilize-top-level-bindings/fingerprint-node.js

@@ -1,9 +0,0 @@
-import { createHash } from "node:crypto";
-import { writeFingerprintNode } from "./serialize-fingerprint-node.js";
-export const hashFingerprintNode = (node) => {
-    const hasher = createHash("sha256");
-    writeFingerprintNode(node, (text) => {
-        hasher.update(text);
-    });
-    return hasher.digest("hex").slice(0, 16);
-};

package/dist/transforms/stabilize-top-level-bindings/fingerprint-scalar-fields.d.ts

@@ -1,2 +0,0 @@
-import type { Node } from "@babel/types";
-export declare const fingerprintScalarFields: (node: Node) => string[];

package/dist/transforms/stabilize-top-level-bindings/fingerprint-scalar-fields.js

@@ -1,153 +0,0 @@
-import * as t from "@babel/types";
-const encodeScalar = (value) => value === undefined ? "undefined" : JSON.stringify(value);
-export const fingerprintScalarFields = (node) => {
-    if (node.type === "AssignmentExpression" ||
-        node.type === "BinaryExpression" ||
-        node.type === "LogicalExpression" ||
-        node.type === "UnaryExpression") {
-        return [
-            `operator=${encodeScalar(node.operator)}`,
-        ];
-    }
-    if (node.type === "UpdateExpression") {
-        return [
-            `operator=${encodeScalar(node.operator)}`,
-            `prefix=${encodeScalar(node.prefix)}`,
-        ];
-    }
-    if (node.type === "MemberExpression" ||
-        node.type === "OptionalMemberExpression") {
-        const computed = node.computed;
-        const property = node
-            .property;
-        // Include non-computed property names to reduce collisions (e.g. `obj.foo` vs
-        // `obj.bar`). This trades some cross-build stability for fewer collisions if
-        // a toolchain mangles property names between builds.
-        const propertyName = computed === false && t.isIdentifier(property)
-            ? property.name
-            : computed === false && t.isPrivateName(property)
-                ? `#${property.id.name}`
-                : undefined;
-        return [
-            `computed=${encodeScalar(computed)}`,
-            `optional=${encodeScalar(node.optional)}`,
-            `propertyName=${encodeScalar(propertyName)}`,
-        ];
-    }
-    if (node.type === "OptionalCallExpression") {
-        return [
-            `optional=${encodeScalar(node.optional)}`,
-        ];
-    }
-    if (node.type === "VariableDeclaration") {
-        return [
-            `kind=${encodeScalar(node.kind)}`,
-        ];
-    }
-    if (node.type === "FunctionDeclaration" ||
-        node.type === "FunctionExpression" ||
-        node.type === "ArrowFunctionExpression" ||
-        node.type === "ObjectMethod" ||
-        node.type === "ClassMethod" ||
-        node.type === "ClassPrivateMethod") {
-        // Keep a uniform field set for all function-like nodes; some fields (e.g. `static`,
-        // `computed`, `kind`) only exist on specific node types and will be `undefined` otherwise.
-        const fields = [
-            `async=${encodeScalar(node.async)}`,
-            `generator=${encodeScalar(node.generator)}`,
-            `kind=${encodeScalar(node.kind)}`,
-            `static=${encodeScalar(node.static)}`,
-            `computed=${encodeScalar(node.computed)}`,
-        ];
-        if (node.type === "ObjectMethod") {
-            const computed = node.computed;
-            const key = node.key;
-            if (computed === true) {
-                // For computed keys, the fingerprint comes from the key expression itself.
-            }
-            else {
-                const keyName = t.isIdentifier(key)
-                    ? key.name
-                    : t.isStringLiteral(key)
-                        ? key.value
-                        : t.isNumericLiteral(key)
-                            ? String(key.value)
-                            : t.isPrivateName(key)
-                                ? `#${key.id.name}`
-                                : undefined;
-                fields.push(`keyName=${encodeScalar(keyName)}`);
-            }
-        }
-        if (node.type === "ClassMethod" || node.type === "ClassPrivateMethod") {
-            const computed = node.computed;
-            const key = node.key;
-            if (computed === true) {
-                // For computed keys, the fingerprint comes from the key expression itself.
-            }
-            else {
-                const keyName = t.isIdentifier(key)
-                    ? key.name
-                    : t.isStringLiteral(key)
-                        ? key.value
-                        : t.isNumericLiteral(key)
-                            ? String(key.value)
-                            : t.isPrivateName(key)
-                                ? `#${key.id.name}`
-                                : undefined;
-                fields.push(`keyName=${encodeScalar(keyName)}`);
-            }
-        }
-        return fields;
-    }
-    if (node.type === "ObjectProperty") {
-        const computed = node.computed;
-        const key = node.key;
-        const fields = [`computed=${encodeScalar(computed)}`];
-        if (computed === true) {
-            // For computed keys, the fingerprint comes from the key expression itself.
-            return fields;
-        }
-        const keyName = t.isIdentifier(key)
-            ? key.name
-            : t.isStringLiteral(key)
-                ? key.value
-                : t.isNumericLiteral(key)
-                    ? String(key.value)
-                    : t.isPrivateName(key)
-                        ? `#${key.id.name}`
-                        : undefined;
-        fields.push(`keyName=${encodeScalar(keyName)}`);
-        return fields;
-    }
-    if (node.type === "ClassProperty" || node.type === "ClassPrivateProperty") {
-        const computed = node.computed;
-        const key = node.key;
-        const keyName = computed === true
-            ? undefined
-            : t.isIdentifier(key)
-                ? key.name
-                : t.isStringLiteral(key)
-                    ? key.value
-                    : t.isNumericLiteral(key)
-                        ? String(key.value)
-                        : t.isPrivateName(key)
-                            ? `#${key.id.name}`
-                            : undefined;
-        return [
-            `static=${encodeScalar(node.static)}`,
-            `computed=${encodeScalar(computed)}`,
-            `keyName=${encodeScalar(keyName)}`,
-        ];
-    }
-    if (node.type === "ImportSpecifier") {
-        const imported = node
-            .imported;
-        const importedName = t.isIdentifier(imported)
-            ? imported.name
-            : t.isStringLiteral(imported)
-                ? imported.value
-                : undefined;
-        return [`importedName=${encodeScalar(importedName)}`];
-    }
-    return [];
-};

package/dist/transforms/stabilize-top-level-bindings/serialize-fingerprint-node.d.ts

@@ -1,3 +0,0 @@
-type Writer = (text: string) => void;
-export declare const writeFingerprintNode: (value: unknown, write: Writer) => void;
-export {};