ts-codemod-lib 2.2.0 → 2.2.2

package/dist/functions/ast-transformers/convert-to-readonly.mjs

@@ -2,6 +2,7 @@ import { ISet, Arr, pipe, match, mapNullable, isString } from 'ts-data-forge';
 import * as tsm from 'ts-morph';
 import { hasDisableNextLineComment } from '../functions/has-disable-next-line-comment.mjs';
 import { isAtomicTypeNode } from '../functions/is-atomic-type-node.mjs';
+import { isConditionalTypeDistributionGuard } from '../functions/is-conditional-type-distribution-guard.mjs';
 import { isReadonlyTypeReferenceNode, isReadonlyTupleOrArrayTypeNode, isReadonlyArrayTypeNode, isReadonlyTupleTypeNode } from '../functions/is-readonly-node.mjs';
 import { removeParentheses } from '../functions/remove-parentheses.mjs';
 import { shouldAvoidParenthesesForReadonly } from '../functions/should-avoid-parentheses-for-readonly.mjs';
@@ -12,863 +13,777 @@ import { invalidDeepReadonlyTypeName } from './readonly-transformer-helpers/cons
 import { groupUnionIntersectionTypes } from './readonly-transformer-helpers/group-union-types.mjs';
 import { nextReadonlyContext } from './readonly-transformer-helpers/readonly-context.mjs';
 
-const TRANSFORMER_NAME = 'convert-to-readonly';
+const TRANSFORMER_NAME = "convert-to-readonly";
 const convertToReadonlyTransformer = (options) => {
-    if (options?.DeepReadonly?.typeName !== undefined &&
-        invalidDeepReadonlyTypeName.has(options.DeepReadonly.typeName)) {
-        throw new Error(`Invalid DeepReadonly typeName "${options.DeepReadonly.typeName}" passed to convertToReadonlyType`);
-    }
-    const DeepReadonlyTypeName = options?.DeepReadonly?.typeName ?? 'DeepReadonly';
-    const ignorePrefixes = ISet.create(options?.ignorePrefixes ?? ['mut_', '#mut_', '_mut_', 'draft']);
-    const optionsInternal = {
-        DeepReadonly: {
-            typeName: DeepReadonlyTypeName,
-            applyLevel: 'keep',
-        },
-        ignoreEmptyObjectTypes: options?.ignoreEmptyObjectTypes ?? true,
-        ignoredPrefixes: ignorePrefixes,
-        debugPrint: options?.debug === true ? console.debug : () => { },
-        replaceNode: options?.debug === true
-            ? replaceNodeWithDebugPrint
-            : (node, newNodeText) => node.replaceWithText(newNodeText),
-    };
-    return {
-        name: TRANSFORMER_NAME,
-        transform: (sourceAst) => {
-            for (const node of sourceAst.getChildren()) {
-                transformNode(node, initialReadonlyContext, optionsInternal);
-            }
-        },
-    };
+  if (options?.DeepReadonly?.typeName !== void 0 && invalidDeepReadonlyTypeName.has(options.DeepReadonly.typeName)) {
+    throw new Error(
+      `Invalid DeepReadonly typeName "${options.DeepReadonly.typeName}" passed to convertToReadonlyType`
+    );
+  }
+  const DeepReadonlyTypeName = options?.DeepReadonly?.typeName ?? "DeepReadonly";
+  const ignorePrefixes = ISet.create(
+    options?.ignorePrefixes ?? ["mut_", "#mut_", "_mut_", "draft"]
+  );
+  const optionsInternal = {
+    DeepReadonly: {
+      typeName: DeepReadonlyTypeName,
+      applyLevel: "keep"
+    },
+    ignoreEmptyObjectTypes: options?.ignoreEmptyObjectTypes ?? true,
+    ignoredPrefixes: ignorePrefixes,
+    debugPrint: options?.debug === true ? console.debug : () => {
+    },
+    replaceNode: options?.debug === true ? replaceNodeWithDebugPrint : (node, newNodeText) => node.replaceWithText(newNodeText)
+  };
+  return {
+    name: TRANSFORMER_NAME,
+    transform: (sourceAst) => {
+      for (const node of sourceAst.getChildren()) {
+        transformNode(node, initialReadonlyContext, optionsInternal);
+      }
+    }
+  };
 };
 const initialReadonlyContext = {
-    type: 'none',
-    indexedAccessDepth: 0,
+  type: "none",
+  indexedAccessDepth: 0
 };
 const transformNode = (node, readonlyContext, options) => {
-    if (tsm.Node.isTypeNode(node) ||
-        node.isKind(tsm.SyntaxKind.InterfaceDeclaration) ||
-        node.isKind(tsm.SyntaxKind.ClassDeclaration)) {
-        options.debugPrint();
-        options.debugPrint(`transformNode [${node.getKindName()}] `);
-        options.debugPrint(node.getFullText());
-        options.debugPrint({ readonlyContext });
-        options.debugPrint();
-    }
-    if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
-        options.debugPrint('skipped by disable-next-line comment');
-        return;
-    }
-    // check for ignorePrefix
-    if (node.isKind(tsm.SyntaxKind.VariableDeclaration)) {
-        const nodeName = node.getName();
-        if (options.ignoredPrefixes.some((p) => nodeName.startsWith(p))) {
-            // Skip conversion for variable declarations with ignored prefixes
-            // Example: const mut_foo: string[] = []; -> remains as is, without appending `as const`
-            options.debugPrint('skipped variable declaration by ignorePrefixes');
-            return;
-        }
-        // TODO: Support ignoredPrefixes in ArrayBindingPattern
-        // if (ts.isArrayBindingPattern(nodeName)) {
-        //   // for (const [i, el] of nodeName.elements.entries())
-        // }
-        // TODO: Support ignoredPrefixes in ObjectBindingPattern
-        // if (ts.isObjectBindingPattern(nodeName)) {
-        //   // for (const [i, el] of nodeName.elements.entries())
-        // }
-    }
-    // Skip readonly conversion for function declarations with ignored prefixes
-    // Example: function mut_foo() {} -> parameters and return types remain as is
-    if ((node.isKind(tsm.SyntaxKind.FunctionDeclaration) ||
-        node.isKind(tsm.SyntaxKind.FunctionExpression)) &&
-        options.ignoredPrefixes.some((p) => node.getName()?.startsWith(p) === true)) {
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.Parameter)) {
-        const nodeName = node.getName();
-        if (options.ignoredPrefixes.some((p) => nodeName.startsWith(p))) {
-            // Skip readonly conversion for variable declarations with ignored prefixes
-            // Example: const mut_foo: string[] = []; -> remains as is, without readonly conversion
-            return;
-        }
-        // TODO: Support ignoredPrefixes in ArrayBindingPattern
-        // if (ts.isArrayBindingPattern(nodeName)) {
-        // }
-        // TODO: Support ignoredPrefixes in ObjectBindingPattern
-        // if (ts.isObjectBindingPattern(nodeName)) {
-        // }
-    }
-    // Skip readonly conversion for type alias declarations with ignored prefixes
-    // Example: type mut_Foo = number[]; -> remains as number[] without readonly
-    if (node.isKind(tsm.SyntaxKind.TypeAliasDeclaration) &&
-        options.ignoredPrefixes.some((p) => node.getName().startsWith(p))) {
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.TypeReference)) {
-        if (readonlyContext.type === 'readonly') {
-            throw new Error('Invalid readonlyContext "readonly" passed to TypeReferenceNode');
-        }
-        transformTypeReferenceNode(node, readonlyContext, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.ArrayType)) {
-        transformArrayTypeNode(node, readonlyContext, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.TupleType)) {
-        transformTupleTypeNode(node, readonlyContext, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.RestType)) {
-        transformRestTypeNode(node, readonlyContext, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.TypeOperator)) {
-        if (readonlyContext.type === 'readonly') {
-            throw new Error('Invalid readonlyContext "readonly" passed to TypeOperatorNode');
-        }
-        transformTypeOperatorNode(node, readonlyContext, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.TypeLiteral)) {
-        if (readonlyContext.type === 'readonly') {
-            throw new Error('Invalid readonlyContext "readonly" passed to TypeLiteralNode');
-        }
-        transformTypeLiteralNode(node, readonlyContext, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.IndexedAccessType)) {
-        transformIndexedAccessTypeNode(node, readonlyContext, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.MappedType)) {
-        if (readonlyContext.type === 'readonly') {
-            throw new Error('Invalid readonlyContext "readonly" passed to MappedTypeNode');
-        }
-        transformMappedTypeNode(node, readonlyContext, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.InterfaceDeclaration)) {
-        // Skip readonly conversion for interface declarations with ignored prefixes
-        // Example: interface mut_Interface {...} -> properties remain without readonly
-        if (options.ignoredPrefixes.some((p) => node.getName().startsWith(p))) {
-            return;
-        }
-        transformInterfaceDeclarationNode(node, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.ClassDeclaration)) {
-        // Skip readonly conversion for class declarations with ignored prefixes
-        // Example: class mut_Class {...} -> properties remain without readonly
-        if (options.ignoredPrefixes.some((p) => node.getName()?.startsWith(p) === true)) {
-            return;
-        }
-        transformClassDeclarationNode(node, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.IntersectionType)) {
-        if (readonlyContext.type === 'readonly') {
-            throw new Error('Invalid readonlyContext "readonly" passed to IntersectionTypeNode');
-        }
-        transformIntersectionTypeNode(node, readonlyContext, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.UnionType)) {
-        if (readonlyContext.type === 'readonly') {
-            throw new Error('Invalid readonlyContext "readonly" passed to UnionTypeNode');
-        }
-        transformUnionTypeNode(node, readonlyContext, options);
-        return;
-    }
-    if (node.isKind(tsm.SyntaxKind.ParenthesizedType)) {
-        // NOTE: readonlyContext を不変のままバケツリレーさせるためにこのケースも必要
-        transformParenthesizedTypeNode(node, readonlyContext, options);
-        return;
-    }
-    for (const child of node.getChildren()) {
-        transformNode(child, initialReadonlyContext, options);
-    }
+  if (tsm.Node.isTypeNode(node) || node.isKind(tsm.SyntaxKind.InterfaceDeclaration) || node.isKind(tsm.SyntaxKind.ClassDeclaration)) {
+    options.debugPrint();
+    options.debugPrint(`transformNode [${node.getKindName()}] `);
+    options.debugPrint(node.getFullText());
+    options.debugPrint({ readonlyContext });
+    options.debugPrint();
+  }
+  if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
+    options.debugPrint("skipped by disable-next-line comment");
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.VariableDeclaration)) {
+    const nodeName = node.getName();
+    if (options.ignoredPrefixes.some((p) => nodeName.startsWith(p))) {
+      options.debugPrint("skipped variable declaration by ignorePrefixes");
+      return;
+    }
+  }
+  if ((node.isKind(tsm.SyntaxKind.FunctionDeclaration) || node.isKind(tsm.SyntaxKind.FunctionExpression)) && options.ignoredPrefixes.some((p) => node.getName()?.startsWith(p) === true)) {
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.Parameter)) {
+    const nodeName = node.getName();
+    if (options.ignoredPrefixes.some((p) => nodeName.startsWith(p))) {
+      return;
+    }
+  }
+  if (node.isKind(tsm.SyntaxKind.TypeAliasDeclaration) && options.ignoredPrefixes.some((p) => node.getName().startsWith(p))) {
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.TypeReference)) {
+    if (readonlyContext.type === "readonly") {
+      throw new Error(
+        'Invalid readonlyContext "readonly" passed to TypeReferenceNode'
+      );
+    }
+    transformTypeReferenceNode(node, readonlyContext, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.ArrayType)) {
+    transformArrayTypeNode(node, readonlyContext, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.TupleType)) {
+    transformTupleTypeNode(node, readonlyContext, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.RestType)) {
+    transformRestTypeNode(node, readonlyContext, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.TypeOperator)) {
+    if (readonlyContext.type === "readonly") {
+      throw new Error(
+        'Invalid readonlyContext "readonly" passed to TypeOperatorNode'
+      );
+    }
+    transformTypeOperatorNode(node, readonlyContext, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.TypeLiteral)) {
+    if (readonlyContext.type === "readonly") {
+      throw new Error(
+        'Invalid readonlyContext "readonly" passed to TypeLiteralNode'
+      );
+    }
+    transformTypeLiteralNode(node, readonlyContext, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.IndexedAccessType)) {
+    transformIndexedAccessTypeNode(node, readonlyContext, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.MappedType)) {
+    if (readonlyContext.type === "readonly") {
+      throw new Error(
+        'Invalid readonlyContext "readonly" passed to MappedTypeNode'
+      );
+    }
+    transformMappedTypeNode(node, readonlyContext, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.InterfaceDeclaration)) {
+    if (options.ignoredPrefixes.some((p) => node.getName().startsWith(p))) {
+      return;
+    }
+    transformInterfaceDeclarationNode(node, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.ClassDeclaration)) {
+    if (options.ignoredPrefixes.some(
+      (p) => node.getName()?.startsWith(p) === true
+    )) {
+      return;
+    }
+    transformClassDeclarationNode(node, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.IntersectionType)) {
+    if (readonlyContext.type === "readonly") {
+      throw new Error(
+        'Invalid readonlyContext "readonly" passed to IntersectionTypeNode'
+      );
+    }
+    transformIntersectionTypeNode(node, readonlyContext, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.UnionType)) {
+    if (readonlyContext.type === "readonly") {
+      throw new Error(
+        'Invalid readonlyContext "readonly" passed to UnionTypeNode'
+      );
+    }
+    transformUnionTypeNode(node, readonlyContext, options);
+    return;
+  }
+  if (node.isKind(tsm.SyntaxKind.ParenthesizedType)) {
+    transformParenthesizedTypeNode(node, readonlyContext, options);
+    return;
+  }
+  for (const child of node.getChildren()) {
+    transformNode(child, initialReadonlyContext, options);
+  }
 };
-//
-// Transformer implementation for each node type
-//
-/**
- * - `tr(ReadonlyArray<E>) |-> readonly tr(E)[]`
- * - `tr(Readonly<Readonly<E>>) |-> Readonly<tr(E)>`
- * - `tr(DeepReadonly<Readonly<E>>) |-> DeepReadonly<tr(E)>`
- * - `tr(Readonly<number>) |-> number`
- * - `tr(Readonly<E[]>) |-> readonly tr(E)[]`
- * - `tr(Readonly<[E1, E2, E3]>) |-> readonly [tr(E1), tr(E2), tr(E3)]`
- * - `tr(Readonly<readonly E[]>) |-> readonly tr(E)[]`
- * - `tr(Readonly<readonly [E1, E2, E3]>) |-> readonly [tr(E1), tr(E2), tr(E3)]`
- * - `tr(Readonly<A | readonly E[]>) |-> Readonly<tr(A)> | readonly tr(E)[]>`
- */
-const transformTypeReferenceNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    const typeNameStr = node.getTypeName().getText();
-    const typeArguments = node.getTypeArguments();
-    // Array<T> / ReadonlyArray<T> to readonly T[]
-    if (typeNameStr === 'Array' || typeNameStr === 'ReadonlyArray') {
-        if (!Arr.isArrayOfLength(typeArguments, 1)) {
-            throw new Error(`Unexpected number of type arguments "${typeArguments.length}" for ${typeNameStr}.`);
-        }
-        // Recursive processing
-        transformNode(typeArguments[0], {
-            type: 'none',
-            indexedAccessDepth: readonlyContext.indexedAccessDepth,
-        }, options);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const T = node.getTypeArguments()[0];
-        options.replaceNode(node, readonlyContext.type === 'DeepReadonly'
-            ? wrapWithParentheses(`${wrapWithParentheses(T.getFullText())}[]`)
-            : wrapWithParentheses(`readonly ${wrapWithParentheses(T.getFullText())}[]`));
-        return;
-    }
-    // Set<T> to ReadonlySet<T>
-    if (typeNameStr === 'Set') {
-        if (!Arr.isArrayOfLength(typeArguments, 1)) {
-            throw new Error(`Unexpected number of type arguments "${typeArguments.length}" for Set.`);
-        }
-        // Recursive processing
-        transformNode(typeArguments[0], {
-            type: 'none',
-            indexedAccessDepth: readonlyContext.indexedAccessDepth,
-        }, options);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const T = node.getTypeArguments()[0];
-        options.replaceNode(node, `ReadonlySet<${T.getFullText()}>`);
-        return;
-    }
-    // Map<T> to ReadonlyMap<T>
-    if (typeNameStr === 'Map') {
-        if (!Arr.isArrayOfLength(typeArguments, 2)) {
-            throw new Error(`Unexpected number of type arguments "${typeArguments.length}" for Map.`);
-        }
-        const nextReadonlyContextValue = nextReadonlyContext({
-            currentReadonlyContext: readonlyContext,
-            nextReadonlyContextType: 'none',
-            indexedAccessDepthChange: 'keep',
-        });
-        // Recursive processing
-        for (const t of typeArguments) {
-            transformNode(t, nextReadonlyContextValue, options);
-        }
-        const [K, V] = node.getTypeArguments();
-        options.replaceNode(node, 
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        `ReadonlyMap<${K.getFullText()}, ${V.getFullText()}>`);
-        return;
-    }
-    // remove unnecessary `Readonly` wrapper or convert to readonly operator
-    if (typeNameStr === 'Readonly') {
-        if (!Arr.isArrayOfLength(typeArguments, 1)) {
-            throw new Error(`Unexpected number of type arguments "${typeArguments.length}" for Readonly.`);
-        }
-        // Recursive processing
-        transformNode(typeArguments[0], nextReadonlyContext({
-            currentReadonlyContext: readonlyContext,
-            nextReadonlyContextType: 'Readonly',
-            indexedAccessDepthChange: 'keep',
-        }), options);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const T = removeParentheses(node.getTypeArguments()[0]);
-        // DeepReadonly<Readonly<T>> -> DeepReadonly<T>
-        if (readonlyContext.type === 'DeepReadonly') {
-            options.replaceNode(node, T.getFullText());
-            return;
-        }
-        // Readonly<{ ... }>[I] -> { ... }[I]
-        if (readonlyContext.indexedAccessDepth > 0) {
-            options.replaceNode(node, T.getFullText());
-            return;
-        }
-        // Readonly<Readonly<T>> -> Readonly<T>
-        if (isReadonlyTypeReferenceNode(T)) {
-            options.replaceNode(node, T.getFullText());
-            return;
-        }
-        // Readonly<number> -> number
-        if (isAtomicTypeNode(T)) {
-            options.replaceNode(node, T.getFullText());
-            return;
-        }
-        // T = E[]
-        // Readonly<E[]> -> readonly E[]
-        //
-        // T = [E1, E2, E3]
-        // Readonly<[E1, E2, E3]> -> readonly [E1, E2, E3]
-        if (T.isKind(tsm.SyntaxKind.ArrayType) ||
-            T.isKind(tsm.SyntaxKind.TupleType)) {
-            const readonlyText = `readonly ${T.getFullText()}`;
-            options.replaceNode(node, shouldAvoidParenthesesForReadonly(node)
-                ? readonlyText
-                : wrapWithParentheses(readonlyText));
-            return;
-        }
-        // T = readonly E[] or readonly [E1, E2, E3]
-        // Readonly<readonly E[]> -> readonly E[]
-        // Readonly<readonly [E1, E2, E3]> -> readonly [E1, E2, E3]
-        if (isReadonlyTupleOrArrayTypeNode(T)) {
-            options.replaceNode(node, T.getFullText());
-            return;
-        }
-        // T = A | B | C
-        // T = A & B & C
-        if (T.isKind(tsm.SyntaxKind.UnionType) ||
-            T.isKind(tsm.SyntaxKind.IntersectionType)) {
-            options.replaceNode(node, T.getFullText());
-            return;
-        }
-        return;
-    }
-    // DeepReadonly
-    if (typeNameStr === options.DeepReadonly.typeName) {
-        if (!Arr.isArrayOfLength(typeArguments, 1)) {
-            throw new Error(`Unexpected number of type arguments "${typeArguments.length}" for Readonly.`);
-        }
-        // Recursive processing
-        transformNode(typeArguments[0], nextReadonlyContext({
-            currentReadonlyContext: readonlyContext,
-            nextReadonlyContextType: 'DeepReadonly',
-        }), options);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const T = node.getTypeArguments()[0];
-        // DeepReadonly<DeepReadonly<T>> -> DeepReadonly<T>
-        if (readonlyContext.type === 'DeepReadonly') {
-            options.replaceNode(node, T.getFullText());
-            return;
-        }
-        // Readonly<number> -> number
-        if (isAtomicTypeNode(T)) {
-            options.replaceNode(node, T.getFullText());
-            return;
-        }
-        // T = P[]
-        // DeepReadonly<P[]> -> readonly P[] (for primitive type arrays, convert to readonly P[] form)
-        // DeepReadonly<O[]> -> DeepReadonly<O[]> (for object type arrays, keep as is to recursively apply Readonly)
-        // DeepReadonly<P[][]> -> DeepReadonly<P[][]>
-        if (T.isKind(tsm.SyntaxKind.ArrayType) &&
-            isAtomicTypeNode(T.getElementTypeNode())) {
-            const readonlyText = `readonly ${T.getFullText()}`;
-            options.replaceNode(node, shouldAvoidParenthesesForReadonly(node)
-                ? readonlyText
-                : wrapWithParentheses(readonlyText));
-            return;
-        }
-        // T = [P1, P2, P3]
-        // DeepReadonly<[P1, P2, P3]> -> readonly [P1, P2, P3]
-        if (T.isKind(tsm.SyntaxKind.TupleType) &&
-            T.getElements().every(isAtomicTypeNode)) {
-            const readonlyText = `readonly ${T.getFullText()}`;
-            options.replaceNode(node, shouldAvoidParenthesesForReadonly(node)
-                ? readonlyText
-                : wrapWithParentheses(readonlyText));
-            return;
-        }
-        return;
-    }
-    {
-        const nextReadonlyContextValue = nextReadonlyContext({
-            currentReadonlyContext: readonlyContext,
-            nextReadonlyContextType: 'none',
-            indexedAccessDepthChange: 'keep',
-        });
-        // Recursive processing
-        for (const t of node.getTypeArguments()) {
-            transformNode(t, nextReadonlyContextValue, options);
-        }
+const transformTypeReferenceNode = (node, readonlyContext, options) => {
+  const typeNameStr = node.getTypeName().getText();
+  const typeArguments = node.getTypeArguments();
+  if (typeNameStr === "Array" || typeNameStr === "ReadonlyArray") {
+    if (!Arr.isArrayOfLength(typeArguments, 1)) {
+      throw new Error(
+        `Unexpected number of type arguments "${typeArguments.length}" for ${typeNameStr}.`
+      );
+    }
+    transformNode(
+      typeArguments[0],
+      {
+        type: "none",
+        indexedAccessDepth: readonlyContext.indexedAccessDepth
+      },
+      options
+    );
+    const T = node.getTypeArguments()[0];
+    options.replaceNode(
+      node,
+      readonlyContext.type === "DeepReadonly" ? wrapWithParentheses(`${wrapWithParentheses(T.getFullText())}[]`) : wrapWithParentheses(
+        `readonly ${wrapWithParentheses(T.getFullText())}[]`
+      )
+    );
+    return;
+  }
+  if (typeNameStr === "Set") {
+    if (!Arr.isArrayOfLength(typeArguments, 1)) {
+      throw new Error(
+        `Unexpected number of type arguments "${typeArguments.length}" for Set.`
+      );
+    }
+    transformNode(
+      typeArguments[0],
+      {
+        type: "none",
+        indexedAccessDepth: readonlyContext.indexedAccessDepth
+      },
+      options
+    );
+    const T = node.getTypeArguments()[0];
+    options.replaceNode(node, `ReadonlySet<${T.getFullText()}>`);
+    return;
+  }
+  if (typeNameStr === "Map") {
+    if (!Arr.isArrayOfLength(typeArguments, 2)) {
+      throw new Error(
+        `Unexpected number of type arguments "${typeArguments.length}" for Map.`
+      );
     }
-};
-/** `tr(E[]) |-> tr(E)[]` */
-const transformArrayTypeNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    // Recursive processing
-    transformNode(node.getElementTypeNode(), nextReadonlyContext({
+    const nextReadonlyContextValue = nextReadonlyContext({
+      currentReadonlyContext: readonlyContext,
+      nextReadonlyContextType: "none",
+      indexedAccessDepthChange: "keep"
+    });
+    for (const t of typeArguments) {
+      transformNode(t, nextReadonlyContextValue, options);
+    }
+    const [K, V] = node.getTypeArguments();
+    options.replaceNode(
+      node,
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      `ReadonlyMap<${K.getFullText()}, ${V.getFullText()}>`
+    );
+    return;
+  }
+  if (typeNameStr === "Readonly") {
+    if (!Arr.isArrayOfLength(typeArguments, 1)) {
+      throw new Error(
+        `Unexpected number of type arguments "${typeArguments.length}" for Readonly.`
+      );
+    }
+    transformNode(
+      typeArguments[0],
+      nextReadonlyContext({
+        currentReadonlyContext: readonlyContext,
+        nextReadonlyContextType: "Readonly",
+        indexedAccessDepthChange: "keep"
+      }),
+      options
+    );
+    const T = removeParentheses(node.getTypeArguments()[0]);
+    if (readonlyContext.type === "DeepReadonly") {
+      options.replaceNode(node, T.getFullText());
+      return;
+    }
+    if (readonlyContext.indexedAccessDepth > 0) {
+      options.replaceNode(node, T.getFullText());
+      return;
+    }
+    if (isReadonlyTypeReferenceNode(T)) {
+      options.replaceNode(node, T.getFullText());
+      return;
+    }
+    if (isAtomicTypeNode(T)) {
+      options.replaceNode(node, T.getFullText());
+      return;
+    }
+    if (T.isKind(tsm.SyntaxKind.ArrayType) || T.isKind(tsm.SyntaxKind.TupleType)) {
+      const readonlyText = `readonly ${T.getFullText()}`;
+      options.replaceNode(
+        node,
+        shouldAvoidParenthesesForReadonly(node) ? readonlyText : wrapWithParentheses(readonlyText)
+      );
+      return;
+    }
+    if (isReadonlyTupleOrArrayTypeNode(T)) {
+      options.replaceNode(node, T.getFullText());
+      return;
+    }
+    if (T.isKind(tsm.SyntaxKind.UnionType) || T.isKind(tsm.SyntaxKind.IntersectionType)) {
+      options.replaceNode(node, T.getFullText());
+      return;
+    }
+    return;
+  }
+  if (typeNameStr === options.DeepReadonly.typeName) {
+    if (!Arr.isArrayOfLength(typeArguments, 1)) {
+      throw new Error(
+        `Unexpected number of type arguments "${typeArguments.length}" for Readonly.`
+      );
+    }
+    transformNode(
+      typeArguments[0],
+      nextReadonlyContext({
         currentReadonlyContext: readonlyContext,
-        nextReadonlyContextType: 'none',
-        indexedAccessDepthChange: 'decr',
-    }), options);
-    switch (readonlyContext.type) {
-        case 'DeepReadonly':
-        case 'readonly':
-            return; // remain tr(E)[] as is
-        // Unnecessary `Readonly` wrapper will be remove in transformTypeReferenceNode
-        case 'Readonly':
-        case 'none':
-            if (readonlyContext.indexedAccessDepth === 0) {
-                const readonlyText = `readonly ${node.getFullText()}`;
-                options.replaceNode(node, shouldAvoidParenthesesForReadonly(node)
-                    ? readonlyText
-                    : wrapWithParentheses(readonlyText));
-            }
+        nextReadonlyContextType: "DeepReadonly"
+      }),
+      options
+    );
+    const T = node.getTypeArguments()[0];
+    if (readonlyContext.type === "DeepReadonly") {
+      options.replaceNode(node, T.getFullText());
+      return;
+    }
+    if (isAtomicTypeNode(T)) {
+      options.replaceNode(node, T.getFullText());
+      return;
+    }
+    if (T.isKind(tsm.SyntaxKind.ArrayType) && isAtomicTypeNode(T.getElementTypeNode())) {
+      const readonlyText = `readonly ${T.getFullText()}`;
+      options.replaceNode(
+        node,
+        shouldAvoidParenthesesForReadonly(node) ? readonlyText : wrapWithParentheses(readonlyText)
+      );
+      return;
+    }
+    if (T.isKind(tsm.SyntaxKind.TupleType) && T.getElements().every(isAtomicTypeNode)) {
+      const readonlyText = `readonly ${T.getFullText()}`;
+      options.replaceNode(
+        node,
+        shouldAvoidParenthesesForReadonly(node) ? readonlyText : wrapWithParentheses(readonlyText)
+      );
+      return;
+    }
+    return;
+  }
+  {
+    const nextReadonlyContextValue = nextReadonlyContext({
+      currentReadonlyContext: readonlyContext,
+      nextReadonlyContextType: "none",
+      indexedAccessDepthChange: "keep"
+    });
+    for (const t of node.getTypeArguments()) {
+      transformNode(t, nextReadonlyContextValue, options);
     }
+  }
 };
-/** `tr([E1, E2, E3])` |-> `[tr(E1), tr(E2), tr(E3)]` */
-const transformTupleTypeNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    // Recursive processing
-    {
-        const nextReadonlyContextValue = nextReadonlyContext({
-            currentReadonlyContext: readonlyContext,
-            nextReadonlyContextType: 'none',
-            indexedAccessDepthChange: 'decr',
-        });
-        for (const el of node.getElements()) {
-            if (el.isKind(tsm.SyntaxKind.NamedTupleMember)) {
-                if (options.ignoredPrefixes.every((p) => !el.getName().startsWith(p))) {
-                    transformNode(el.getTypeNode(), nextReadonlyContextValue, options);
-                }
-            }
-            else {
-                transformNode(el, nextReadonlyContextValue, options);
-            }
-        }
-    }
-    switch (readonlyContext.type) {
-        case 'DeepReadonly':
-        case 'readonly':
-            return; // remain tr(E)[] as is
-        // Unnecessary `Readonly` wrapper will be remove in transformTypeReferenceNode
-        case 'Readonly':
-        case 'none':
-            if (readonlyContext.indexedAccessDepth === 0) {
-                const readonlyText = `readonly ${node.getFullText()}`;
-                options.replaceNode(node, shouldAvoidParenthesesForReadonly(node)
-                    ? readonlyText
-                    : wrapWithParentheses(readonlyText));
-            }
-    }
+const transformArrayTypeNode = (node, readonlyContext, options) => {
+  transformNode(
+    node.getElementTypeNode(),
+    nextReadonlyContext({
+      currentReadonlyContext: readonlyContext,
+      nextReadonlyContextType: "none",
+      indexedAccessDepthChange: "decr"
+    }),
+    options
+  );
+  switch (readonlyContext.type) {
+    case "DeepReadonly":
+    case "readonly":
+      return;
+    // remain tr(E)[] as is
+    // Unnecessary `Readonly` wrapper will be remove in transformTypeReferenceNode
+    case "Readonly":
+    case "none":
+      if (readonlyContext.indexedAccessDepth === 0 && !isConditionalTypeDistributionGuard(node)) {
+        const readonlyText = `readonly ${node.getFullText()}`;
+        options.replaceNode(
+          node,
+          shouldAvoidParenthesesForReadonly(node) ? readonlyText : wrapWithParentheses(readonlyText)
+        );
+      }
+  }
 };
-/** `tr("...T")` |-> `...tr(T)` */
-const transformRestTypeNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    // Recursive processing
-    transformNode(node.getTypeNode() /* = T */, nextReadonlyContext({
-        currentReadonlyContext: readonlyContext,
-        nextReadonlyContextType: 'none',
-        indexedAccessDepthChange: 'decr',
-    }), options);
-    const R = removeParentheses(node.getTypeNode());
-    // `tr("...readonly E[]") |-> ...tr(E)[]`
-    // `tr("...readonly [E1, E2]") |-> ...[tr(E1), tr(E2)]`
-    if (isReadonlyArrayTypeNode(R) || isReadonlyTupleTypeNode(R)) {
-        options.replaceNode(node, `...${R.getTypeNode().getFullText()}` /* = tr(E)[] or [tr(E1), tr(E2)] */);
-    }
+const transformTupleTypeNode = (node, readonlyContext, options) => {
+  {
+    const nextReadonlyContextValue = nextReadonlyContext({
+      currentReadonlyContext: readonlyContext,
+      nextReadonlyContextType: "none",
+      indexedAccessDepthChange: "decr"
+    });
+    for (const el of node.getElements()) {
+      if (el.isKind(tsm.SyntaxKind.NamedTupleMember)) {
+        if (options.ignoredPrefixes.every((p) => !el.getName().startsWith(p))) {
+          transformNode(el.getTypeNode(), nextReadonlyContextValue, options);
+        }
+      } else {
+        transformNode(el, nextReadonlyContextValue, options);
+      }
+    }
+  }
+  switch (readonlyContext.type) {
+    case "DeepReadonly":
+    case "readonly":
+      return;
+    // remain tr(E)[] as is
+    // Unnecessary `Readonly` wrapper will be remove in transformTypeReferenceNode
+    case "Readonly":
+    case "none":
+      if (readonlyContext.indexedAccessDepth === 0 && !isConditionalTypeDistributionGuard(node)) {
+        const readonlyText = `readonly ${node.getFullText()}`;
+        options.replaceNode(
+          node,
+          shouldAvoidParenthesesForReadonly(node) ? readonlyText : wrapWithParentheses(readonlyText)
+        );
+      }
+  }
 };
-/**
- * - `readonly T[][] |-> readonly (readonly T[])[]`
- * - `keyof { a: number[] } |-> keyof Readonly<{ a: readonly number[] }>`
- */
-const transformTypeOperatorNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    // Recursive processing
-    transformNode(node.getTypeNode(), nextReadonlyContext({
-        currentReadonlyContext: readonlyContext,
-        nextReadonlyContextType: node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword
-            ? 'readonly'
-            : 'none',
-        indexedAccessDepthChange: 'decr',
-    }), options);
-    switch (readonlyContext.type) {
-        // DeepReadonly<readonly E[]> -> DeepReadonly<E[]>
-        case 'DeepReadonly':
-            options.replaceNode(node, node.getTypeNode().getFullText());
-            return;
-        case 'Readonly':
-        case 'none':
-            if (readonlyContext.indexedAccessDepth > 0) {
-                options.replaceNode(node, node.getTypeNode().getFullText());
-            }
-    }
+const transformRestTypeNode = (node, readonlyContext, options) => {
+  transformNode(
+    node.getTypeNode(),
+    nextReadonlyContext({
+      currentReadonlyContext: readonlyContext,
+      nextReadonlyContextType: "none",
+      indexedAccessDepthChange: "decr"
+    }),
+    options
+  );
+  const R = removeParentheses(node.getTypeNode());
+  if (isReadonlyArrayTypeNode(R) || isReadonlyTupleTypeNode(R)) {
+    options.replaceNode(
+      node,
+      `...${R.getTypeNode().getFullText()}`
+    );
+  }
 };
-// `{ readonly member: V } |-> Readonly<{ member: V }>`
-const transformTypeLiteralNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    if (options.ignoreEmptyObjectTypes &&
-        Arr.isArrayOfLength(node.getMembers(), 0)) {
-        return;
-    }
-    // Recursive processing
-    transformMembers(node.getMembers(), 'remove', nextReadonlyContext({
-        currentReadonlyContext: readonlyContext,
-        nextReadonlyContextType: 'none',
-        indexedAccessDepthChange: 'decr',
-    }), options);
-    switch (readonlyContext.type) {
-        case 'DeepReadonly':
-        case 'Readonly':
-            // Don't wrap with Readonly if already readonly
-            return;
-        case 'none': {
-            if (readonlyContext.indexedAccessDepth === 0) {
-                // `{ readonly x: X, readonly y: Y } |-> Readonly<{ x: X, y: Y }>`
-                options.replaceNode(node, `Readonly<${node.getFullText()}>`);
-            }
-        }
-    }
+const transformTypeOperatorNode = (node, readonlyContext, options) => {
+  transformNode(
+    node.getTypeNode(),
+    nextReadonlyContext({
+      currentReadonlyContext: readonlyContext,
+      nextReadonlyContextType: node.getOperator() === tsm.SyntaxKind.ReadonlyKeyword ? "readonly" : "none",
+      indexedAccessDepthChange: "decr"
+    }),
+    options
+  );
+  switch (readonlyContext.type) {
+    // DeepReadonly<readonly E[]> -> DeepReadonly<E[]>
+    case "DeepReadonly":
+      options.replaceNode(node, node.getTypeNode().getFullText());
+      return;
+    case "Readonly":
+    case "none":
+      if (readonlyContext.indexedAccessDepth > 0) {
+        options.replaceNode(node, node.getTypeNode().getFullText());
+      }
+  }
 };
-/** `tr([A, B, C][I])` |-> `[tr(A), tr(B), tr(C)][I]` */
-const transformIndexedAccessTypeNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    // Recursive processing
-    transformNode(node.getObjectTypeNode(), nextReadonlyContext({
-        currentReadonlyContext: readonlyContext,
-        nextReadonlyContextType: 'none',
-        indexedAccessDepthChange: 'incr',
-    }), options);
-    transformNode(node.getIndexTypeNode() /* = I */, nextReadonlyContext({
-        currentReadonlyContext: readonlyContext,
-        nextReadonlyContextType: 'Readonly',
-        indexedAccessDepthChange: 'decr',
-    }), options);
+const transformTypeLiteralNode = (node, readonlyContext, options) => {
+  if (options.ignoreEmptyObjectTypes && Arr.isArrayOfLength(node.getMembers(), 0)) {
+    return;
+  }
+  transformMembers(
+    node.getMembers(),
+    "remove",
+    nextReadonlyContext({
+      currentReadonlyContext: readonlyContext,
+      nextReadonlyContextType: "none",
+      indexedAccessDepthChange: "decr"
+    }),
+    options
+  );
+  switch (readonlyContext.type) {
+    case "DeepReadonly":
+    case "Readonly":
+      return;
+    case "none": {
+      if (readonlyContext.indexedAccessDepth === 0) {
+        options.replaceNode(node, `Readonly<${node.getFullText()}>`);
+      }
+    }
+  }
 };
-/**
- * - `{ [key in Obj]: V }` -> `Readonly<{ [key in Obj]: V }>`
- * - `{ -readonly [key in Obj]: V }` -> `Readonly<{ [key in Obj]: V }>`
- * - `{ readonly [key in Obj]: V }` -> `Readonly<{ [key in Obj]: V }>`
- * - `{ +readonly [key in Obj]: V }` -> `Readonly<{ [key in Obj]: V }>`
- */
-const transformMappedTypeNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    const typeNode = node.getTypeNode();
-    if (typeNode !== undefined) {
-        transformNode(typeNode, nextReadonlyContext({
-            currentReadonlyContext: readonlyContext,
-            nextReadonlyContextType: 'none',
-            indexedAccessDepthChange: 'decr',
-        }), options);
-    }
-    const questionTokenText = pipe(node.getQuestionToken()?.getText()).mapNullable((t) => t === '?' ? '?' : t === '-' ? '-?' : t === '+' ? '+?' : undefined).value ?? '';
-    const result = pipe(
+const transformIndexedAccessTypeNode = (node, readonlyContext, options) => {
+  transformNode(
+    node.getObjectTypeNode(),
+    nextReadonlyContext({
+      currentReadonlyContext: readonlyContext,
+      nextReadonlyContextType: "none",
+      indexedAccessDepthChange: "incr"
+    }),
+    options
+  );
+  transformNode(
+    node.getIndexTypeNode(),
+    nextReadonlyContext({
+      currentReadonlyContext: readonlyContext,
+      nextReadonlyContextType: "Readonly",
+      indexedAccessDepthChange: "decr"
+    }),
+    options
+  );
+};
+const transformMappedTypeNode = (node, readonlyContext, options) => {
+  const typeNode = node.getTypeNode();
+  if (typeNode !== void 0) {
+    transformNode(
+      typeNode,
+      nextReadonlyContext({
+        currentReadonlyContext: readonlyContext,
+        nextReadonlyContextType: "none",
+        indexedAccessDepthChange: "decr"
+      }),
+      options
+    );
+  }
+  const questionTokenText = pipe(node.getQuestionToken()?.getText()).mapNullable(
+    (t) => t === "?" ? "?" : t === "-" ? "-?" : t === "+" ? "+?" : void 0
+  ).value ?? "";
+  const result = pipe(
     // remove readonlyToken
-    `{ [${node.getTypeParameter().getFullText()}]${questionTokenText}: ${node.getTypeNode()?.getFullText()} }`).map((mpt) => match(readonlyContext.type, {
-        // Don't wrap with Readonly if already readonly or unnecessary
-        DeepReadonly: mpt,
-        Readonly: mpt,
-        none: readonlyContext.indexedAccessDepth > 0 ? mpt : `Readonly<${mpt}>`,
-    })).value;
-    options.replaceNode(node, result);
+    `{ [${node.getTypeParameter().getFullText()}]${questionTokenText}: ${node.getTypeNode()?.getFullText()} }`
+  ).map(
+    (mpt) => match(readonlyContext.type, {
+      // Don't wrap with Readonly if already readonly or unnecessary
+      DeepReadonly: mpt,
+      Readonly: mpt,
+      none: readonlyContext.indexedAccessDepth > 0 ? mpt : `Readonly<${mpt}>`
+    })
+  ).value;
+  options.replaceNode(node, result);
 };
-// Making interface members readonly
-const transformInterfaceDeclarationNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, options) => {
-    for (const param of node.getTypeParameters()) {
-        transformNode(param, initialReadonlyContext, options);
-    }
-    for (const n of node.getHeritageClauses()) {
-        transformNode(n, initialReadonlyContext, options);
-    }
-    transformMembers(node.getMembers(), 'add', initialReadonlyContext, options);
+const transformInterfaceDeclarationNode = (node, options) => {
+  for (const param of node.getTypeParameters()) {
+    transformNode(param, initialReadonlyContext, options);
+  }
+  for (const n of node.getHeritageClauses()) {
+    transformNode(n, initialReadonlyContext, options);
+  }
+  transformMembers(node.getMembers(), "add", initialReadonlyContext, options);
 };
-const transformClassDeclarationNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, options) => {
-    for (const n of node.getTypeParameters()) {
-        transformNode(n, initialReadonlyContext, options);
-    }
-    for (const n of node.getHeritageClauses()) {
-        transformNode(n, initialReadonlyContext, options);
-    }
-    for (const mb of node.getMembers()) {
-        if (hasDisableNextLineComment(mb)) {
-            options.debugPrint('skipped member by disable-next-line comment');
-            continue;
-        }
-        if (mb.isKind(tsm.SyntaxKind.PropertyDeclaration)) {
-            if (!checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options)) {
-                mb.setIsReadonly(true);
-                const type = mb.getTypeNode();
-                if (type !== undefined) {
-                    transformNode(type, initialReadonlyContext, options);
-                }
-                const initializer = mb.getInitializer();
-                if (initializer !== undefined) {
-                    transformNode(initializer, initialReadonlyContext, options);
-                }
-            }
-            continue;
-        }
-        // MethodDeclaration, GetAccessorDeclaration, SetAccessorDeclaration
-        // Check if method name has ignored prefix (e.g., mut_)
-        if ((mb.isKind(tsm.SyntaxKind.MethodDeclaration) ||
-            mb.isKind(tsm.SyntaxKind.GetAccessor) ||
-            mb.isKind(tsm.SyntaxKind.SetAccessor)) &&
-            checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options)) {
-            options.debugPrint('skipped method by ignored prefix');
-            continue;
-        }
-        transformNode(mb, initialReadonlyContext, options);
-    }
-    for (const mb of node.getChildrenOfKind(tsm.SyntaxKind.IndexSignature)) {
-        transformIndexSignatureDeclaration(mb, 'add', initialReadonlyContext, options);
-    }
-    for (const ctor of node.getConstructors()) {
-        for (const param of ctor.getParameters()) {
-            if (hasDisableNextLineComment(param)) {
-                options.debugPrint('skipped class constructor parameter by disable-next-line comment');
-                continue;
-            }
-            {
-                const name = param.getName();
-                if (options.ignoredPrefixes.some((p) => name.startsWith(p))) {
-                    continue;
-                }
-            }
-            // Check if parameter is a property declaration (public/protected/private)
-            const scope = param.getScope();
-            // public -> public readonly
-            // protected -> protected readonly
-            // private -> private readonly
-            if (scope === tsm.Scope.Public ||
-                scope === tsm.Scope.Protected ||
-                scope === tsm.Scope.Private) {
-                param.setIsReadonly(true);
-            }
-            const type = param.getTypeNode();
-            if (type !== undefined) {
-                transformNode(type, initialReadonlyContext, options);
-            }
-        }
-        const body = ctor.getBody();
-        if (body !== undefined) {
-            transformNode(body, initialReadonlyContext, options);
-        }
-        continue;
-    }
+const transformClassDeclarationNode = (node, options) => {
+  for (const n of node.getTypeParameters()) {
+    transformNode(n, initialReadonlyContext, options);
+  }
+  for (const n of node.getHeritageClauses()) {
+    transformNode(n, initialReadonlyContext, options);
+  }
+  for (const mb of node.getMembers()) {
+    if (hasDisableNextLineComment(mb)) {
+      options.debugPrint("skipped member by disable-next-line comment");
+      continue;
+    }
+    if (mb.isKind(tsm.SyntaxKind.PropertyDeclaration)) {
+      if (!checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options)) {
+        mb.setIsReadonly(true);
+        const type = mb.getTypeNode();
+        if (type !== void 0) {
+          transformNode(type, initialReadonlyContext, options);
+        }
+        const initializer = mb.getInitializer();
+        if (initializer !== void 0) {
+          transformNode(initializer, initialReadonlyContext, options);
+        }
+      }
+      continue;
+    }
+    if ((mb.isKind(tsm.SyntaxKind.MethodDeclaration) || mb.isKind(tsm.SyntaxKind.GetAccessor) || mb.isKind(tsm.SyntaxKind.SetAccessor)) && checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options)) {
+      options.debugPrint("skipped method by ignored prefix");
+      continue;
+    }
+    transformNode(mb, initialReadonlyContext, options);
+  }
+  for (const mb of node.getChildrenOfKind(tsm.SyntaxKind.IndexSignature)) {
+    transformIndexSignatureDeclaration(
+      mb,
+      "add",
+      initialReadonlyContext,
+      options
+    );
+  }
+  for (const ctor of node.getConstructors()) {
+    for (const param of ctor.getParameters()) {
+      transformConstructorParameter(param, options);
+    }
+    const body = ctor.getBody();
+    if (body !== void 0) {
+      transformNode(body, initialReadonlyContext, options);
+    }
+  }
 };
-/**
- * - `tr(A & B) -> tr(A) & tr(B)`
- * - `tr(Readonly<A> & Readonly<B>) -> Readonly<tr(A) & tr(B)>`
- */
-const transformIntersectionTypeNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, '&');
+const transformConstructorParameter = (param, options) => {
+  if (hasDisableNextLineComment(param)) {
+    options.debugPrint(
+      "skipped class constructor parameter by disable-next-line comment"
+    );
+    return;
+  }
+  const name = param.getName();
+  if (options.ignoredPrefixes.some((p) => name.startsWith(p))) {
+    return;
+  }
+  const scope = param.getScope();
+  if (scope === tsm.Scope.Public || scope === tsm.Scope.Protected || scope === tsm.Scope.Private) {
+    param.setIsReadonly(true);
+  }
+  const type = param.getTypeNode();
+  if (type !== void 0) {
+    transformNode(type, initialReadonlyContext, options);
+  }
 };
-/**
- * - `tr(A | B) |-> tr(A) | tr(B)`
- * - `tr(Readonly<A> | Readonly<B>) |-> Readonly<tr(A) | tr(B)>`
- */
-const transformUnionTypeNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, '|');
+const transformIntersectionTypeNode = (node, readonlyContext, options) => {
+  transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, "&");
 };
-const transformUnionOrIntersectionTypeNodeImpl = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options, operator) => {
-    const nextReadonlyContextValue = nextReadonlyContext({
-        currentReadonlyContext: readonlyContext,
-        nextReadonlyContextType: 'none',
-        indexedAccessDepthChange: 'keep',
-    });
-    // Recursive processing
-    for (const n of node.getTypeNodes() /* = [A, B] */) {
-        transformNode(n, nextReadonlyContextValue, options);
-    }
-    const newTypes = node.getTypeNodes();
-    const { primitives, arraysAndTuples, typeLiterals, others } = groupUnionIntersectionTypes(newTypes);
-    options.debugPrint({ primitives, arraysAndTuples, typeLiterals, others });
-    // Separate empty type literals from non-empty ones when ignoreEmptyObjectTypes is true
-    const isEmptyTypeLiteral = (
-    // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-    n) => n.isKind(tsm.SyntaxKind.TypeLiteral) &&
-        Arr.isArrayOfLength(n.getMembers(), 0);
-    const nonEmptyTypeLiterals = typeLiterals === undefined
-        ? undefined
-        : options.ignoreEmptyObjectTypes
-            ? typeLiterals.nodes.filter((n) => !isEmptyTypeLiteral(n))
-            : typeLiterals.nodes;
-    const emptyTypeLiterals = typeLiterals === undefined || !options.ignoreEmptyObjectTypes
-        ? undefined
-        : typeLiterals.nodes.filter((n) => isEmptyTypeLiteral(n));
-    const typeLiteralsWrappedWithReadonly = nonEmptyTypeLiterals === undefined ||
-        Arr.isArrayOfLength(nonEmptyTypeLiterals, 0)
-        ? []
-        : [
-            unionToString({
-                types: nonEmptyTypeLiterals.map((n) => isReadonlyTypeReferenceNode(n)
-                    ? // NOTE: Readonly<A & B> -> (A & B)
-                        unwrapReadonlyTypeArgText(n)
-                    : n.getFullText()),
-                op: operator,
-                wrapWithReadonly: nextReadonlyContextValue.type !== 'DeepReadonly' &&
-                    nextReadonlyContextValue.indexedAccessDepth === 0,
-            }),
-        ];
-    // Sort by first occurrence (preserving the original union order as much as possible)
-    const sorted = [
-        mapNullable(primitives, (a) => [a.nodes.map((n) => n.getFullText()), a.firstPosition]),
-        mapNullable(arraysAndTuples, (a) => [a.nodes.map((n) => n.getFullText()), a.firstPosition]),
-        nonEmptyTypeLiterals !== undefined && Arr.isNonEmpty(nonEmptyTypeLiterals)
-            ? mapNullable(typeLiterals, (a) => [typeLiteralsWrappedWithReadonly, a.firstPosition])
-            : undefined,
-        emptyTypeLiterals !== undefined && Arr.isNonEmpty(emptyTypeLiterals)
-            ? mapNullable(typeLiterals, (a) => [
-                emptyTypeLiterals.map((n) => n.getFullText()),
-                // Use a position after non-empty type literals if they exist
-                a.firstPosition +
-                    (nonEmptyTypeLiterals !== undefined &&
-                        Arr.isNonEmpty(nonEmptyTypeLiterals)
-                        ? 0.5
-                        : 0),
-            ])
-            : undefined,
-        mapNullable(others, (a) => [
-            a.nodes.map((n) => wrapWithParentheses(n.getFullText())),
-            a.firstPosition,
-        ]),
-    ]
-        .filter((x) => x !== undefined)
-        .toSorted((a, b) => a[1] - b[1])
-        .flatMap((a) => a[0]);
-    // Readonly<number & { x: X } & { y: Y } & readonly E[]>
-    // -> number & readonly E[] & Readonly<{ x: X } & { y: Y }>
-    // Readonly<number | { x: X } | { y: Y } | readonly E[]>
-    // -> number | readonly E[] | Readonly<{ x: X } | { y: Y }>
-    options.replaceNode(node, unionToString({ types: sorted, op: operator, wrapWithReadonly: false }));
+const transformUnionTypeNode = (node, readonlyContext, options) => {
+  transformUnionOrIntersectionTypeNodeImpl(node, readonlyContext, options, "|");
 };
-const unionToString = ({ types, op, wrapWithReadonly, }) => Arr.isArrayOfLength(types, 0)
-    ? 'never'
-    : Arr.isArrayOfLength(types, 1)
-        ? wrapWithReadonly === false
-            ? wrapWithParentheses(types[0])
-            : `${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types[0]}>`
-        : wrapWithReadonly === false
-            ? wrapWithParentheses(types.join(` ${op} `))
-            : `${isString(wrapWithReadonly) ? wrapWithReadonly : 'Readonly'}<${types.join(` ${op} `)}>`;
-/** Convert ((T)) -> (T) recursively */
-const transformParenthesizedTypeNode = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyContext, options) => {
-    const typeNode = node.getTypeNode();
-    if (typeNode.isKind(tsm.SyntaxKind.ParenthesizedType)) {
-        // Recursive processing
-        transformParenthesizedTypeNode(typeNode, readonlyContext, options);
-    }
-    transformNode(node.getTypeNode(), readonlyContext, options);
-    const T = node.getTypeNode();
-    if (
+const transformUnionOrIntersectionTypeNodeImpl = (node, readonlyContext, options, operator) => {
+  const nextReadonlyContextValue = nextReadonlyContext({
+    currentReadonlyContext: readonlyContext,
+    nextReadonlyContextType: "none",
+    indexedAccessDepthChange: "keep"
+  });
+  for (const n of node.getTypeNodes()) {
+    transformNode(n, nextReadonlyContextValue, options);
+  }
+  const newTypes = node.getTypeNodes();
+  const { primitives, arraysAndTuples, typeLiterals, others } = groupUnionIntersectionTypes(newTypes);
+  options.debugPrint({ primitives, arraysAndTuples, typeLiterals, others });
+  const isEmptyTypeLiteral = (n) => n.isKind(tsm.SyntaxKind.TypeLiteral) && Arr.isArrayOfLength(n.getMembers(), 0);
+  const nonEmptyTypeLiterals = typeLiterals === void 0 ? void 0 : options.ignoreEmptyObjectTypes ? typeLiterals.nodes.filter((n) => !isEmptyTypeLiteral(n)) : typeLiterals.nodes;
+  const emptyTypeLiterals = typeLiterals === void 0 || !options.ignoreEmptyObjectTypes ? void 0 : typeLiterals.nodes.filter((n) => isEmptyTypeLiteral(n));
+  const typeLiteralsWrappedWithReadonly = nonEmptyTypeLiterals === void 0 || Arr.isArrayOfLength(nonEmptyTypeLiterals, 0) ? [] : [
+    unionToString({
+      types: nonEmptyTypeLiterals.map(
+        (n) => isReadonlyTypeReferenceNode(n) ? (
+          // NOTE: Readonly<A & B> -> (A & B)
+          unwrapReadonlyTypeArgText(n)
+        ) : n.getFullText()
+      ),
+      op: operator,
+      wrapWithReadonly: nextReadonlyContextValue.type !== "DeepReadonly" && nextReadonlyContextValue.indexedAccessDepth === 0
+    })
+  ];
+  const sorted = [
+    mapNullable(
+      primitives,
+      (a) => [a.nodes.map((n) => n.getFullText()), a.firstPosition]
+    ),
+    mapNullable(
+      arraysAndTuples,
+      (a) => [a.nodes.map((n) => n.getFullText()), a.firstPosition]
+    ),
+    nonEmptyTypeLiterals !== void 0 && Arr.isNonEmpty(nonEmptyTypeLiterals) ? mapNullable(
+      typeLiterals,
+      (a) => [typeLiteralsWrappedWithReadonly, a.firstPosition]
+    ) : void 0,
+    emptyTypeLiterals !== void 0 && Arr.isNonEmpty(emptyTypeLiterals) ? mapNullable(
+      typeLiterals,
+      (a) => [
+        emptyTypeLiterals.map((n) => n.getFullText()),
+        // Use a position after non-empty type literals if they exist
+        a.firstPosition + (nonEmptyTypeLiterals !== void 0 && Arr.isNonEmpty(nonEmptyTypeLiterals) ? 0.5 : 0)
+      ]
+    ) : void 0,
+    mapNullable(
+      others,
+      (a) => [
+        a.nodes.map((n) => wrapWithParentheses(n.getFullText())),
+        a.firstPosition
+      ]
+    )
+  ].filter((x) => x !== void 0).toSorted((a, b) => a[1] - b[1]).flatMap((a) => a[0]);
+  options.replaceNode(
+    node,
+    unionToString({ types: sorted, op: operator, wrapWithReadonly: false })
+  );
+};
+const unionToString = ({
+  types,
+  op,
+  wrapWithReadonly
+}) => Arr.isArrayOfLength(types, 0) ? "never" : Arr.isArrayOfLength(types, 1) ? wrapWithReadonly === false ? wrapWithParentheses(types[0]) : `${isString(wrapWithReadonly) ? wrapWithReadonly : "Readonly"}<${types[0]}>` : wrapWithReadonly === false ? wrapWithParentheses(types.join(` ${op} `)) : `${isString(wrapWithReadonly) ? wrapWithReadonly : "Readonly"}<${types.join(` ${op} `)}>`;
+const transformParenthesizedTypeNode = (node, readonlyContext, options) => {
+  const typeNode = node.getTypeNode();
+  if (typeNode.isKind(tsm.SyntaxKind.ParenthesizedType)) {
+    transformParenthesizedTypeNode(typeNode, readonlyContext, options);
+  }
+  transformNode(node.getTypeNode(), readonlyContext, options);
+  const T = node.getTypeNode();
+  if (
     // remove () if T is TypeReferenceNode
     // e.g. `(Readonly<A>) |-> Readonly<A>`
-    T.isKind(tsm.SyntaxKind.TypeReference) ||
-        // remove () if T is ArrayTypeNode
-        // e.g. `(A[]) |-> A[]`
-        T.isKind(tsm.SyntaxKind.ArrayType) ||
-        // remove () if T is TupleTypeNode
-        // e.g. `([A]) |-> [A]`
-        T.isKind(tsm.SyntaxKind.TupleType) ||
-        // remove () if T is PrimitiveTypeNode
-        // e.g. `(number) |-> number`
-        isAtomicTypeNode(T) ||
-        // remove () if T is TypeLiteralNode
-        // e.g. `({ member: V }) |-> { member: V }`
-        T.isKind(tsm.SyntaxKind.TypeLiteral)) {
-        options.replaceNode(node, T.getFullText());
-    }
+    T.isKind(tsm.SyntaxKind.TypeReference) || // remove () if T is ArrayTypeNode
+    // e.g. `(A[]) |-> A[]`
+    T.isKind(tsm.SyntaxKind.ArrayType) || // remove () if T is TupleTypeNode
+    // e.g. `([A]) |-> [A]`
+    T.isKind(tsm.SyntaxKind.TupleType) || // remove () if T is PrimitiveTypeNode
+    // e.g. `(number) |-> number`
+    isAtomicTypeNode(T) || // remove () if T is TypeLiteralNode
+    // e.g. `({ member: V }) |-> { member: V }`
+    T.isKind(tsm.SyntaxKind.TypeLiteral) || // collapse redundant nested parentheses if T is itself a ParenthesizedType
+    // e.g. `((X)) |-> (X)`
+    //
+    // This is what makes the transform terminate on nested parentheses. The
+    // union/intersection handler defensively wraps its result in parentheses
+    // for precedence safety, which turns `(A | B)` into `((A | B))` when the
+    // union already sits inside a `ParenthesizedType`. Collapsing the redundant
+    // outer layer here means each pass removes exactly the layer the wrapping
+    // added, so the parentheses no longer grow without bound (which previously
+    // overflowed the parser stack on inputs like `type T = (('a' | 'b'))`).
+    T.isKind(tsm.SyntaxKind.ParenthesizedType)
+  ) {
+    options.replaceNode(node, T.getFullText());
+  }
 };
-/**
- * `tr(["member1: V1", "member2: V2", "member3: V3"])`
- *
- * -> `["member1: tr(V1)", "member2: tr(V2)", "member3: tr(V3)"]`
- */
-const transformMembers = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-members, readonlyModifier, readonlyContext, options) => {
-    for (const mb of members) {
-        if (hasDisableNextLineComment(mb)) {
-            options.debugPrint('skipped by member disable-next-line comment');
-            continue;
-        }
-        if (mb.isKind(tsm.SyntaxKind.PropertySignature)) {
-            if (!checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options)) {
-                transformPropertySignature(mb, readonlyModifier, readonlyContext, options);
-            }
-            continue;
-        }
-        if (mb.isKind(tsm.SyntaxKind.IndexSignature)) {
-            transformIndexSignatureDeclaration(mb, readonlyModifier, readonlyContext, options);
-            continue;
-        }
-        transformNode(mb, readonlyContext, options);
-        continue;
-    }
+const transformMembers = (members, readonlyModifier, readonlyContext, options) => {
+  for (const mb of members) {
+    if (hasDisableNextLineComment(mb)) {
+      options.debugPrint("skipped by member disable-next-line comment");
+      continue;
+    }
+    if (mb.isKind(tsm.SyntaxKind.PropertySignature)) {
+      if (!checkIfPropertyNameShouldBeIgnored(mb.getNameNode(), options)) {
+        transformPropertySignature(
+          mb,
+          readonlyModifier,
+          readonlyContext,
+          options
+        );
+      }
+      continue;
+    }
+    if (mb.isKind(tsm.SyntaxKind.IndexSignature)) {
+      transformIndexSignatureDeclaration(
+        mb,
+        readonlyModifier,
+        readonlyContext,
+        options
+      );
+      continue;
+    }
+    transformNode(mb, readonlyContext, options);
+    continue;
+  }
 };
-const transformPropertySignature = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyModifier, readonlyContext, options) => {
-    if (readonlyContext.type === 'DeepReadonly' ||
-        readonlyModifier === 'remove') {
-        node.setIsReadonly(false);
-    }
-    else {
-        node.setIsReadonly(true);
-    }
-    {
-        const type = node.getTypeNode();
-        if (type !== undefined) {
-            transformNode(type, readonlyContext, options);
-        }
-    }
+const transformPropertySignature = (node, readonlyModifier, readonlyContext, options) => {
+  if (readonlyContext.type === "DeepReadonly" || readonlyModifier === "remove") {
+    node.setIsReadonly(false);
+  } else {
+    node.setIsReadonly(true);
+  }
+  {
+    const type = node.getTypeNode();
+    if (type !== void 0) {
+      transformNode(type, readonlyContext, options);
+    }
+  }
 };
-const transformIndexSignatureDeclaration = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-node, readonlyModifier, readonlyContext, options) => {
-    if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
-        options.debugPrint('skipped index signature by disable-next-line comment');
-        return;
-    }
-    if (readonlyContext.type === 'DeepReadonly' ||
-        readonlyModifier === 'remove') {
-        // node.setIsReadonly(false);
-        node.toggleModifier('readonly', false);
-    }
-    else {
-        node.toggleModifier('readonly', true);
-        // node.setIsReadonly(true);
-    }
-    {
-        const key = node.getKeyTypeNode();
-        transformNode(key, readonlyContext, options);
-    }
-    {
-        const ret = node.getReturnTypeNode();
-        if (ret !== undefined) {
-            transformNode(ret, readonlyContext, options);
-        }
-    }
+const transformIndexSignatureDeclaration = (node, readonlyModifier, readonlyContext, options) => {
+  if (hasDisableNextLineComment(node, TRANSFORMER_NAME)) {
+    options.debugPrint("skipped index signature by disable-next-line comment");
+    return;
+  }
+  if (readonlyContext.type === "DeepReadonly" || readonlyModifier === "remove") {
+    node.toggleModifier("readonly", false);
+  } else {
+    node.toggleModifier("readonly", true);
+  }
+  {
+    const key = node.getKeyTypeNode();
+    transformNode(key, readonlyContext, options);
+  }
+  {
+    const ret = node.getReturnTypeNode();
+    if (ret !== void 0) {
+      transformNode(ret, readonlyContext, options);
+    }
+  }
 };
-const checkIfPropertyNameShouldBeIgnored = (
-// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-nameNode, options) => {
-    return (
+const checkIfPropertyNameShouldBeIgnored = (nameNode, options) => {
+  return (
     // mut_x: number[]
-    (nameNode.isKind(tsm.SyntaxKind.Identifier) &&
-        pipe(nameNode.getText()).map((nm) => options.ignoredPrefixes.some((p) => nm.startsWith(p))).value) ||
-        // "mut_x": number[]
-        (nameNode.isKind(tsm.SyntaxKind.StringLiteral) &&
-            pipe(nameNode.getLiteralValue()).map((nm) => options.ignoredPrefixes.some((p) => nm.startsWith(p))).value) ||
-        //  #memberName: number[] (class only)
-        (nameNode.isKind(tsm.SyntaxKind.PrivateIdentifier) &&
-            pipe(nameNode.getText()).map((nm) => options.ignoredPrefixes.some((p) => nm.startsWith(`#${p}`))).value) ||
-        // [`mut_x`]: number[]
-        (nameNode.isKind(tsm.SyntaxKind.ComputedPropertyName) &&
-            pipe(nameNode.getExpression()).map((exp) => {
-                if (exp.isKind(tsm.SyntaxKind.StringLiteral)) {
-                    const nm = exp.getLiteralValue();
-                    return options.ignoredPrefixes.some((p) => nm.startsWith(p));
-                }
-                return false;
-            }).value));
+    nameNode.isKind(tsm.SyntaxKind.Identifier) && pipe(nameNode.getText()).map(
+      (nm) => options.ignoredPrefixes.some((p) => nm.startsWith(p))
+    ).value || // "mut_x": number[]
+    nameNode.isKind(tsm.SyntaxKind.StringLiteral) && pipe(nameNode.getLiteralValue()).map(
+      (nm) => options.ignoredPrefixes.some((p) => nm.startsWith(p))
+    ).value || //  #memberName: number[] (class only)
+    nameNode.isKind(tsm.SyntaxKind.PrivateIdentifier) && pipe(nameNode.getText()).map(
+      (nm) => options.ignoredPrefixes.some((p) => nm.startsWith(`#${p}`))
+    ).value || // [`mut_x`]: number[]
+    nameNode.isKind(tsm.SyntaxKind.ComputedPropertyName) && pipe(nameNode.getExpression()).map((exp) => {
+      if (exp.isKind(tsm.SyntaxKind.StringLiteral)) {
+        const nm = exp.getLiteralValue();
+        return options.ignoredPrefixes.some((p) => nm.startsWith(p));
+      }
+      return false;
+    }).value
+  );
 };
 
 export { convertToReadonlyTransformer };